// Finds the first node of the loop
func FindCorruptNode(l ds.LinkedList) *ds.Node {
head := l.Head()
slowRunner := head
fastRunner := head.Next()
corruptNode := &ds.Node{}
// Find the Collusion
for {
// There is no loop
if slowRunner.Next() == nil || fastRunner.Next() == nil {
return nil
}
// Move slow runner one point
slowRunner = slowRunner.Next()
// Move fast runner two points
fastRunner = fastRunner.Next().Next()
// Are they matched ?
if slowRunner == fastRunner {
fastRunner = fastRunner.Next()
break
}
}
// Find the collision point
slowRunner = head
for {
if slowRunner == fastRunner {
corruptNode = slowRunner
break
}
// Move one point ahead for two of runners
slowRunner = slowRunner.Next()
fastRunner = fastRunner.Next()
}
return corruptNode
}
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
}
// Gives sliced linked list from kth element to last element.
// Also it assumes that, we don't know size&last element of the linkedlist.
func Slice(l datastructures.LinkedList, kth int) *datastructures.LinkedList {
if kth <= 0 {
return nil
}
current := l.Head()
runner := current
sliced_list := datastructures.LinkedList{}
count := 0
for current != nil {
runner = current
if count == kth {
sliced_list.SetHead(current)
for runner != nil {
runner = runner.Next()
}
break
sliced_list.SetTail(current)
}
count++
current = current.Next()
}
if sliced_list.Head() != nil {
return &sliced_list
} else {
return nil
}
}
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 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
}
// Removes duplicate nodes inside the given linkedlist
func RemoveDuplicates(l *datastructures.LinkedList) {
current := l.Head()
for current != nil {
runner := current
for runner.Next() != nil {
if runner.Next().GetValue() == current.GetValue() {
runner.SetNext(runner.Next().Next())
} else {
runner = runner.Next()
}
}
current = current.Next()
}
}
// checks wheter given list is palindrome
func IsPalindrome(l ds.LinkedList) bool {
head := l.Head()
// reverse given list
reversed_list := reverseList(l)
reversed_head := reversed_list.Head()
// checks items until half of the list
for i := 0; i < l.Len()/2; i++ {
if head.GetValue() != reversed_head.GetValue() {
return false
}
head = head.Next()
reversed_head = reversed_head.Next()
}
return true
}
// reverse given list
func reverseList(l ds.LinkedList) ds.LinkedList {
temp := l.Copy()
reversed_list := ds.LinkedList{}
head := temp.Head()
current_node := head
var prev_node *ds.Node
for {
if current_node != nil {
next_node := current_node.Next()
current_node.SetNext(prev_node)
prev_node = current_node
current_node = next_node
} else {
reversed_list.SetHead(prev_node)
break
}
}
return reversed_list
}
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 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())
}
}
}
}
// Sum up two linked list in reverse order
// Input:(7-> 1 -> 6) + (5 -> 9 -> 2).Thatis,617 + 295.
// Output: 2 -> 1 -> 9.That is, 912.
// we assume that, result integer does not exceed integer size
func SumLinkedListReverse(l1 ds.LinkedList, l2 ds.LinkedList) int {
head1 := l1.Head()
head2 := l2.Head()
num1 := 0
num2 := 0
multiplier := 1
// convert l1 list to int
for head1 != nil {
num1 += multiplier * head1.GetValue()
multiplier = multiplier * 10
head1 = head1.Next()
}
multiplier = 1
// convert l2 list to int
for head2 != nil {
num2 += multiplier * head2.GetValue()
multiplier = multiplier * 10
head2 = head2.Next()
}
return num1 + num2
}
// Sum up two linked list in forward order
// Input:(6 -> 1 -> 7) + (2 -> 9 -> 5).Thatis,617 + 295.
// Output: 9 -> 1 -> 2.That is, 912.
// we assume that, result integer does not exceed integer size
func SumLinkedListForward(l1 ds.LinkedList, l2 ds.LinkedList) int {
head1 := l1.Head()
head2 := l2.Head()
num1 := 0
num2 := 0
multiplier1 := exp(10, l1.Len()-1)
multiplier2 := exp(10, l2.Len()-1)
// convert l1 list to int
for head1 != nil {
num1 += multiplier1 * head1.GetValue()
multiplier1 = multiplier1 / 10
head1 = head1.Next()
}
// convert l2 list to int
for head2 != nil {
num2 += multiplier2 * head2.GetValue()
multiplier2 = multiplier2 / 10
head2 = head2.Next()
}
return num1 + num2
}
func initializeSlice() []sliceTestPair {
orig := datastructures.LinkedList{}
for i := 0; i < 10; i++ {
n := &datastructures.Node{}
n.SetValue(i)
orig.Add(n)
}
target := datastructures.LinkedList{}
for i := 3; i < 10; i++ {
n := &datastructures.Node{}
n.SetValue(i)
target.Add(n)
}
var sliceTests = []sliceTestPair{
{orig, &target, 3},
{orig, nil, 30},
{orig, nil, -3},
}
return sliceTests
}
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 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
}
func TestRemoveDuplicates(t *testing.T) {
l := datastructures.LinkedList{}
for i := 0; i <= 10; i++ {
n := &datastructures.Node{}
n.SetValue(i % 3)
l.Add(n)
}
RemoveDuplicates(&l)
if l.Len() != 3 {
t.Error("Wrong length, Len() must be", 3)
}
if l.Find(0) == nil || l.Find(1) == nil || l.Find(2) == nil {
t.Error("Wrong deletion for one of the elements.")
}
}
// 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
}