func initializePalindromeTests() []palindromeTestPair {
l1 := ds.LinkedList{} // palindrome
l2 := ds.LinkedList{} // non-palindrome
// create a palindrome list
// move until half of the list to create a palindrome list
for i := 0; i < 5; i++ {
n := ds.Node{}
n.SetValue(i)
l1.Add(&n)
}
// move from half of the list to create a palindrome list
for i := 5; i >= 0; i-- {
n := ds.Node{}
n.SetValue(i)
l1.Add(&n)
}
// create a non-palindrome list
for i := 0; i < 10; i++ {
n := ds.Node{}
n.SetValue(i)
l2.Add(&n)
}
// we can expand test cases
var palindromeTests = []palindromeTestPair{
{l1, true},
{l2, false},
}
return palindromeTests
}
// partition given list into two parts due to the given value
// and then merge them together.
func PartitionList(l datastructures.LinkedList, value int) datastructures.LinkedList {
beforeValue := datastructures.LinkedList{}
afterValue := datastructures.LinkedList{}
head := l.Head()
for head != nil {
n := datastructures.Node{}
n.SetValue(head.GetValue())
if head.GetValue() < value {
beforeValue.Add(&n)
} else {
afterValue.Add(&n)
}
head = head.Next()
}
beforeValue.SetTail(afterValue.Head())
return beforeValue
}
func initializeForwardList() []sumLinkedListForwardTestPair {
l1 := datastructures.LinkedList{}
l2 := datastructures.LinkedList{}
// l1 : 1->2->3->4 = 1234
// l2 : 1->2->3 = 123
// summed value = 1357
value := 1357
// Create l1 : 1->2->3->4 = 1234
for i := 1; i < 5; i++ {
n := datastructures.Node{}
n.SetValue(i)
l1.Add(&n)
}
// Create l2 : 1->2->3 = 123
for i := 1; i < 4; i++ {
n := datastructures.Node{}
n.SetValue(i)
l2.Add(&n)
}
// we can expand test cases
var forwardTests = []sumLinkedListForwardTestPair{
{l1, l2, value},
}
return forwardTests
}
func initializeReverseList() []sumLinkedListReverseTestPair {
l1 := datastructures.LinkedList{}
l2 := datastructures.LinkedList{}
// l2 : 1->2->3 = 321
// l1 : 1->2->3->4 = 4321
// summed value = 4642
value := 4642
// Create l1 : 1->2->3->4 = 4321
for i := 1; i < 5; i++ {
n := datastructures.Node{}
n.SetValue(i)
if i == 4 {
l1.Add(&n)
continue
}
l1.Add(&n)
}
// Create l2 : 1->2->3 = 321
for i := 1; i < 4; i++ {
n := datastructures.Node{}
n.SetValue(i)
l2.Add(&n)
}
// we can expand test cases
var reverseTests = []sumLinkedListReverseTestPair{
{l1, l2, value},
}
return reverseTests
}
func initializeLoopedList() []findCorruptNodeTestPair {
l1 := ds.LinkedList{}
l2 := ds.LinkedList{}
node := &ds.Node{}
// Create a looped linked list
// 0->1->2->3->4->5->6->3->4->5->6->3->4->5->6...
for i := 0; i < 6; i++ {
n := ds.Node{}
n.SetValue(i)
l1.Add(&n)
if i == 5 {
temp := l1.Head().Next().Next().Next()
node = temp
l1.Add(temp)
}
}
// Create a non-looped linked list
for i := 0; i < 10; i++ {
n := ds.Node{}
n.SetValue(i)
l2.Add(&n)
}
// we can expand test cases
var loopTests = []findCorruptNodeTestPair{
{l1, node},
{l2, nil}, // no loop
}
return loopTests
}
func initializePartitionList() []partitionListTestPair {
orig := datastructures.LinkedList{}
result := datastructures.LinkedList{}
value := 4
for i := 0; i < 10; i++ {
n := datastructures.Node{}
n.SetValue(i)
// Set before values
if i < value {
orig.Add(&n)
// Set after values
} else {
result.Add(&n)
}
}
// we can expand test cases
var partitionListTests = []partitionListTestPair{
{orig, result, value},
}
return partitionListTests
}
func TestDeleteNode(t *testing.T) {
deleteNodeTests := initializeDeleteNode()
for _, test := range deleteNodeTests {
// save original list in a temporary list
temp := datastructures.LinkedList{}
for elem := range test.orig.GetElements() {
n := datastructures.Node{}
n.SetValue(elem)
temp.Add(&n)
}
DeleteNode(&test.node)
// item by item check through two lists
for i := 0; i < test.orig.Len(); i++ {
if test.orig.Find(i) != test.result.Find(i) {
t.Error("For ", temp.GetElements(),
"Expected", test.result.GetElements(),
"got", test.orig.GetElements())
}
}
}
}
func initializeDeleteNode() []deleteNodeTestPair {
node := datastructures.Node{}
orig := datastructures.LinkedList{}
target := datastructures.LinkedList{}
for i := 0; i < 10; i++ {
n := datastructures.Node{}
n.SetValue(i)
orig.Add(&n)
// will delete this node
// so, don't add this node to result list
if i == 4 {
node = n
} else {
target.Add(&n)
}
}
// we can expand test cases
var deleteNodeTests = []deleteNodeTestPair{
{orig, target, node},
}
return deleteNodeTests
}
// deletes a node inside the linked list.
// we assume that, we are not given access to the head of the linked list.
// You only have access to that node.
func DeleteNode(n *datastructures.Node) {
if n.Next() != nil {
n.SetValue(n.Next().GetValue())
n.SetNext(n.Next().Next())
}
}