/// <summary>
/// We will use floyd's cycle detection.
/// We will have two runners. One will move by going to the next node
/// whereas other will traverse by moving 2 nodes at the same time.
/// One both the runners meet, that will be the offset point.
/// So keep a runner at the offset point and another at the head and move one by one.
/// The node where both the runners meet will be the start of the cycle in the linked list
/// </summary>
/// <param name="head"></param>
/// <returns></returns>
public static SingleLinkedListNode <int> StartOfCircularLinkedListAlgo1(SingleLinkedListNode <int> head)
{
SingleLinkedListNode <int> node1 = head.NextNode;
SingleLinkedListNode <int> node2 = (head.NextNode != null)? head.NextNode.NextNode: null;
while (node1 != null && node2 != null)
{
if (node1 == node2)
{
break;
}
node1 = node1.NextNode;
node2 = (node2.NextNode != null) ? node2.NextNode.NextNode : null;
}
if (node1 == null || node2 == null)
{
// there is no cycle
return(null);
}
node1 = head;
while (node1 != node2)
{
node1 = node1.NextNode;
node2 = node2.NextNode;
}
return(node1);
}
/// <summary>
/// This reversal is done using 3 pointers by actually rearranging the node
/// </summary>
/// <param name="HeadNode"></param>
/// <returns></returns>
private static SingleLinkedListNode <int> ReverseAdjacentNodes(SingleLinkedListNode <int> HeadNode)
{
SingleLinkedListNode <int> currentNode = HeadNode;
SingleLinkedListNode <int> previousNode = null;
// We will move forward in twos
while (currentNode != null && currentNode.NextNode != null)
{
SingleLinkedListNode <int> llNode1 = currentNode;
SingleLinkedListNode <int> llNode2 = currentNode.NextNode;
// Reverse the adjacent nodes
SingleLinkedListNode <int> temp = llNode2.NextNode;
llNode2.NextNode = llNode1;
llNode1.NextNode = temp;
if (previousNode != null)
{
previousNode.NextNode = llNode2;
}
else
{
HeadNode = llNode2;
}
currentNode = temp;
previousNode = llNode1;
}
return(HeadNode);
}
/*
* Input: 1->2->4, 1->3->4
* Output: 1->1->2->3->4->4
*/
public SingleLinkedListNode MergeTwoLists(SingleLinkedListNode l1, SingleLinkedListNode l2)
{
SingleLinkedListNode head = null;
SingleLinkedListNode t = new SingleLinkedListNode(0);
head = t;
while (l1 != null && l2 != null)
{
if (l1.val < l2.val)
{
t.next = l1;
l1 = l1.next;
}
else
{
t.next = l2;
l2 = l2.next;
}
t = t.next;
}
if (l1 != null)
{
t.next = l1;
}
if (l2 != null)
{
t.next = l2;
}
return(head.next);
}
public void AddFirst(SingleLinkedList singleLinkedList, int new_data)
{
SingleLinkedListNode new_node = new SingleLinkedListNode(new_data);
new_node.next = singleLinkedList.head;
singleLinkedList.head = new_node;
}
public void Enque( double value )
{
if( _data == null )
_data = new SingleLinkedListNode() { Value = value };
else
_data.Add( value );
}
public SingleLinkedListNode <int> NthLastNodeOfLinkedListAlgo1(SingleLinkedListNode <int> head, int n)
{
// Step1: Get the length of the linked list
SingleLinkedListNode <int> currentNode = head;
int length = 0;
while (currentNode != null)
{
length++;
currentNode = currentNode.NextNode;
}
// Step2: Get the index of the element from the start
int indexOfNodeFromStart = length - n;
// Error condition where the length of the linked list is less than n
if (indexOfNodeFromStart < 0 || indexOfNodeFromStart >= length)
{
return(null);
}
// Step3: traverse the linked list to get the element
currentNode = head;
while (indexOfNodeFromStart > 0)
{
currentNode = currentNode.NextNode;
indexOfNodeFromStart--;
}
return(currentNode);
}
public SingleLinkedListNode <int> AddNumbersRepresentedByLinkedListAlgo2(SingleLinkedListNode <int> num1, SingleLinkedListNode <int> num2, int carry)
{
// Recursion base condition
if (num1 == null && num2 == null)
{
return(null);
}
int num1Val = num1 != null ? num1.Data : 0;
int num2Val = num2 != null ? num2.Data : 0;
int sum = num1Val + num2Val + carry;
if (sum >= 10)
{
carry = 1;
sum = sum % 10;
}
else
{
carry = 0;
}
SingleLinkedListNode <int> sumNode = new SingleLinkedListNode <int>(sum);
sumNode.NextNode = AddNumbersRepresentedByLinkedListAlgo2((num1 != null)?num1.NextNode:null, (num2 != null)?num2.NextNode:null, carry);
return(sumNode);
}
public static void TestAddNumbersRepresentedByLinkedList()
{
AddNumbers adNums = new AddNumbers();
SingleLinkedListNode <int> ll1 = LinkedListHelper.CreateSinglyLinkedList(6);
LinkedListHelper.PrintSinglyLinkedList(ll1);
SingleLinkedListNode <int> ll2 = LinkedListHelper.CreateSinglyLinkedList(7);
LinkedListHelper.PrintSinglyLinkedList(ll2);
Console.WriteLine("The sum with algo 1 is as follows:");
SingleLinkedListNode <int> sum = adNums.AddNumbersRepresentedByLinkedListAlgo1(ll1, ll2);
LinkedListHelper.PrintSinglyLinkedList(sum);
Console.WriteLine("The sum with algo 2 is as follows:");
sum = adNums.AddNumbersRepresentedByLinkedListAlgo2(ll1, ll2, 0);
LinkedListHelper.PrintSinglyLinkedList(sum);
Console.WriteLine("The sum with algo 3 is as follows:");
sum = adNums.AddLinkedLists(ll1, ll2);
LinkedListHelper.PrintSinglyLinkedList(sum);
}
/// <summary>
/// This will convert a number to a linked list
/// for eg:
/// num 152 will be converted to 2->5->1
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
private SingleLinkedListNode <int> GetLLFromNum(int num)
{
if (num == 0)
{
return(new SingleLinkedListNode <int>(0));
}
SingleLinkedListNode <int> linkedListHead = null;
SingleLinkedListNode <int> linkedListCurrent = null;
while (num > 0)
{
int currentLLData = num % 10;
if (linkedListCurrent == null)
{
// Case where we need to set the linkedlist head
linkedListCurrent = new SingleLinkedListNode <int>(currentLLData);
linkedListHead = linkedListCurrent;
}
else
{
// case where we have the linkedlist head and we need to add the new node at the current's next node
linkedListCurrent.NextNode = new SingleLinkedListNode <int>(currentLLData);
linkedListCurrent = linkedListCurrent.NextNode;
}
num /= 10;
}
return(linkedListHead);
}
public SingleLinkedListNode <int> NthLastNodeOfLinkedListAlgo2(SingleLinkedListNode <int> head, int n)
{
// Step1: Have 2 pointers to the head of the linked list
SingleLinkedListNode <int> slowPointer = head;
SingleLinkedListNode <int> fastPointer = head;
// Step2: Move the fast pointer till we are n distance from the slow pointer
while (n != 0)
{
n--;
// Error condition where the length of the linked list is less than n
if (fastPointer == null)
{
return(null);
}
fastPointer = fastPointer.NextNode;
}
// Step3: Move both pointers till next node of fast pointer is not null
while (fastPointer.NextNode != null)
{
fastPointer = fastPointer.NextNode;
slowPointer = slowPointer.NextNode;
}
// Step4: The position of the slow pointer is our nth element from the last element
return(slowPointer);
}
public static void TestReverseAdjacentNodes()
{
SingleLinkedListNode <int> node1 = LinkedListHelper.CreateSinglyLinkedList(10);
LinkedListHelper.PrintSinglyLinkedList(node1);
SingleLinkedListNode <int> node2 = ReverseAdjacentNodes(node1);
Console.WriteLine("the reversed adjacent nodes for algo1 are:");
LinkedListHelper.PrintSinglyLinkedList(node2);
SingleLinkedListNode <int> node3 = LinkedListHelper.CreateSinglyLinkedList(10);
LinkedListHelper.PrintSinglyLinkedList(node3);
SingleLinkedListNode <int> node4 = ReverseAdjacentNodesAlgo2(node3);
Console.WriteLine("the reversed adjacent nodes for algo2 are:");
LinkedListHelper.PrintSinglyLinkedList(node4);
SingleLinkedListNode <int> node5 = LinkedListHelper.CreateSinglyLinkedList(11);
LinkedListHelper.PrintSinglyLinkedList(node5);
SingleLinkedListNode <int> node6 = ReverseAdjacentNodes(node5);
Console.WriteLine("the reversed adjacent nodes for algo1 are:");
LinkedListHelper.PrintSinglyLinkedList(node6);
SingleLinkedListNode <int> node7 = LinkedListHelper.CreateSinglyLinkedList(11);
LinkedListHelper.PrintSinglyLinkedList(node7);
SingleLinkedListNode <int> node8 = ReverseAdjacentNodesAlgo2(node7);
Console.WriteLine("the reversed adjacent nodes for algo2 are:");
LinkedListHelper.PrintSinglyLinkedList(node8);
}
public static void TestStartOfCycleInLinkedList()
{
Console.WriteLine("Find the start of the circular linked list");
SingleLinkedListNode <int> linkedlist = LinkedListHelper.CreateSinglyLinkedList(10);
LinkedListHelper.PrintSinglyLinkedList(linkedlist);
SingleLinkedListNode <int> randomNode = LinkedListHelper.GetRandomNode(linkedlist, 10);
Console.WriteLine("The random node is {0}", randomNode.Data);
SingleLinkedListNode <int> lastNode = linkedlist;
while (lastNode.NextNode != null)
{
lastNode = lastNode.NextNode;
}
// Create the circular node
lastNode.NextNode = randomNode;
SingleLinkedListNode <int> node = StartOfCircularLinkedListAlgo1(linkedlist);
Console.WriteLine("The start of the circle is {0} and the expected node is {1}", node.Data, randomNode.Data);
node = StartOfCircularLinkedListAlgo2(linkedlist);
Console.WriteLine("The start of the circle is {0} and the expected node is {1}", node.Data, randomNode.Data);
}
/// <summary>
/// Merge two sorted linked list w/o using extra space in such a way that the final linked list is sorted
/// </summary>
/// <param name="list1">linked list to be merged</param>
/// <param name="list2">linked list to be merged</param>
/// <returns>Merged and sorted linked list</returns>
private static SingleLinkedListNode <int> Merge(SingleLinkedListNode <int> list1, SingleLinkedListNode <int> list2)
{
SingleLinkedListNode <int> mergedListHead = null;
SingleLinkedListNode <int> mergedListCurrent = null;
while (list1 != null && list2 != null)
{
if (list1.Data < list2.Data)
{
AddToMergedList(ref mergedListHead, ref mergedListCurrent, ref list1);
}
else
{
AddToMergedList(ref mergedListHead, ref mergedListCurrent, ref list2);
}
}
// Add all list1 items if any of them are left
if (list1 != null)
{
AddToMergedList(ref mergedListHead, ref mergedListCurrent, ref list1);
}
// Add all the list2 items if any of them are left
if (list2 != null)
{
AddToMergedList(ref mergedListHead, ref mergedListCurrent, ref list2);
}
return(mergedListHead);
}
public static void TestMerge()
{
Console.WriteLine("Test merging of 2 sorted linked list");
SingleLinkedListNode <int> list1 = LinkedListHelper.SortedLinkedList(10);
LinkedListHelper.PrintSinglyLinkedList(list1);
SingleLinkedListNode <int> list2 = LinkedListHelper.SortedLinkedList(10, 5);
LinkedListHelper.PrintSinglyLinkedList(list2);
Console.WriteLine("The merged linked list is as follows:");
LinkedListHelper.PrintSinglyLinkedList(Merge(list1, list2));
//Test2
Console.WriteLine("Test2:Test merging of 2 sorted linked list");
list1 = LinkedListHelper.SortedLinkedList(10);
LinkedListHelper.PrintSinglyLinkedList(list1);
list2 = LinkedListHelper.SortedLinkedList(1, 5);
LinkedListHelper.PrintSinglyLinkedList(list2);
Console.WriteLine("The merged linked list is as follows:");
LinkedListHelper.PrintSinglyLinkedList(Merge(list1, list2));
}
/// <summary>
/// We can delete the Linked list duplicates with o(1) space but we will need O(n^2) time
/// </summary>
/// <param name="head"> head reference to the linked list</param>
/// <returns> the head reference to the linked list w/o the duplicates</returns>
public SingleLinkedListNode <int> DeleteDuplicatesAlgo2(SingleLinkedListNode <int> head)
{
SingleLinkedListNode <int> currentNode = head;
while (currentNode != null)
{
bool isDuplicate = false;
SingleLinkedListNode <int> iterateNode = head;
if (currentNode.NextNode != null)
{
while (currentNode.NextNode != iterateNode)
{
if (currentNode.NextNode.Data == iterateNode.Data)
{
isDuplicate = true;
break;
}
iterateNode = iterateNode.NextNode;
}
}
if (isDuplicate)
{
currentNode.NextNode = currentNode.NextNode.NextNode;
}
currentNode = currentNode.NextNode;
}
return(head);
}
public static void TestGetMedian()
{
SingleLinkedListNode <int> headNode = LinkedListHelper.SortedLinkedList(10, 5);
LinkedListHelper.PrintSinglyLinkedList(headNode);
SingleLinkedListNode <int> currentNode = headNode;
// get the last node
while (currentNode.NextNode != null)
{
currentNode = currentNode.NextNode;
}
currentNode.NextNode = headNode;
Console.WriteLine("The median for the circular linked list is {0}", GetMedian(headNode));
headNode = LinkedListHelper.SortedLinkedList(9, 5);
LinkedListHelper.PrintSinglyLinkedList(headNode);
currentNode = headNode;
// get the last node
while (currentNode.NextNode != null)
{
currentNode = currentNode.NextNode;
}
currentNode.NextNode = headNode;
Console.WriteLine("The median for the circular linked list is {0}", GetMedian(headNode));
}
public void Delete(int value)
{
if (Head != null)
{
SingleLinkedListNode <int> currentNode = Head;
if (Head.Data == value)
{
currentNode = Head;
// go to the end of the cycle
while (currentNode.NextNode != Head)
{
currentNode = currentNode.NextNode;
}
// delete the head
currentNode.NextNode = Head.NextNode;
Head = Head.NextNode;
}
else
{
while (currentNode.NextNode != Head)
{
if (currentNode.NextNode.Data == value)
{
// we need to delete currentNode.NextNode
currentNode.NextNode = currentNode.NextNode.NextNode;
break;
}
currentNode = currentNode.NextNode;
}
}
}
}
public virtual void Push(T dataToPush)
{
SingleLinkedListNode <T> nodeToPush = new SingleLinkedListNode <T>(dataToPush);
nodeToPush.NextNode = Top;
Top = nodeToPush;
}
public LinkedQueue()
{
_head = new SingleLinkedListNode <T>();
_tail = _head;
_count = 0;
_version = 0;
}
/// <summary>
/// We can use 2 linked list to do the operation in BFS fashion.
///
/// </summary>
/// <param name="head"></param>
/// <returns></returns>
public static List <SinglyLinkedList <BinaryTreeNode <int> > > CreateLinkedListOfTreeNodesAtEachDepth(BinaryTreeNode <int> head)
{
// the list of the linkedlist of nodes at each level
List <SinglyLinkedList <BinaryTreeNode <int> > > retList = new List <SinglyLinkedList <BinaryTreeNode <int> > >();
SinglyLinkedList <BinaryTreeNode <int> > lastLinkedList = new SinglyLinkedList <BinaryTreeNode <int> >();
lastLinkedList.AppendToEnd(head);
while (lastLinkedList.Head != null)
{
SingleLinkedListNode <BinaryTreeNode <int> > lastLinkedListNode = lastLinkedList.Head;
SinglyLinkedList <BinaryTreeNode <int> > newLinkedList = new SinglyLinkedList <BinaryTreeNode <int> >();
while (lastLinkedListNode != null)
{
if (lastLinkedListNode.Data.Left != null)
{
// Add the left child to the linked list
newLinkedList.AppendToEnd(lastLinkedListNode.Data.Left);
}
if (lastLinkedListNode.Data.Right != null)
{
// Add the right child to the linked list
newLinkedList.AppendToEnd(lastLinkedListNode.Data.Right);
}
lastLinkedListNode = lastLinkedListNode.NextNode;
}
retList.Add(lastLinkedList);
lastLinkedList = newLinkedList;
}
return(retList);
}
public bool DeleteNode(SingleLinkedListNode <int> delNode)
{
// Error check: null node cannot be deleted
if (delNode == null)
{
return(false);
}
if (delNode.NextNode == null)
{
// This is the case which will not be handled by this method
// if we do delNode = null, we are only changing the reference delNode
// and it will not affect the node
// We can mark the last node as dummy node, but the functions calling
// this method should also know how to handle the dummy node.
return(false);
}
else
{
SingleLinkedListNode <int> nextNode = delNode.NextNode;
delNode.Data = nextNode.Data;
delNode.NextNode = nextNode.NextNode;
return(true);
}
}
/// <summary>
/// We need to check whether list2 is present in list1.
/// Naive Algo: travese list1 and keep checking for match with list2.
///
/// The running time is O(m*n) where m is the length of list1 and n is the length of list2
/// The space requirement is O(1)
/// </summary>
/// <param name="list1"></param>
/// <param name="list2"></param>
/// <returns>true if list2 is a subset of list1</returns>
public bool Search1(SingleLinkedListNode <int> list1, SingleLinkedListNode <int> list2)
{
if (list1 == null || list2 == null)
{
// Argument check
throw new ArgumentNullException("the input linked list cannot be null");
}
SingleLinkedListNode <int> head2 = list2;
while (list1 != null && list2 != null)
{
if (list1.Data == list2.Data)
{
list1 = list1.NextNode;
list2 = list2.NextNode;
if (list2 == null)
{
// we have a match
return(true);
}
}
else
{
list2 = head2;
if (list2.Data != list1.Data)
{
list1 = list1.NextNode;
}
}
}
return(false); // no match
}
public void Test()
{
var multipleNodesList = new SingleLinkedListNode <int> {
Value = 1, Next = null
};
var nextNode = Insert(multipleNodesList, 2);
Insert(nextNode, 3);
var multipleNodesListToBeReversed = new SingleLinkedListNode <int> {
Value = 1, Next = null
};
nextNode = Insert(multipleNodesListToBeReversed, 2);
Insert(nextNode, 3);
var withRemovedNodesList = new SingleLinkedListNode <int> {
Value = 1, Next = null
};
nextNode = Insert(withRemovedNodesList, 2);
Insert(nextNode, 3);
RemoveAfter(withRemovedNodesList);
Assert.Equal(new[] { 1, 2, 3 }, Content(multipleNodesList));
Assert.Equal(new[] { 3, 2, 1 }, Content(Reverse(multipleNodesList)));
Assert.Equal(new[] { 3, 2, 1 }, Content(ReverseInPlace(multipleNodesListToBeReversed)));
Assert.Equal(new[] { 1, 3 }, Content(withRemovedNodesList));
}
/// <summary>
/// Given 2 linked list, we should do a sum of them and return the result in a linkedlist
/// ll1 = 1->5->3
/// ll2 = 4->7->2
/// 351+274 = 625
/// so return 5->2->6
/// </summary>
/// <param name="ll1"></param>
/// <param name="ll2"></param>
/// <returns></returns>
public SingleLinkedListNode <int> AddLinkedLists(SingleLinkedListNode <int> ll1, SingleLinkedListNode <int> ll2)
{
int num1 = GetNumFromLL(ll1);
int num2 = GetNumFromLL(ll2);
int sum = num1 + num2;
return(GetLLFromNum(sum));
}
public void Push(SingleLinkedListNode <T> nodeToPush)
{
if (nodeToPush != null)
{
nodeToPush.NextNode = Top;
Top = nodeToPush;
}
}
internal Enumerator(LinkedStack <T> stack)
{
_stack = stack;
_version = stack._version;
_node = stack._top.Next;
_current = default(T);
_index = 0;
}
internal Enumerator(LinkedQueue <T> queue)
{
_queue = queue;
_version = queue._version;
_node = queue._head.Next;
_current = default(T);
_index = 0;
}
public void Enqueue(T item)
{
var node = new SingleLinkedListNode <T>(item);
_tail.Next = node;
_tail++;
++_count;
++_version;
}
public void AddAfter_SelectedNodeNotPresentInList_ThrowsInvalidOperationException()
{
var notPresentNode = new SingleLinkedListNode <int>(5);
var newNode = new SingleLinkedListNode <int>(4);
TestDelegate del = () => _list.AddAfter(notPresentNode, newNode);
Assert.Throws <InvalidOperationException>(del);
}
public static SingleLinkedListNode Solve(SingleLinkedListNode l1, SingleLinkedListNode l2)
{
if (l1 == null)
{
return(l2);
}
if (l2 == null)
{
return(l1);
}
var newHead = new SingleLinkedListNode(0);
SingleLinkedListNode p1 = l1, p2 = l2, pResult = newHead;
while (p1 != null || p2 != null)
{
if (p1 == null)
{
pResult.Next = new SingleLinkedListNode(p2.Data);
p2 = p2.Next;
goto END;
}
if (p2 == null)
{
pResult.Next = new SingleLinkedListNode(p1.Data);
p1 = p1.Next;
goto END;
}
if (p1.Data == p2.Data)
{
var newNode = new SingleLinkedListNode(p1.Data);
newNode.Next = new SingleLinkedListNode(p2.Data);
pResult.Next = newNode;
p1 = p1.Next;
p2 = p2.Next;
pResult = pResult.Next;
}
else if (p1.Data > p2.Data)
{
pResult.Next = new SingleLinkedListNode(p2.Data);
p2 = p2.Next;
}
else
{
pResult.Next = new SingleLinkedListNode(p1.Data);
p1 = p1.Next;
}
END : pResult = pResult.Next;
}
return(newHead.Next);
}
public void Reset()
{
if (_version != _stack._version)
{
throw new InvalidOperationException();
}
_current = default(T);
_node = _stack._top.Next;
_index = 0;
}
public void Push( double value )
{
// New value is stored
SingleLinkedListNode newValue = new SingleLinkedListNode() { Value = value };
// Fix the links
if( _data == null )
{
_data = newValue;
}
else
{
newValue.Next = _data.Next; ;
_data.Next = newValue;
}
}
public void TestGetKthNodeFromLastUsingRunnerTechnique()
{
var headNode = new SingleLinkedListNode<int>(1);
var linkedList = new SingleLinkedList<int>(headNode);
var secondNode = new SingleLinkedListNode<int>(2);
var thirdNode = new SingleLinkedListNode<int>(3);
var fourthNode = new SingleLinkedListNode<int>(4);
var fifthNode = new SingleLinkedListNode<int>(5);
var sixthNode = new SingleLinkedListNode<int>(6);
var seventhNode = new SingleLinkedListNode<int>(7);
linkedList.AddToTail(secondNode);
linkedList.AddToTail(thirdNode);
linkedList.AddToTail(fourthNode);
linkedList.AddToTail(fifthNode);
linkedList.AddToTail(sixthNode);
linkedList.AddToTail(seventhNode);
int kthNodeFromLastUsingRunnerTechnique = linkedList.GetKthNodeFromLastUsingRunnerTechnique(5);
Assert.AreEqual(3,kthNodeFromLastUsingRunnerTechnique);
}
public void TestAddNodeToTail()
{
var headNode = new SingleLinkedListNode<int>(1);
var linkedList = new SingleLinkedList<int>(headNode);
var midNode = new SingleLinkedListNode<int>(2);
var childNode = new SingleLinkedListNode<int>(3);
Assert.AreEqual(1, linkedList.Count);
linkedList.AddToTail(midNode);
Assert.AreEqual(2, linkedList.Count);
linkedList.AddToTail(childNode);
Assert.AreEqual(3, linkedList.Count);
IEnumerable<int> nodeData = linkedList.GetAllNodeValues().ToList();
Assert.AreEqual(1,nodeData.First());
Assert.AreEqual(2, nodeData.Skip(1).First());
Assert.AreEqual(3, nodeData.Last());
Console.WriteLine(string.Join(",",nodeData.ToArray()));
}
public void TestDeleteNode()
{
var headNode = new SingleLinkedListNode<int>(1);
var linkedList = new SingleLinkedList<int>(headNode);
var midNode = new SingleLinkedListNode<int>(2);
var childNode = new SingleLinkedListNode<int>(3);
linkedList.AddToTail(midNode);
Assert.AreEqual(2, linkedList.Count);
linkedList.AddToTail(childNode);
IEnumerable<int> nodeData = linkedList.GetAllNodeValues().ToList();
Assert.AreEqual(1, nodeData.First());
Assert.AreEqual(2, nodeData.Skip(1).First());
Assert.AreEqual(3, nodeData.Last());
SingleLinkedListNode<int> currentLinkedList = linkedList.DeleteNode(2);
nodeData = linkedList.GetAllNodeValues().ToList();
Assert.AreEqual(2,nodeData.Count());
Assert.AreEqual(1, nodeData.First());
Assert.AreEqual(3, nodeData.Last());
}
