public void DesignSinglyLinkedListTestCase7()
{
var myLinkedList = new MySinglyLinkedList();
myLinkedList.AddAtTail(1);
myLinkedList.Get(0).Should().Be(1);
}
public MySinglyLinkedListNode <int> Intersaction(MySinglyLinkedList <int> first,
MySinglyLinkedList <int> second)
{
if (first == null || second == null)
{
throw new ArgumentNullException();
}
var headFirst = first.Head;
var headSecond = second.Head;
if (first.Count > second.Count)
{
var number = first.Count - second.Count;
while (number-- > 0)
{
headFirst = headFirst.Next;
}
}
else if (first.Count < second.Count)
{
var number = second.Count - first.Count;
while (number-- > 0)
{
headSecond = headSecond.Next;
}
}
return(IntersactionHelper(headFirst, headSecond));
}
public static MySinglyLinkedList SwapPairs(MySinglyLinkedList head)
{
return(Swap(head));
MySinglyLinkedList Swap(MySinglyLinkedList first)
{
if (first == null)
{
return(null);
}
var second = first.Next;
var temp = second?.Next;
first.Next = temp;
if (second != null)
{
second.Next = first;
first.Next = Swap(first.Next);
return(second);
}
return(first);
}
}
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 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 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);
}
//BigInteger is a dirty hack for LeetCodes test cases with long Linked Lists. But right now I'm too lazy to make calculations by myself
public static MySinglyLinkedList AddTwoNumbers(MySinglyLinkedList l1, MySinglyLinkedList l2)
{
var result = new MySinglyLinkedList();
var resCopy = result;
var firstNumber = string.Empty;
var secondNumber = string.Empty;
while (l1 != null)
{
firstNumber = l1.Value + firstNumber;
l1 = l1.Next;
}
while (l2 != null)
{
secondNumber = l2.Value + secondNumber;
l2 = l2.Next;
}
var resultNumber = (BigInteger.Parse(firstNumber) + BigInteger.Parse(secondNumber)).ToString().Reverse();
foreach (var n in resultNumber)
{
resCopy.Next = new MySinglyLinkedList(int.Parse(n.ToString()));
resCopy = resCopy.Next;
}
return(result.Next);
}
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 MySinglyLinkedList <int> SumLists_Forward(MySinglyLinkedList <int> first,
MySinglyLinkedList <int> second)
{
if (first == null || second == null)
{
throw new ArgumentNullException();
}
if (first.Count != second.Count)
{
var count = Math.Abs(first.Count - second.Count);
var smallerList = first.Count > second.Count ? second : first;
while (count-- > 0)
{
smallerList.AddFirst(new MySinglyLinkedListNode <int>(0));
}
}
var result = new MySinglyLinkedList <int>();
var carry = SumLists_ForwardHelper(first.Head, second.Head, result);
if (carry)
{
result.AddFirst(new MySinglyLinkedListNode <int>(1));
}
return(result);
}
public void SumLists_Backward_Should_Check_Nines()
{
//arrange
var first = new MySinglyLinkedList <int>();
first.AddLast(new MySinglyLinkedListNode <int>(1));
var second = new MySinglyLinkedList <int>();
second.AddLast(new MySinglyLinkedListNode <int>(9));
second.AddLast(new MySinglyLinkedListNode <int>(9));
second.AddLast(new MySinglyLinkedListNode <int>(9));
var resultList = new MySinglyLinkedList <int>();
resultList.AddLast(new MySinglyLinkedListNode <int>(0));
resultList.AddLast(new MySinglyLinkedListNode <int>(0));
resultList.AddLast(new MySinglyLinkedListNode <int>(0));
resultList.AddLast(new MySinglyLinkedListNode <int>(1));
//act
var result = _linkedList.SumLists_Backward(first, second);
//assert
result.Count.ShouldBeEquivalentTo(resultList.Count);
var h1 = result.Head;
var h2 = resultList.Head;
while (h1 != null)
{
h1.Data.ShouldBeEquivalentTo(h2.Data);
h1 = h1.Next;
h2 = h2.Next;
}
}
public void SumLists_Forward_Should_Check_Empty_And_Not_Length()
{
//arrange
var first = new MySinglyLinkedList <int>();
var second = new MySinglyLinkedList <int>();
second.AddLast(new MySinglyLinkedListNode <int>(5));
second.AddLast(new MySinglyLinkedListNode <int>(8));
second.AddLast(new MySinglyLinkedListNode <int>(6));
var resultList = new MySinglyLinkedList <int>();
resultList.AddLast(new MySinglyLinkedListNode <int>(5));
resultList.AddLast(new MySinglyLinkedListNode <int>(8));
resultList.AddLast(new MySinglyLinkedListNode <int>(6));
//act
var result = _linkedList.SumLists_Forward(first, second);
//assert
result.Count.ShouldBeEquivalentTo(resultList.Count);
var h1 = result.Head;
var h2 = resultList.Head;
while (h1 != null)
{
h1.Data.ShouldBeEquivalentTo(h2.Data);
h1 = h1.Next;
h2 = h2.Next;
}
}
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);
}
// O(n^2 + m) solution
public static MySinglyLinkedList GetIntersectionNode(MySinglyLinkedList headA, MySinglyLinkedList headB)
{
if (headA == null || headB == null)
{
return(null);
}
if (headA == headB)
{
return(headA);
}
var pointer = headA.Next != null ? headA : headB;
var current = headA.Next != null ? headB : headA;
while (pointer != null)
{
do
{
if (pointer == current)
{
return(pointer);
}
current = current.Next;
} while (current != null);
pointer = pointer.Next;
current = headA.Next != null ? headB : headA;
}
return(null);
}
public void Example1_Can_detect_intersection_node()
{
//Combined
var combined = new MySinglyLinkedList(new ListNode(8));
combined.AddAtTail(4);
combined.AddAtTail(5);
//List One
var alist = new MySinglyLinkedList(new ListNode(4));
alist.AddAtTail(1);
alist.Tail.next = combined.Head;
//List two
var blist = new MySinglyLinkedList(new ListNode(5));
blist.AddAtTail(6);
blist.AddAtTail(1);
blist.Tail.next = combined.Head;
// Additional set up
var expected = combined.Head;
var sut = new Solution();
var actual = sut.GetIntersectionNode(alist.Head, blist.Head);
Assert.AreEqual(expected, actual);
}
public void DesignSinglyLinkedListTestCase2()
{
var myLinkedList = new MySinglyLinkedList();
myLinkedList.AddAtHead(1);
myLinkedList.DeleteAtIndex(0);
}
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 static MySinglyLinkedList MergeTwoLists(MySinglyLinkedList l1, MySinglyLinkedList l2)
{
if (l1 == null && l2 == null)
{
return(null);
}
if (l1 == null)
{
return(l2);
}
if (l2 == null)
{
return(l1);
}
MySinglyLinkedList head;
if (l1.Value > l2.Value)
{
head = l2;
l2 = l2.Next;
}
else
{
head = l1;
l1 = l1.Next;
}
var result = head;
while (head != null)
{
if (l1?.Value > l2?.Value)
{
head.Next = l2;
l2 = l2?.Next;
}
else if (l1 != null && l2 != null)
{
head.Next = l1;
l1 = l1.Next;
}
else if (l1 == null)
{
head.Next = l2;
break;
}
else if (l2 == null)
{
head.Next = l1;
break;
}
head = head.Next;
}
return(result);
}
public void DesignSinglyLinkedListTestCase6()
{
var myLinkedList = new MySinglyLinkedList();
myLinkedList.AddAtIndex(0, 10);
myLinkedList.AddAtIndex(0, 20);
myLinkedList.AddAtIndex(1, 30);
myLinkedList.Get(0).Should().Be(20);
}
public static MySinglyLinkedList RemoveNthFromEnd(MySinglyLinkedList head, int n)
{
if (head == null || n < 0 || head.Next == null && n == 1)
{
return(null);
}
if (head.Next == null && n == 0)
{
return(head);
}
//The better way is to make something like var tempHead = new MyLinkedList(0); tempHead.Next = head;
//so it is better than null and better than head as init value. After I can just prevBeforeNFromEnd.Next = prevBeforeNFromEnd.Next.Next; return tempHead.Next;
var pointer = head;
var prevBeforeNFromEnd = head;
var i = 0;
while (pointer != null)
{
if (i > n)
{
prevBeforeNFromEnd = prevBeforeNFromEnd.Next;
}
pointer = pointer.Next;
i++;
}
switch (i)
{
case 2 when n == 1:
head.Next = null;
break;
case 2 when n == 2:
head = head.Next;
break;
default:
{
if (prevBeforeNFromEnd == head && i == n)
{
head = head.Next;
}
else
{
prevBeforeNFromEnd.Next = prevBeforeNFromEnd.Next?.Next;
}
break;
}
}
return(head);
}
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 AddAtHead_Can_Add()
{
var head = new LinkedListHelper().CreateSinglyLinkedList(new int[] { 1, 2, 3, 4 });
var sut = new MySinglyLinkedList(head);
sut.AddAtHead(0);
var result = sut.Head.val;
Assert.AreEqual(0, result);
}
public void Can_Delete_At_Index()
{
var head = new LinkedListHelper().CreateSinglyLinkedList(new int[] { 1, 2, 3, 4 });
var sut = new MySinglyLinkedList(head);
sut.DeleteAtIndex(1);
var result = sut.Get(1);
Assert.AreEqual(3, result);
}
public void AddAtIndex_Can_Add()
{
var head = new LinkedListHelper().CreateSinglyLinkedList(new int[] { 1, 2, 3, 4 });
var sut = new MySinglyLinkedList(head);
sut.AddAtIndex(3, 10);
var result = sut.Get(3);
Assert.AreEqual(10, result);
}
public void Should_Create_Empty_List()
{
//arrange
//act
var list = new MySinglyLinkedList <int>();
//assert
list.Head.ShouldBeEquivalentTo(null);
}
public void Example3_Can_tell_NO_cycle_when_one_node()
{
var list = new MySinglyLinkedList(new ListNode(1));
var expected = false;
var sut = new Solution();
var actual = sut.HasCycle(list.Head);
Assert.AreEqual(expected, actual);
}
public void Example2_Can_remove_if_only_one_node_in_list()
{
var list = new MySinglyLinkedList(new ListNode(0));
ListNode expected = null;
var sut = new Solution();
var actual = sut.RemoveNthFromEnd(list.Head, 1);
Assert.AreEqual(expected, actual);
}
public void Example3_Can_detect_NO_cycle_when_one_node()
{
var list = new MySinglyLinkedList(new ListNode(1));
ListNode expected = null;
var sut = new Solution();
var actual = sut.DetectCycle(list.Head);
Assert.AreEqual(expected, actual);
}
public void Should_Throw_Remove_Last_When_List_Is_Empty()
{
//arrange
var list = new MySinglyLinkedList <int>();
//act
Action act = () => list.RemoveLast();
//assert
act.ShouldThrow <InvalidOperationException>();
}
public static MySinglyLinkedList GetLinkedListFromArray(int[] values)
{
var result = new MySinglyLinkedList();
foreach (var value in values)
{
result.AddAtTail(value);
}
return(result);
}
public void Should_Check_Copy_To_Throw_If_Null()
{
//arrange
var list = new MySinglyLinkedList <int>();
//act
Action act = () => list.CopyTo(null, 1);
//assert
act.ShouldThrow <ArgumentException>();
}
