public void FindNthToLastTest()
{
var list = SingleLinkedList <int> .CreateList(5);
list.InsertLast(2);
list.InsertLast(8);
list.InsertLast(9);
list.InsertLast(6);
list.InsertLast(3);
list.InsertLast(7);
list.Print();
var node = LinkedListProblems.GetNthFromLast <int>(list, 3);
Assert.IsTrue(node != null && node.Data == 6, string.Format("Found = {0}. Expected = 6", node.Data.ToString()));
node = LinkedListProblems.GetNthFromLast <int>(list, 1);
Assert.IsTrue(node != null && node == list.Tail, string.Format("Found = {0}. Expected = {1}", node.Data, list.Tail.Data));
node = LinkedListProblems.GetNthFromLast <int>(list, 7);
Assert.IsTrue(node != null && node == list.Head, string.Format("Found = {0}. Expected = {1}", node.Data, list.Head.Data));
node = LinkedListProblems.GetNthFromLast <int>(list, 0);
Assert.IsTrue(node == null, "0th to last is not a valid position.");
try
{
node = LinkedListProblems.GetNthFromLast <int>(list, 10);
Assert.IsTrue(false, "Should have thrown argument exception");
}
catch (ArgumentException ex)
{
Assert.IsTrue(ex.Message.Equals("N too big."), string.Format("N={0} should be out of range.", 10));
}
}
public void TestDeleteARandomNode()
{
var list = new SingleLinkedList <int>();
list.InsertLast(2);
list.InsertLast(8);
list.InsertLast(9);
INode <int> node = new LLNode <int> {
Data = 6
};
list.InsertLast(node);
list.InsertLast(3);
list.InsertLast(7);
list.Print();
LinkedListProblems.DeleteARandomNode(list, node);
list.Print();
Assert.IsTrue(node.Data == 3, "Delete failed.");
node = new LLNode <int> {
Data = 16
};
list.InsertLast(node);
try
{
LinkedListProblems.DeleteARandomNode(list, node);
}
catch (ApplicationException ex)
{
Assert.IsTrue(ex.Message.Equals("cannot delete the node as its null or the last node."));
}
}
public void ReArrageListOddLenghtTest()
{
var list = SingleLinkedList <string> .CreateList("a1");
list.InsertLast("a2");
list.InsertLast("a3");
list.InsertLast("a4");
list.InsertLast("b1");
list.InsertLast("b2");
list.InsertLast("b3");
list.Print();
try
{
LinkedListProblems.ReArrageList(list);
}
catch (ArgumentException ex)
{
Assert.IsTrue(ex.Message.Equals("list length should be even."), "Odd length list should throw error");
}
list.InsertLast("b4");
list.InsertLast("b5");
try
{
LinkedListProblems.ReArrageList(list);
}
catch (ArgumentException ex)
{
Assert.IsTrue(ex.Message.Equals("list length should be even."), "Odd length list should throw error");
}
list.Print();
}
public void DeleteDuplicateSingleNodeTest()
{
var list = SingleLinkedList <int> .CreateList(5);
LinkedListProblems.DeleteDuplicates(list);
list.Print();
}
public void TestNoCycle()
{
var list = BuildLinkedList();
var node = LinkedListProblems.FindStartNodeOfCircularList(list);
Assert.AreEqual(null, node);
}
public void TestFindNthNodeFromEnd()
{
var list1 = BuildLinkedList();
var val = LinkedListProblems.FindNthNodeFromEnd(list1, 2).Data;
Assert.AreEqual(8, val);
}
public void TestPivotOverARandomNode()
{
var list = new SingleLinkedList <int>();
list.InsertLast(2);
list.InsertLast(8);
list.InsertLast(9);
list.InsertLast(6);
list.InsertLast(3);
list.InsertLast(7);
list.Print();
var newlist = LinkedListProblems.SplitMe(list, 6);
newlist.Print();
int[] result = new int[] { 2, 3, 6, 8, 9, 7 };
var r = newlist.Head;
for (int i = 0; i < result.Length; i++)
{
Assert.IsTrue(r.Data == result[i], "Order not correct. Position={0}, Expected={1}, Actual={2}", i, result[i], r.Data);
r = r.Next;
}
}
public void TestCycleStartNode()
{
var list = BuildLinkedList();
var curr = list;
var start = list;
//Find the last node
while (curr.Next != null)
{
curr = curr.Next;
}
//Find an arbitary node
for (int i = 0; i < 9; i++)
{
start = start.Next;
if (start.Data == 5)
{
break;
}
}
// Create a cycle
curr.Next = start;
var node = LinkedListProblems.FindStartNodeOfCircularList(list);
Assert.AreEqual(start.Data, node.Data);
}
public void TestSeggregateOddEven()
{
var list = new Node(5).Append(1).Append(2).Append(3).Append(4).Append(6);
var list1 = new Node(2).Append(4).Append(6).Append(5).Append(1).Append(3);
var list2 = LinkedListProblems.SeggregateOddEven(list);
Assert.AreEqual(0, list1.CompareTo(list2));
}
static void Main(string[] args)
{
//Tester tester = new Tester();
//tester.RotateArrayTest();
//ChangeTester changeTester = new ChangeTester();
//changeTester.Test();
LinkedListProblems linkedTester = new LinkedListProblems();
linkedTester.Test();
}
public void TestRemoveNthFromEnd(int[] list, int n, int[] expected)
{
var linkedListProblems = new LinkedListProblems();
var expectedResults = SingleLinkedListNode.GenerateList(expected);
var input = SingleLinkedListNode.GenerateList(list);
var actualResults = linkedListProblems.RemoveNthFromEnd(input, n);
Assert.True(SingleLinkedListNode.AreListsEqual(expectedResults, actualResults));
}
public void TestListSum()
{
var list1 = new Node(9).Append(9).Append(9);
var list2 = new Node(9).Append(9).Append(9);
var sum = new Node(8).Append(9).Append(9).Append(1);
var calcsum = LinkedListProblems.ListSum(list1, list2, 0);
Assert.AreEqual(0, calcsum.CompareTo(sum));
}
public void TestReverseListRecursion(int[] list, int[] expectedOutput)
{
var linkedListProblems = new LinkedListProblems();
var input = SingleLinkedListNode.GenerateList(list);
var expectedResults = SingleLinkedListNode.GenerateList(expectedOutput);
var actualResults = linkedListProblems.ReverseListRecursion(input);
Assert.True(SingleLinkedListNode.AreListsEqual(expectedResults, actualResults));
}
public void ReArrageListTwoNodeTest()
{
var list = SingleLinkedList <string> .CreateList("a1");
list.InsertLast("b1");
list.Print();
LinkedListProblems.ReArrageList(list);
list.Print();
}
public void TestRemoveDuplicatesWithoutBuffer()
{
var list1 = BuildLinkedList();
var list2 = BuildLinkedList();
list2.AppendToTail(1);
list2.AppendToTail(2);
list2 = LinkedListProblems.RemoveDuplicatesWithoutBuffer(list2);
Assert.AreEqual(0, list1.CompareTo(list2));
}
public void TestMergeTwoLists(int[] num1, int[] num2, int[] expectedNum)
{
var l1 = SingleLinkedListNode.GenerateList(num1);
var l2 = SingleLinkedListNode.GenerateList(num2);
var expectedResults = SingleLinkedListNode.GenerateList(expectedNum);
var linkedListProblems = new LinkedListProblems();
var actualResults = linkedListProblems.MergeTwoLists(l1, l2);
Assert.NotNull(expectedResults);
Assert.True(SingleLinkedListNode.AreListsEqual(expectedResults, actualResults));
}
public void ReArrageListNullTest()
{
var list = SingleLinkedList <string> .CreateList("a1");
list.DeleteFirst();
list.Print();
LinkedListProblems.ReArrageList(list);
list.Print();
}
public void TestDeleteNode()
{
var list = BuildLinkedList();
var nodeTobeDeleted = list.Next.Next.Next; //the node with value 4
Assert.AreEqual(2, list.Next.Next.Data);
Assert.AreEqual(3, list.Next.Next.Next.Data);
LinkedListProblems.DeleteNode(nodeTobeDeleted);
Assert.AreEqual(2, list.Next.Next.Data);
Assert.AreEqual(4, list.Next.Next.Next.Data);
}
public void DeleteDuplicateWhereAllUniqueTest()
{
var list = SingleLinkedList <int> .CreateList(5);
list.InsertLast(2);
list.InsertLast(8);
list.InsertLast(9);
list.InsertLast(7);
list.InsertLast(3);
list.Print();
LinkedListProblems.DeleteDuplicates(list);
list.Print();
}
public void ReArrageListBigListTest()
{
var list = SingleLinkedList <string> .CreateList("a1");
list.InsertLast("a2");
list.InsertLast("a3");
list.InsertLast("a4");
list.InsertLast("b1");
list.InsertLast("b2");
list.InsertLast("b3");
list.InsertLast("b4");
list.Print();
LinkedListProblems.ReArrageList(list);
list.Print();
}
public void TestMergeKListsBruteForce()
{
var linkedListProblems = new LinkedListProblems();
var inputs = new int[3][] { new int[3] {
1, 4, 5
}, new int[3] {
1, 3, 4
}, new int[2] {
2, 6
} };
var expectedResults = SingleLinkedListNode.GenerateList(new int[] { 1, 1, 2, 3, 4, 4, 5, 6 });
SingleLinkedListNode[] lists = new SingleLinkedListNode[]
{
SingleLinkedListNode.GenerateList(inputs[0]),
SingleLinkedListNode.GenerateList(inputs[1]),
SingleLinkedListNode.GenerateList(inputs[2]),
};
var actualResults = linkedListProblems.MergeKListsBruteForce(lists);
Assert.True(SingleLinkedListNode.AreListsEqual(expectedResults, actualResults));
}
public void TestPalindrom()
{
// 1->2->3->2->1
var list = new SingleLinkedList <int>();
list.InsertLast(1);
list.InsertLast(2);
list.InsertLast(3);
list.InsertLast(2);
list.InsertLast(1);
list.Print();
var isPalindrom = LinkedListProblems.IsPalindrome(list);
Assert.IsTrue(isPalindrom, "List is a valid palindrom");
// 1->2->3->3->2->1
list = new SingleLinkedList <int>();
list.InsertLast(1);
list.InsertLast(2);
list.InsertLast(3);
list.InsertLast(3);
list.InsertLast(2);
list.InsertLast(1);
list.Print();
isPalindrom = LinkedListProblems.IsPalindrome(list);
Assert.IsTrue(isPalindrom, "List is a valid palindrom");
// 1
list = new SingleLinkedList <int>();
list.InsertLast(1);
list.Print();
isPalindrom = LinkedListProblems.IsPalindrome(list);
Assert.IsTrue(isPalindrom, "List is a valid palindrom");
// Empty list
list = new SingleLinkedList <int>();
isPalindrom = LinkedListProblems.IsPalindrome(list);
Assert.IsFalse(isPalindrom, "Empty List is not a valid palindrom");
// 1->2->3->4->2->1
list = new SingleLinkedList <int>();
list.InsertLast(1);
list.InsertLast(2);
list.InsertLast(3);
list.InsertLast(4);
list.InsertLast(2);
list.InsertLast(1);
list.Print();
isPalindrom = LinkedListProblems.IsPalindrome(list);
Assert.IsFalse(isPalindrom, "List is not a valid palindrom");
// 1->2->3->2
list = new SingleLinkedList <int>();
list.InsertLast(1);
list.InsertLast(2);
list.InsertLast(3);
list.InsertLast(2);
list.Print();
isPalindrom = LinkedListProblems.IsPalindrome(list);
Assert.IsFalse(isPalindrom, "List is not a valid palindrom");
// 1->2->3->4->1
list = new SingleLinkedList <int>();
list.InsertLast(1);
list.InsertLast(2);
list.InsertLast(3);
list.InsertLast(4);
list.InsertLast(1);
list.Print();
isPalindrom = LinkedListProblems.IsPalindrome(list);
Assert.IsFalse(isPalindrom, "List is not a valid palindrom");
}
