public void Should_Add_Before()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(3);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
var node5 = new MySinglyLinkedListNode <int>(5);
var list = new MySinglyLinkedList <int>(node1);
//act
list.AddBefore(node3, node5);
//assert
list.Count.ShouldBeEquivalentTo(5);
list.Head.Should().NotBeNull();
list.Head.Data.ShouldBeEquivalentTo(1);
list.Head.Next.Data.ShouldBeEquivalentTo(2);
list.Head.Next.Next.Data.ShouldBeEquivalentTo(5);
list.Head.Next.Next.Next.Data.ShouldBeEquivalentTo(3);
list.Head.Next.Next.Next.Next.Data.ShouldBeEquivalentTo(4);
}
public void DeleteMiddleNode(MySinglyLinkedListNode <int> node)
{
if (node == null)
{
throw new ArgumentNullException();
}
if (node.Next == null)
{
throw new ArgumentException();
}
var head = node.Next;
MySinglyLinkedListNode <int> prev = null;
while (head != null)
{
node.Data = head.Data;
prev = node;
node = node.Next;
head = head.Next;
}
if (prev != null)
{
prev.Next = null;
}
}
public void Intersaction_Should_Check_Different_Length()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(3);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
var node5 = new MySinglyLinkedListNode <int>(5);
node5.Next = node3;
var first = new MySinglyLinkedList <int>(node1);
var second = new MySinglyLinkedList <int>(node5);
//act
var result = _linkedList.Intersaction(first, second);
//assert
result.ShouldBeEquivalentTo(node3);
}
public void Should_Remove_False()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(3);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
var list = new MySinglyLinkedList <int>(node1);
//act
var result = list.Remove(new MySinglyLinkedListNode <int>(5));
//assert
result.ShouldBeEquivalentTo(false);
list.Count.ShouldBeEquivalentTo(4);
list.Head.Data.ShouldBeEquivalentTo(1);
list.Head.Next.Data.ShouldBeEquivalentTo(2);
list.Head.Next.Next.Data.ShouldBeEquivalentTo(3);
list.Head.Next.Next.Next.Data.ShouldBeEquivalentTo(4);
}
public void Should_Check_Copy_To()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(3);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
var list = new MySinglyLinkedList <int>(node1);
var array = new int[6];
//act
list.CopyTo(array, 2);
//assert
array[0].ShouldBeEquivalentTo(0);
array[1].ShouldBeEquivalentTo(0);
array[2].ShouldBeEquivalentTo(1);
array[3].ShouldBeEquivalentTo(2);
array[4].ShouldBeEquivalentTo(3);
array[5].ShouldBeEquivalentTo(4);
}
public void Should_Add_After_When_Node_Is_In_The_Middle()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(3);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
var list = new MySinglyLinkedList <int>(node1);
//act
list.AddAfter(node2, new MySinglyLinkedListNode <int>(5));
//assert
list.Count.ShouldBeEquivalentTo(5);
list.Head.Should().NotBeNull();
list.Head.Data.ShouldBeEquivalentTo(1);
list.Head.Next.Data.ShouldBeEquivalentTo(2);
list.Head.Next.Next.Data.ShouldBeEquivalentTo(5);
list.Head.Next.Next.Next.Data.ShouldBeEquivalentTo(3);
list.Head.Next.Next.Next.Next.Data.ShouldBeEquivalentTo(4);
}
public void Partition_Should_Check_Example()
{
//arrange
int partition = 5;
var list = new MySinglyLinkedList <int>();
var node1 = new MySinglyLinkedListNode <int>(3);
var node2 = new MySinglyLinkedListNode <int>(5);
var node3 = new MySinglyLinkedListNode <int>(8);
var node4 = new MySinglyLinkedListNode <int>(5);
var node5 = new MySinglyLinkedListNode <int>(10);
var node6 = new MySinglyLinkedListNode <int>(2);
var node7 = new MySinglyLinkedListNode <int>(1);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node4.Next = node5;
node5.Next = node6;
node6.Next = node7;
list.Head = node1;
var beforeCounts = new Dictionary <int, int>()
{
{ 3, 1 },
{ 1, 1 },
{ 2, 1 }
};
var afterCounts = new Dictionary <int, int>()
{
{ 10, 1 },
{ 5, 2 },
{ 8, 1 }
};
//act
var result = _linkedList.Partition(list, partition);
//assert
var head = result.Head;
while (head != null)
{
if (head.Data < partition)
{
beforeCounts[head.Data]--;
}
else
{
afterCounts[head.Data]--;
}
head = head.Next;
}
afterCounts.Values.Sum().ShouldBeEquivalentTo(0);
beforeCounts.Values.Sum().ShouldBeEquivalentTo(0);
}
public MySinglyLinkedList <int> SumLists_Backward(MySinglyLinkedList <int> first,
MySinglyLinkedList <int> second)
{
if (first == null || second == null)
{
throw new ArgumentNullException();
}
var h1 = first.Head;
var h2 = second.Head;
var result = new MySinglyLinkedList <int>();
int carry = 0;
while (h1 != null && h2 != null)
{
var number = h1.Data + h2.Data + carry;
if (number > 9)
{
carry = 1;
number %= 10;
}
else
{
carry = 0;
}
result.AddLast(new MySinglyLinkedListNode <int>(number));
h1 = h1.Next;
h2 = h2.Next;
}
MySinglyLinkedListNode <int> remainder = h1 ?? h2;
while (remainder != null)
{
var number = remainder.Data + carry;
if (number > 9)
{
number %= 10;
carry = 1;
}
else
{
carry = 0;
}
result.AddLast(new MySinglyLinkedListNode <int>(number));
remainder = remainder.Next;
}
if (carry != 0)
{
result.AddLast(new MySinglyLinkedListNode <int>(carry));
}
return(result);
}
public void Should_Add_Last_When_List_Is_Empty()
{
//arrange
var node = new MySinglyLinkedListNode <int>(1);
var list = new MySinglyLinkedList <int>();
//act
list.AddLast(node);
//assert
list.Count.ShouldBeEquivalentTo(1);
list.Head.Data.ShouldBeEquivalentTo(node.Data);
}
public void Intersaction_Should_Check_One_Length_True()
{
//arrange
var node = new MySinglyLinkedListNode <int>(1);
var first = new MySinglyLinkedList <int>(node);
var second = new MySinglyLinkedList <int>(node);
//act
var result = _linkedList.Intersaction(first, second);
//assert
result.ShouldBeEquivalentTo(node);
}
public void Should_Add_Before_Throw_When_Node_Is_Not_Found()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var list = new MySinglyLinkedList <int>(node1);
//act
Action act = () => list.AddBefore(new MySinglyLinkedListNode <int>(3), node2);
//assert
act.ShouldThrow <ArgumentException>();
}
public void Should_Create_List_With_One_Node()
{
//arrange
int data = 1;
var node = new MySinglyLinkedListNode <int>(data);
//act
var list = new MySinglyLinkedList <int>(node);
//assert
list.Head.Should().NotBeNull();
list.Head.Data.ShouldBeEquivalentTo(data);
list.Count.ShouldBeEquivalentTo(1);
}
public void DeleteMiddleNode_Should_Check_Length_One()
{
//arrange
var list = new MySinglyLinkedList <int>();
var node1 = new MySinglyLinkedListNode <int>(1);
list.Head = node1;
//act
Action act = () => _linkedList.DeleteMiddleNode(node1);
//assert
act.ShouldThrow <ArgumentException>();
}
public void Should_Throw_When_Add_After_And_Node_Is_Not_Found()
{
//arrange
var node = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var list = new MySinglyLinkedList <int>(node);
//act
Action act = () => list.AddAfter(node2, new MySinglyLinkedListNode <int>(2));
//assert
act.ShouldThrow <ArgumentException>();
list.Count.ShouldBeEquivalentTo(1);
}
public void Should_Throw_When_Add_After_And_List_Is_Empty()
{
//arrange
int data = 1;
var node = new MySinglyLinkedListNode <int>(data);
var list = new MySinglyLinkedList <int>();
//act
Action act = () => list.AddAfter(node, new MySinglyLinkedListNode <int>(1));
//assert
act.ShouldThrow <ArgumentException>();
list.Count.ShouldBeEquivalentTo(0);
}
private MySinglyLinkedListNode <int> IntersactionHelper(
MySinglyLinkedListNode <int> first, MySinglyLinkedListNode <int> second)
{
if (first == null || second == null)
{
return(null);
}
if (first == second)
{
return(first);
}
var nextNode = IntersactionHelper(first.Next, second.Next);
return(nextNode);
}
public void Should_Add_Before_When_Length_One()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var list = new MySinglyLinkedList <int>(node1);
//act
list.AddBefore(node1, node2);
//assert
list.Count.ShouldBeEquivalentTo(2);
list.Head.Should().NotBeNull();
list.Head.Data.ShouldBeEquivalentTo(2);
list.Head.Next.Data.ShouldBeEquivalentTo(1);
}
public void Should_Add_After_When_Length_Is_One()
{
//arrange
int data = 1;
var node = new MySinglyLinkedListNode <int>(data);
var list = new MySinglyLinkedList <int>(node);
//act
list.AddAfter(node, new MySinglyLinkedListNode <int>(2));
//assert
list.Count.ShouldBeEquivalentTo(2);
list.Head.Should().NotBeNull();
list.Head.Data.ShouldBeEquivalentTo(1);
list.Head.Next.Data.ShouldBeEquivalentTo(2);
}
public void DeleteMiddleNode_Should_Previous_Last()
{
//arrange
var list = new MySinglyLinkedList <int>();
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(3);
node1.Next = node2;
list.Head = node1;
//act
_linkedList.DeleteMiddleNode(node1);
//assert
list.Head.Data.ShouldBeEquivalentTo(3);
list.Head.Next.Should().BeNull();
}
private MySinglyLinkedListNode <int> ReturnKthToLastHelper(
MySinglyLinkedListNode <int> head, int k, ref int offset)
{
if (head.Next != null)
{
var res = ReturnKthToLastHelper(head.Next, k, ref offset);
if (res != null)
{
return(res);
}
}
if (k == offset)
{
return(head);
}
offset++;
return(null);
}
public void DeleteMiddleNode_Should_Delete_Middle()
{
//arrange
var list = new MySinglyLinkedList <int>();
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(3);
var node3 = new MySinglyLinkedListNode <int>(4);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
list.Head = node1;
var counts = new Dictionary <int, int>();
var head = list.Head;
while (head != null)
{
if (!counts.ContainsKey(head.Data))
{
counts[head.Data] = 0;
}
counts[head.Data]++;
head = head.Next;
}
//act
_linkedList.DeleteMiddleNode(node1);
head = list.Head;
while (head != null)
{
counts[head.Data]--;
head = head.Next;
}
//assert
counts.Values.Sum().ShouldBeEquivalentTo(1);
}
public void LoopDetection_Should_Check_False()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(3);
var node4 = new MySinglyLinkedListNode <int>(4);
var node5 = new MySinglyLinkedListNode <int>(5);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node4.Next = node5;
//act
var result = _linkedList.LoopDetection(node1);
//assert
result.ShouldBeEquivalentTo(null);
}
public void Should_Check_Copy_To_Throw_Start_Index_Range()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
node1.Next = node2;
var list = new MySinglyLinkedList <int>(node1);
var array = new int[1];
//act
Action actLower = () => list.CopyTo(array, -1);
Action actUpper = () => list.CopyTo(array, 0);
//assert
actLower.ShouldThrow <ArgumentException>();
actUpper.ShouldThrow <ArgumentException>();
}
public void Should_Check_Find_Last_False()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(2);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
var list = new MySinglyLinkedList <int>(node1);
//act
var result = list.FindLast(5);
//assert
result.Should().BeNull();
}
public void Should_Check_Find_Last_True()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(2);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
var list = new MySinglyLinkedList <int>(node1);
//act
var result = list.FindLast(2);
//assert
result.ShouldBeEquivalentTo(node3);
}
public void Should_Check_Contains_False()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(3);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
var list = new MySinglyLinkedList <int>(node1);
//act
var result = list.Contains(new MySinglyLinkedListNode <int>(5));
//assert
result.ShouldBeEquivalentTo(false);
}
public void Should_Find_Node_Return_Null()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(3);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
var list = new MySinglyLinkedList <int>(node1);
//act
var result = list.Find(5);
//assert
result.Should().BeNull();
}
private bool SumLists_ForwardHelper(MySinglyLinkedListNode <int> first,
MySinglyLinkedListNode <int> second,
MySinglyLinkedList <int> result)
{
if (first == null || second == null)
{
return(false);
}
bool carry = false;
if (first.Next != null && second.Next != null)
{
carry = SumLists_ForwardHelper(first.Next, second.Next, result);
}
var number = first.Data + second.Data + (carry ? 1 : 0);
result.AddFirst(new MySinglyLinkedListNode <int>(number % 10));;
return(number > 9);
}
private bool PalindromeHelper(MySinglyLinkedListNode <int> node,
ref MySinglyLinkedListNode <int> nextNode, int depth, bool isEvenLength)
{
depth--;
if (depth > 0)
{
if (!PalindromeHelper(node.Next, ref nextNode, depth, isEvenLength))
{
return(false);
}
nextNode = nextNode.Next;
}
if (depth == 0)
{
nextNode = isEvenLength ? node.Next : node.Next.Next;
}
return(nextNode.Data == node.Data);
}
public void Should_Add_Clear()
{
//arrange
var node1 = new MySinglyLinkedListNode <int>(1);
var node2 = new MySinglyLinkedListNode <int>(2);
var node3 = new MySinglyLinkedListNode <int>(3);
var node4 = new MySinglyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
var list = new MySinglyLinkedList <int>(node1);
//act
list.Clear();
//assert
list.Count.ShouldBeEquivalentTo(0);
list.Head.Should().BeNull();
}
