/// <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()); }