public void LinkedListSingleLinkFindIntersection2OptimizedCompleteTest3SameList()
{
// Note that since we need intersecting nodes, we can't use our helpers
// to construct these lists.
// Construct:
// 11 -> 12 -> 13
// Initialize first list.
var third1 = new LinkedListSingleLinkNode <int>
{
Value = 13
};
var second1 = new LinkedListSingleLinkNode <int>
{
Next = third1,
Value = 12
};
var first1 = new LinkedListSingleLinkNode <int>
{
Next = second1,
Value = 11
};
// Do check.
Assert.AreEqual(first1, LinkedListSingleLinkFindIntersection2OptimizedComplete.FindIntersection(first1, first1));
}
/// <summary>
/// Find the first intersecting node between two lists.
/// </summary>
/// <param name="list1">The first list.</param>
/// <param name="list2">The second list.</param>
/// <returns>The first intersecting node or null if no intersection.</returns>
public static LinkedListSingleLinkNode <int> FindIntersection(LinkedListSingleLinkNode <int> list1, LinkedListSingleLinkNode <int> list2)
{
// Check all nodes in list 1.
var curr1 = list1;
while (curr1 != null)
{
// Compare all nodes in list 2.
var curr2 = list2;
while (curr2 != null)
{
// If they match we are done.
if (curr1 == curr2)
{
return(curr1);
}
// Advance.
curr2 = curr2.Next;
}
// Advance.
curr1 = curr1.Next;
}
// No match.
return(null);
}
public void LinkedListSingleLinkPartition3NonStableCompleteTest1NullList()
{
LinkedListSingleLinkNode <int> actual = null;
LinkedListSingleLinkPartition3NonStableComplete.Partition(ref actual, 7);
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(null, actual));
}
public void LinkedListSingleLinkPartition3NonStableCompleteTest7AllBefore()
{
var actual = LinkedListSingleLinkNode <int> .CreateFromData(1, 2, 8, 7, 5, 3);
var expected = LinkedListSingleLinkNode <int> .CreateFromData(3, 5, 7, 8, 2, 1);
LinkedListSingleLinkPartition3NonStableComplete.Partition(ref actual, 9);
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(expected, actual));
}
public void LinkedListSingleLinkPartition2StableUseDummyNodesTest8AllAfter()
{
var actual = LinkedListSingleLinkNode <int> .CreateFromData(1, 2, 8, 7, 5, 3);
var expected = LinkedListSingleLinkNode <int> .CreateFromData(1, 2, 8, 7, 5, 3);
LinkedListSingleLinkPartition2StableUseDummyNodesComplete.Partition(ref actual, 0);
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(expected, actual));
}
public void LinkedListSingleLinkPartition3NonStableCompleteTest6SingleBeforeAfter()
{
var actual = LinkedListSingleLinkNode <int> .CreateFromData(3, 2, 1);
var expected = LinkedListSingleLinkNode <int> .CreateFromData(1, 3, 2);
LinkedListSingleLinkPartition3NonStableComplete.Partition(ref actual, 2);
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(expected, actual));
}
public void LinkedListSingleLinkPartition1StableCompleteTest4SingleIsPartition()
{
var actual = LinkedListSingleLinkNode <int> .CreateFromData(1);
var expected = LinkedListSingleLinkNode <int> .CreateFromData(1);
LinkedListSingleLinkPartition1StableComplete.Partition(ref actual, 1);
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(expected, actual));
}
public void LinkedListSingleLinkPartition1StableCompleteTest9Default()
{
var actual = LinkedListSingleLinkNode <int> .CreateFromData(1, 2, 8, 7, 5, 3);
var expected = LinkedListSingleLinkNode <int> .CreateFromData(1, 2, 5, 3, 8, 7);
LinkedListSingleLinkPartition1StableComplete.Partition(ref actual, 7);
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(expected, actual));
}
public void LinkedListSingleLinkPartition2StableUseDummyNodesTest5SingleBefore()
{
var actual = LinkedListSingleLinkNode <int> .CreateFromData(3, 2);
var expected = LinkedListSingleLinkNode <int> .CreateFromData(3, 2);
LinkedListSingleLinkPartition2StableUseDummyNodesComplete.Partition(ref actual, 2);
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(expected, actual));
}
public void LinkedListSingleLinkFindIntersection2OptimizedCompleteTest5NullList2()
{
var first1 = new LinkedListSingleLinkNode <int>
{
Value = 11
};
// Do check.
Assert.AreEqual(null, LinkedListSingleLinkFindIntersection2OptimizedComplete.FindIntersection(first1, null));
}
public void LinkedListSingleRemoveDuplicates2NoAdditionalDSCompleteTest6SingleNode()
{
// Create with helper.
var actual = LinkedListSingleLinkNode <int> .CreateFromData(1);
var expected = LinkedListSingleLinkNode <int> .CreateFromData(1);
LinkedListSingleRemoveDuplicates2NoAdditionalDSComplete.RemoveDuplicates(actual);
LinkedListSingleLinkNode <int> .Compare(expected, actual);
}
public void LinkedListSingleLinkSplit2FastSlowCompleteTestEmptyList()
{
// Split the list.
LinkedListSingleLinkSplit2FastSlowComplete.Split(null, out LinkedListSingleLinkNode <int> ResultA, out LinkedListSingleLinkNode <int> ResultB, out LinkedListSingleLinkNode <int> ResultDropped);
// Do the compare.
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultA, null));
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultB, null));
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultDropped, null));
}
public void LinkedListSingleRemoveDuplicates1HashSetCompleteTest4SingleDup()
{
// Create with helper.
var actual = LinkedListSingleLinkNode <int> .CreateFromData(1, 1, 1);
var expected = LinkedListSingleLinkNode <int> .CreateFromData(1);
LinkedListSingleRemoveDuplicates1HashSetComplete.RemoveDuplicates(actual);
LinkedListSingleLinkNode <int> .Compare(expected, actual);
}
public void LinkedListSingleLinkFindIntersection1BruteForceCompleteTest4NullList1()
{
var first2 = new LinkedListSingleLinkNode <int>
{
Value = 21
};
// Do check.
Assert.AreEqual(null, LinkedListSingleLinkFindIntersection1BruteForceComplete.FindIntersection(null, first2));
}
public void LinkedListSingleLinkReverse1TestEmptyListWithDefaults()
{
// List to reverse.
LinkedListSingleLinkNode <int> toReverse = null;
// Reverse the list.
LinkedListSingleLinkReverse1Complete.Reverse(ref toReverse);
// Do the compare.
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(toReverse, null));
}
public void LinkedListSingleLinkFindIntersection2OptimizedCompleteTest2NoIntersectionFound()
{
// Note that since we need intersecting nodes, we can't use our helpers
// to construct these lists.
// Construct:
// 11 -> 12 -> 13
// 21 -> 22 -> 23 -> 24
// Initialize first list.
var third1 = new LinkedListSingleLinkNode <int>
{
Value = 13
};
var second1 = new LinkedListSingleLinkNode <int>
{
Next = third1,
Value = 12
};
var first1 = new LinkedListSingleLinkNode <int>
{
Next = second1,
Value = 11
};
// Initialize second list.
var fourth2 = new LinkedListSingleLinkNode <int>
{
Value = 24
};
var third2 = new LinkedListSingleLinkNode <int>
{
Next = fourth2,
Value = 23
};
var second2 = new LinkedListSingleLinkNode <int>
{
Next = third2,
Value = 22
};
var first2 = new LinkedListSingleLinkNode <int>
{
Next = second2,
Value = 21
};
// Do check.
Assert.AreEqual(null, LinkedListSingleLinkFindIntersection2OptimizedComplete.FindIntersection(first1, first2));
}
public void LinkedListSingleLinkReverse1TestSingleElementWithDefaults()
{
// List to reverse.
var toReverse = LinkedListSingleLinkNode <int> .CreateFromData(3);
// Expected list.
var expected = LinkedListSingleLinkNode <int> .CreateFromData(3);
// Reverse the list.
LinkedListSingleLinkReverse1Complete.Reverse(ref toReverse);
// Do the compare.
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(toReverse, expected));
}
public void LinkedListSingleLinkReverse1TestMultipleElementsWithEndingNode()
{
// List to reverse.
var toReverse = LinkedListSingleLinkNode <int> .CreateFromData(1, 2, 3, 4, 5);
// Expected list.
var expected = LinkedListSingleLinkNode <int> .CreateFromData(2, 1, 3, 4, 5);
// Reverse the list.
LinkedListSingleLinkReverse1Complete.Reverse(ref toReverse, endReverse: toReverse.Next);
// Do the compare.
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(toReverse, expected));
}
public void LinkedListSingleLinkReverse1TestEndBeforeStartNode()
{
try
{
var toReverse = LinkedListSingleLinkNode <int> .CreateFromData(1, 2, 3);
LinkedListSingleLinkReverse1Complete.Reverse(ref toReverse, toReverse.Next, toReverse);
}
catch (ArgumentException)
{
Assert.IsTrue(true);
return;
}
Assert.Fail();
}
public void LinkedListSingleLinkReverse1TestInvalidEndNode()
{
try
{
var toReverse = LinkedListSingleLinkNode <int> .CreateFromData(1, 2, 3);
LinkedListSingleLinkReverse1Complete.Reverse(ref toReverse, endReverse: new LinkedListSingleLinkNode <int>());
}
catch (ArgumentException)
{
Assert.IsTrue(true);
return;
}
Assert.Fail();
}
public void LinkedListSingleLinkSplit2FastSlowCompleteTestSingleElement()
{
// First list.
var toSplit = LinkedListSingleLinkNode <int> .CreateFromData(3);
// Expected A (1st half of list)
var expectedDropped = LinkedListSingleLinkNode <int> .CreateFromData(3);
// Split the list.
LinkedListSingleLinkSplit2FastSlowComplete.Split(toSplit, out LinkedListSingleLinkNode <int> ResultA, out LinkedListSingleLinkNode <int> ResultB, out LinkedListSingleLinkNode <int> ResultDropped);
// Do the compare.
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultA, null));
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultB, null));
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultDropped, expectedDropped));
}
/// <summary>
/// Partitions a list around a specified value in place.
/// </summary>
/// <param name="head">The head of the list.</param>
/// <param name="x">The value to partition around.</param>
public static void Partition(ref LinkedListSingleLinkNode <int> head, int x)
{
// Use dummy nodes to simply code.
var beforeTop = new LinkedListSingleLinkNode <int>(-1);
var beforeBottom = beforeTop;
var afterTop = new LinkedListSingleLinkNode <int>(-1);
var afterBottom = afterTop;
var curr = head;
while (curr != null)
{
// Store next & null out to prevent cycles.
var next = curr.Next;
curr.Next = null;
// Add to appropriate list.
if (curr.Value < x)
{
// Update next pointer & bottom.
beforeBottom.Next = curr;
beforeBottom = curr;
}
else
{
// Update next pointer & bottom.
afterBottom.Next = curr;
afterBottom = curr;
}
// Go to next.
curr = next;
}
// Special case, if no before list, just use after list.
// (Use .Next due to dummy node).
if (beforeTop.Next == null)
{
head = afterTop.Next;
return;
}
// Update head & attach the after list to the before list.
// (Use .Next due to dummy node).
head = beforeTop.Next;
beforeBottom.Next = afterTop.Next;
}
/// <summary>
/// Partitions a list around a specified value in place.
/// </summary>
/// <param name="head">The head of the list.</param>
/// <param name="x">The value to partition around.</param>
public static void Partition(ref LinkedListSingleLinkNode <int> head, int x)
{
// Initialize new list links.
LinkedListSingleLinkNode <int> headNew = null;
LinkedListSingleLinkNode <int> tailNew = null;
var curr = head;
while (curr != null)
{
// Store next & null out to prevent cycles.
var next = curr.Next;
curr.Next = null;
// Update new list initially.
if (headNew == null)
{
headNew = curr;
tailNew = curr;
}
else
{
// Add to head.
if (curr.Value < x)
{
curr.Next = headNew;
headNew = curr;
}
// Add to tail.
else
{
tailNew.Next = curr;
tailNew = curr;
}
}
// Go to next.
curr = next;
}
// Update head.
head = headNew;
}
public void LinkedListSingleLinkSplit2FastSlowCompleteTestSimpleEven()
{
// First list.
var a = LinkedListSingleLinkNode <int> .CreateFromData(1, 2, 3, 4);
// Expected A (1st half of list)
var expectedA = LinkedListSingleLinkNode <int> .CreateFromData(1, 2);
// Expected B (2nd half of list)
var expectedB = LinkedListSingleLinkNode <int> .CreateFromData(3, 4);
// Split the list.
LinkedListSingleLinkSplit2FastSlowComplete.Split(a, out LinkedListSingleLinkNode <int> ResultA, out LinkedListSingleLinkNode <int> ResultB, out LinkedListSingleLinkNode <int> ResultDropped);
// Do the compare.
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultA, expectedA));
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultB, expectedB));
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultDropped, null));
}
public void LinkedListSingleLinkSplit1BruteForceCompleteTestSimpleOdd()
{
// First list.
var a = LinkedListSingleLinkNode <int> .CreateFromData(1, 2, 3);
// Expected A (1st half of list)
var expectedA = LinkedListSingleLinkNode <int> .CreateFromData(1);
// Expected B (2nd half of list)
var expectedB = LinkedListSingleLinkNode <int> .CreateFromData(3);
// Expected dropped.
var expectedDropped = LinkedListSingleLinkNode <int> .CreateFromData(2);
// Split the list.
LinkedListSingleLinkSplit1BruteForceComplete.Split(a, out LinkedListSingleLinkNode <int> ResultA, out LinkedListSingleLinkNode <int> ResultB, out LinkedListSingleLinkNode <int> ResultDropped);
// Do the compare.
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultA, expectedA));
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultB, expectedB));
Assert.IsTrue(LinkedListSingleLinkNode <int> .Compare(ResultDropped, expectedDropped));
}
/// <summary>
/// Reverse the list.
/// </summary>
/// <param name="top">The top of the list.</param>
private static void ReverseHelper(ref LinkedListSingleLinkNode <int> top)
{
// Initialize starting vars.
LinkedListSingleLinkNode <int> prev = null;
var curr = top;
// Go through list.
while (curr != null)
{
// Store next.
var next = curr.Next;
// Update
curr.Next = prev;
prev = curr;
// Go to next.
curr = next;
// Update top.
top = prev;
}
}
/// <summary>
/// Removes duplicate nodes from the list.
/// </summary>
/// <param name="head">A ref to the head node in the list.</param>
public static void RemoveDuplicates(LinkedListSingleLinkNode <int> head)
{
// Initialize ref to node being checked.
var currToCheck = head;
// Check all nodes.
while (currToCheck != null)
{
// Initialize refs to nodes being
// checked against current node.
// Skip the node we are checking.
var prev = currToCheck;
var curr = currToCheck.Next;
// If there is a node to check, check it.
while (curr != null)
{
// If the nodes values match, remove the
// node.
if (curr.Value == currToCheck.Value)
{
prev.Next = curr.Next;
}
// Otherwise just go to next.
else
{
prev = curr;
}
// Go to next.
curr = curr.Next;
}
// Go to next node to check.
currToCheck = currToCheck.Next;
}
}
/// <summary>
/// Removes duplicate nodes from the list.
/// </summary>
/// <param name="head">A ref to the head node in the list.</param>
public static void RemoveDuplicates(LinkedListSingleLinkNode <int> head)
{
// Initialize hash set.
var values = new HashSet <int>();
// Initialize initial values.
LinkedListSingleLinkNode <int> prev = null;
var curr = head;
// Check each node.
while (curr != null)
{
// Check if node is already there.
if (values.Contains(curr.Value))
{
// Delete this node.
// Note: previous can't be null for this algorithm
// since the first node cannot be a duplicate, but
// check to prevent ReSharper warning.
if (prev != null)
{
prev.Next = curr.Next;
}
}
else
{
// Add new node.
values.Add(curr.Value);
// Note: Don't update previous in the delete case.
prev = curr;
}
// Go to next.
curr = curr.Next;
}
}
/// <summary>
/// Split 'toSplit' the lists using the fast-pointer slow pointer method.
/// If the list has an uneven number of elements remove the 'middle'
/// element and return it in dropped.
/// </summary>
/// <param name="toSplit">The list to split.</param>
/// <param name="resultA">The first half of the list.</param>
/// <param name="resultB">The second half of the list.</param>
/// <param name="dropped">The 'middle' element (null for even number of elements).</param>
public static void Split(LinkedListSingleLinkNode <int> toSplit, out LinkedListSingleLinkNode <int> resultA, out LinkedListSingleLinkNode <int> resultB, out LinkedListSingleLinkNode <int> dropped)
{
// Start at toSplit.
resultA = toSplit;
resultB = toSplit;
// dropped is null by default.
dropped = null;
// End is fast pointer.
var end = toSplit;
// Set previous.
LinkedListSingleLinkNode <int> prev = null;
LinkedListSingleLinkNode <int> prev2 = null;
// Strategy: End is fast pointer, move to end.
while (end != null)
{
// Move to next.
prev2 = prev;
prev = resultB;
resultB = resultB.Next;
end = end.Next;
// Double move 'End'.
if (end != null)
{
end = end.Next;
}
// End of uneven list case.
else
{
dropped = prev;
}
}
// At this point resultA, resultB and dropped are set correctly
// so we just need to do some additional cleanup.
// For odd case, null prev2.
if (dropped != null)
{
// Isolate the dropped element.
dropped.Next = null;
// For odd count prev2 points to the end of the first half of
// the list so we need to null the next pointer.
if (prev2 != null)
{
prev2.Next = null;
}
// If no prev2 is null we have a single element list so just null resultA.
else
{
resultA = null;
}
}
// For even case, null previous.
else
{
// For even count prev points to the end of the first half of
// the list so we need to null the next pointer.
// Note: prev is null for empty list.
if (prev != null)
{
prev.Next = null;
}
}
}
public void LinkedListSingleLinkFindIntersection1BruteForceCompleteTest1IntersectionFound()
{
// Note that since we need intersecting nodes, we can't use our helpers
// to construct these lists.
// Construct:
// 11 -> 12 -> 13 -> (Common) 101 -> (Common) 102
// 21 -> 22 -> 23 -> 24 -> (Common) 101 -> (Common) 102
// Initialize first list.
var third1 = new LinkedListSingleLinkNode <int>
{
Value = 13
};
var second1 = new LinkedListSingleLinkNode <int>
{
Next = third1,
Value = 12
};
var first1 = new LinkedListSingleLinkNode <int>
{
Next = second1,
Value = 11
};
// Initialize second list.
var fourth2 = new LinkedListSingleLinkNode <int>
{
Value = 24
};
var third2 = new LinkedListSingleLinkNode <int>
{
Next = fourth2,
Value = 23
};
var second2 = new LinkedListSingleLinkNode <int>
{
Next = third2,
Value = 22
};
var first2 = new LinkedListSingleLinkNode <int>
{
Next = second2,
Value = 21
};
// Initialize common nodes.
var common1 = new LinkedListSingleLinkNode <int>
{
Value = 101
};
fourth2.Next = common1;
third1.Next = common1;
var common2 = new LinkedListSingleLinkNode <int>
{
Value = 102
};
common1.Next = common2;
// Do check.
Assert.AreEqual(common1, LinkedListSingleLinkFindIntersection1BruteForceComplete.FindIntersection(first1, first2));
}
