Esempio n. 1
0
        public static void Main(string[] args)
        {
            LinkedList<string> linked = new LinkedList<string>();
            //
            // Use AddLast method to add elements at the end.
            // Use AddFirst method to add element at the start.
            //
            linked.AddLast("Third");
            linked.AddLast("Fourth");
            linked.AddLast("Fifth");
            linked.AddFirst("Second");
            linked.AddLast("Sixth");
            linked.AddFirst("First");
            linked.RemoveFirst ();
            //linked.RemoveLast();
            linked.Find("Fourth");
            //linked.FindLast ("dog");
            int x=linked.Count;
            Console.WriteLine (x);

            // Insert a node before the second node (after the first node)
            //
            LinkedListNode<string> node = linked.Find("Third");
            linked.AddAfter(node, "inserted");
            //
            // Loop through the linked list.
            foreach (string s in linked)
                Console.WriteLine (s);
        }
Esempio n. 2
0
        public static void Main()
        {
            var list = new LinkedList<int>();

            list.ForEach(Console.WriteLine);
            Console.WriteLine("--------------------");

            list.Add(5);
            list.Add(3);
            list.Add(5);
            list.Add(10);
            Console.WriteLine("First index of element (5): {0}", list.FirstIndexOf(5));
            Console.WriteLine("Last index of element (5): {0}", list.LastIndexOf(5));

            Console.WriteLine("Count = {0}", list.Count);

            list.ForEach(Console.WriteLine);
            Console.WriteLine("--------------------");

            list.Remove(0);
            list.Remove(2);
            list.Remove(0);

            list.ForEach(Console.WriteLine);
            Console.WriteLine("--------------------");

            list.Remove(0);

            list.ForEach(Console.WriteLine);
            Console.WriteLine("--------------------");
        }
Esempio n. 3
0
        static void Main(string[] args)
        {
            int[] inputA = new int[] { 7, 1, 6, 2 };

            ListNode cycleNode  = new ListNode();
            ListNode node       = new ListNode();
            ListNode cycleNode2 = new ListNode();

            cycleNode.Data  = 10;
            cycleNode.Next  = cycleNode2;
            cycleNode2.Data = 11;
            cycleNode.Next  = node;
            node.Data       = 3;
            node.Next       = cycleNode;

            LinkedList.LinkedList listA = new LinkedList.LinkedList();

            for (int i = 0; i < inputA.Length; i++)
            {
                listA.AddLast(new ListNode()
                {
                    Data = inputA[i]
                });
            }

            //listA.AddLast(node);

            Console.WriteLine(GetLoopNode(listA.Head).Data);
            Console.ReadLine();
        }
 public void ShouldReturnOneForOneElementList()
 {
     LinkedList<int> myList = new LinkedList<int>();
     myList.Add(0);
     int result = myList.Count;
     Assert.Equal(1, result);
 }
Esempio n. 5
0
        private static void Main(string[] args)
        {
            // Creation
            ILinkedList<int> testList = new LinkedList<int>() { 1, 2, 3, 4, 5};

            // Addition
            testList.Add(6);
            testList.Add(7);
            Console.WriteLine(string.Join(", ", testList)); // Enumerator

            // Removal
            testList.Remove(4);
            Console.WriteLine(string.Join(", ", testList));

            Console.WriteLine("Contains 6: " + testList.Contains(6));
            Console.WriteLine("Contains 4: " + testList.Contains(4));

            int[] arr = new int[6];
            testList.CopyTo(arr, 0);
            Console.WriteLine("Copied to array " + string.Join(", ", arr));

            testList.AddAfter(6, 13);
            Console.WriteLine("Add after result " + string.Join(", ", testList));

            testList.AddBefore(6, 13);
            Console.WriteLine("Add before result " + string.Join(", ", testList));
        }
Esempio n. 6
0
        static void Main()
        {
            var list = new LinkedList<int>();
            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Add(2);
            list.Add(2);

            Console.WriteLine("Count -> " + list.Count);
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine("Remoeved at index 0 -> " + list.Remove(0));
            Console.WriteLine("Count -> " + list.Count);
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine("First index of 2 -> " + list.FristIdexOf(2));
            Console.WriteLine("Last index of 2 -> " + list.LastIndexOf(2));
        }
Esempio n. 7
0
        public static void Main()
        {
            LinkedList<int> myTestLinkedList = new LinkedList<int>();
            myTestLinkedList.AddFirst(1);
            myTestLinkedList.AddLast(2);
            myTestLinkedList.AddLast(3);
            myTestLinkedList.AddLast(2);
            myTestLinkedList.AddLast(6);
            myTestLinkedList.AddLast(4);

            ListItem<int> itemInMiddle = myTestLinkedList.Find(3);
            myTestLinkedList.AddAfter(itemInMiddle, 10);

            myTestLinkedList.AddFirst(100);

            ListItem<int> currItem = myTestLinkedList.FirstElement;

            while (currItem.NextItem != null)
            {
                Console.WriteLine(currItem.Value);

                currItem = currItem.NextItem;
            }

            Console.WriteLine(currItem.Value);
        }
Esempio n. 8
0
        static void Main(string[] args)
        {
            var firstItem = new ListItem<int>(5, null);
            var linkedList = new LinkedList<int>(firstItem);

            //TODO: IMPLEMENT FUNCTIONS
        }
Esempio n. 9
0
        static void Main(string[] args)
        {
            int[] inputA = new int[] { 5, 6 };

            LinkedList.LinkedList listA = new LinkedList.LinkedList();

            for (int i = 0; i < inputA.Length; i++)
            {
                listA.AddLast(new ListNode()
                {
                    Data = inputA[i]
                });
            }

            int[] inputB = new int[] { 8, 4, 2 };

            LinkedList.LinkedList listB = new LinkedList.LinkedList();

            for (int i = 0; i < inputB.Length; i++)
            {
                listB.AddLast(new ListNode()
                {
                    Data = inputB[i]
                });
            }

            LinkedList.LinkedList listSum = new LinkedList.LinkedList();
            listSum.Head = SumTwoNumbersLinkedList(listA.Head, listB.Head, carryForward);

            listSum.Print();

            Console.ReadLine();
        }
Esempio n. 10
0
        static void Main(string[] args)
        {
            LinkedList<int> list = new LinkedList<int>();
            for (int i = 0; i < 10; i++)
            {
                list.Add(new Random().Next(0, 20));
                Thread.Sleep(20);
            }

            list.AddRange(GetRandEnumerable(10));

            foreach (var item in list)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine(list.Contains(7));
            Console.WriteLine(list.Find(7));

            list.RemoveOneFirst(7);
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }

            Console.ReadKey();
        }
Esempio n. 11
0
        public static void Main()
        {
            try
            {
                LinkedList<int> linkedList = new LinkedList<int>();
                linkedList.AddFirst(5);
                linkedList.AddLast(10);
                linkedList.AddFirst(20);
                // returns Exception
                //linkedList.AddItemAt(30, 0);
                linkedList.AddItemAt(30, 1);

                Console.WriteLine(linkedList[1]);

                linkedList.AddLast(50);
                linkedList.AddAfter(linkedList.FirstElement.NextItem.NextItem.NextItem, 60);
                linkedList.AddBefore(linkedList.FirstElement, 0);
                linkedList.RemoveFirst();
                linkedList.RemoveLast();
                linkedList.RemoveAt(1);

                Console.WriteLine(linkedList[1]);
                Console.WriteLine(linkedList.Count);

                linkedList.RemoveAt(5);
            }
            catch (ArgumentException aex)
            {
                Console.WriteLine(aex.TargetSite + " -> " + aex.Message);
            }
            catch (IndexOutOfRangeException iex)
            {
                Console.WriteLine(iex.TargetSite + " -> " + iex.Message);
            }
        }
Esempio n. 12
0
        public static ListNode ReverseInGroups(ListNode head, int k)
        {
            Stack <int> stack = new Stack <int>(k);

            LinkedList.LinkedList result = new LinkedList.LinkedList();
            ListNode resultHead          = null;
            ListNode current             = head;

            while (current != null)
            {
                while (stack.Count < k && current != null)
                {
                    stack.Push(current.Data);
                    current = current.Next;
                }

                while (stack.Count > 0)
                {
                    int data = stack.Pop();
                    result.AddLast(new ListNode(data));

                    resultHead = AddToLast(resultHead, new ListNode(data));
                }
            }

            return(result.Head);
        }
Esempio n. 13
0
File: StartUp.cs Progetto: GAlex7/TA
        public static void Main()
        {
            var myLinkedList = new LinkedList<int>();
            myLinkedList.First = new ListItem<int>(1);

            Console.WriteLine(myLinkedList.First.Value);
            Console.WriteLine(myLinkedList.First.NextItem);
        }
 public void ShouldAddTwoElementsAndReturnTworElementCountList()
 {
     LinkedList<int> myList = new LinkedList<int>();
     myList.Add(0);
     myList.Add(4);
     int result = myList.Count;
     Assert.Equal(2, result);
 }
Esempio n. 15
0
 public static void driver()
 {
     LinkedList lnkd = new LinkedList();
     lnkd.buildlist(10);
     lnkd.printList();
     //lnkd.revIter();
     lnkd.revRecur(lnkd.head);
     lnkd.printList();
 }
Esempio n. 16
0
        static void Main()
        {
            var linkedList = new LinkedList<int>();

            var firstListItem = new ListItem<int>();
            firstListItem.Value = 1;

            linkedList.FirstElement = firstListItem;
        }
        // Produces a randon number between minRange (inclusive) and maxRange (exclusive) and
        // generates a single linked list that is size of length.
        public void RunTests(uint minRange, uint maxRange, uint length)
        {
            Random random = new Random();

            // Vetting insert works.
            for (int i = 0; i < length; ++i)
            {
                // if this is our head node
                if (i == 0)
                {
                    myList = new LinkedList.LinkedList(random.Next((int)minRange, (int)maxRange));
                    continue;
                }

                myList.InsertSorted(random.Next((int)minRange, (int)maxRange));
            }

            // Vet size of list is the same as length
            if (length != myList.GetSize())
            {
                FailedTestCase("LENGTH");
            }
            else
            {
                System.Console.WriteLine("PASSED: sizeof linked list expected: " + length + " actual: " + myList.GetSize());
            }

            // Vetting its all sorted
            LinkedListNode.Node currentNode = myList.GetHeadNode();
            int count = 1;             //start count at 1 to count the Head;

            while (currentNode.GetNextNode() != null)
            {
                // check if current node is less than or equal to the next node
                if (currentNode.GetValue() <= currentNode.GetNextNode().GetValue())
                {
                    // so far its sorted, move to the next node
                    currentNode = currentNode.GetNextNode();
                }

                // we have a currentNode value that is > the nextNodes value, failed
                else
                {
                    FailedTestCase("SORTING - currentNode: " + currentNode.GetValue() + " nextNodes value: " + currentNode.GetNextNode().GetValue());
                    break;
                }
                count++;
            }

            // Manual count to make sure all is accounted for
            System.Console.WriteLine("PASSED: Manual count " + count.ToString());

            // Sorting test passed
            System.Console.WriteLine("PASSED: Sorting");
            myList.PrintList();
        }
Esempio n. 18
0
        static void Main(string[] args)
        {
            LinkedList list = new LinkedList();
            list.Add("Test1");
            list.Add("Test2");
            list.Add("Test3", 1);

            list.Remove(1);
            list.Clear();
        }
        static void Main()
        {
            var linkedList = new LinkedList<int>();
            for (int i = 0; i < 10; i++)
            {
                linkedList.Add(i);
            }

            Console.WriteLine(string.Join(", ", linkedList));
        }
        public void ShouldCheckIfInsertBeforeIndex3Works()
        {
            var list = new LinkedList<int>() { 9, 2, 7, 5 };

            list.InsertBefore(3, 3);
            int[] result = new int[] { 9, 2, 7, 3, 5 };

            Assert.Equal(result, list);
            Assert.Equal(5, list.Count);
        }
        public void ShouldCheckIfInsertAfterIndex0Works()
        {
            var list = new LinkedList<int>() { 9, 2, 7, 5 };

            list.InsertAfter(3, 0);
            int[] result = new int[] { 9, 3, 2, 7, 5 };

            Assert.Equal(result, list);
            Assert.Equal(5, list.Count);
        }
 public void ShouldReturnAnArrayWithElementsFromList()
 {
     LinkedList<int> myList = new LinkedList<int>();
     myList.Add(0);
     myList.Add(4);
     myList.Add(7);
     int[] result = new int[3];
     myList.CopyTo(result,0);
     int[] expected = { 0, 4, 7 };
     Assert.Equal(expected,result);
 }
 public void ShouldReturnAnArrayWithElementsFromListStartingFromOne()
 {
     LinkedList<int> myList = new LinkedList<int>();
     myList.Add(3);
     myList.Add(4);
     myList.Add(7);
     int[] result = new int[2];
     myList.CopyTo(result, 1);
     int[] expected = { 0, 3 };
     Assert.Equal(expected, result);
 }
 public void ShouldRemoveFirstElementWithValueFour()
 {
     LinkedList<int> myList = new LinkedList<int>();
     myList.Add(0);
     myList.Add(4);
     myList.Add(7);
     myList.Remove(4);
     int[] expected = { 0, 7 };
     int[] result = new int[2];
     myList.CopyTo(result, 0);
     Assert.Equal(expected, result);
 }
Esempio n. 25
0
        static void Main(string[] args)
        {
            LinkedList<int> list = new LinkedList<int>();
            list.AddToEnd(3);
            list.AddToEnd(8);
            list.AddToFront(5);
            list.DeleteFromEnd();
            list.DeleteFromHead();

            list.Display();
            Console.WriteLine(list.Search(7));
        }
        public void ShouldCheckIfValueAtIndexIsRemoved()
        {
            var list = new LinkedList<int>() { 9, 2, 7, 5 };
            //list.Remove(2);
            //int[] result = new int[] { 9, 2, 5 };

            list.Remove(0);
            int[] result = new int[] { 2, 7, 5 };

            Assert.Equal(result,list);
            Assert.Equal(3, list.Count);
        }
Esempio n. 27
0
        /**
         * Initiates the program by constructing and editing a linked list.
         *
         * @param args command line arguments
         */ 
        static void Main(string[] args)
        {
            LinkedList list = new LinkedList();
            list.add("Thomas");
            list.add("Curtis");
            list.add("Zach");
            Console.WriteLine(list.getHead().data);

            Console.WriteLine("Lets print the entire list\n");
            Console.WriteLine(list.ToString());

            Console.ReadLine();
        }
Esempio n. 28
0
        static void Main(string[] args)
        {
            LinkedList<int> test = new LinkedList<int>();
            test.Add(0);
            test.Add(1);
            test.Add(2);
            test.Add(3);
            test.Add(3);

            test.Remove(0);

            Console.WriteLine(test.FirstIndexOf(2));
            Console.WriteLine(test.LastIndexOf(3));
        }
Esempio n. 29
0
        public static void Main()
        {
            LinkedList<int> list = new LinkedList<int>();
            list.AddFirst(5);
            list.AddFirst(1);
            list.AddLast(-10);
            list.AddLast(8);
            list.AddFirst(3);

            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
        }
Esempio n. 30
0
        static void Main(string[] args)
        {
            LinkedList<string> list = new LinkedList<string>();
            list.Add("x");
            list.Add("g");
            list.Add("s");

            Console.WriteLine(list.Count);

            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }

            list.InsertAfter("g", "a");

            Console.WriteLine();
            Console.WriteLine();

            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }

            //list.InsertAt(10, "z");

            Console.WriteLine();
            Console.WriteLine();

            list.InsertAt(2, "z");

            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }

            Console.WriteLine();
            Console.WriteLine();

            list.RemoveAt(2);

            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }

            //Console.WriteLine(list[2]);
        }
Esempio n. 31
0
        public static void Main()
        {
            var numbers = new LinkedList<int>();
            numbers.AddFirst(1);
            numbers.AddFirst(2);
            numbers.AddFirst(3);
            numbers.AddFirst(4);
            numbers.AddLast(5);
            numbers.AddLast(6);
            numbers.AddLast(7);

            int numberOfElements = numbers.Count;
            Console.WriteLine(NumberOfElementsMessage, numberOfElements);

            numbers.Print();
        }        
Esempio n. 32
0
        public static void Main()
        {
            var linkedList = new LinkedList<int>();
            linkedList.Add(5);
            linkedList.Add(10);
            linkedList.Add(42);
            linkedList.Add(45);
            linkedList.Add(5);
            linkedList.Remove(5);
            linkedList.Remove(45);
            Console.WriteLine(linkedList.Contains(42));

            foreach (var item in linkedList)
            {
                Console.WriteLine(item);
            }
        }
Esempio n. 33
0
        public static void Main()
        {
            LinkedList<int> list = new LinkedList<int>();

            ListItem<int> head = new ListItem<int>(1337);
            list.FirstElement = head;

            ListItem<int> secondElement = new ListItem<int>(666);
            head.NextItem = secondElement;

            secondElement.NextItem = new ListItem<int>(42);

            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
        }
Esempio n. 34
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 1, 2, 3, 1, 3, 2, 1 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.AddLast(new ListNode()
                {
                    Data = input[i]
                });
            }
            Console.WriteLine(IsPalindromeRec(list.Head));
            //Console.WriteLine(IsPalindrome(list.Head));
            Console.ReadLine();
        }
Esempio n. 35
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 1, 2, 3, 4, 5, 6, 7 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.AddLast(new ListNode()
                {
                    Data = input[i]
                });
            }

            Fold(list.Head);

            Console.ReadLine();
        }
Esempio n. 36
0
        public void TestReverse()
        {
            LinkedList<int> ll = new LinkedList<int>();
            ll.AddFirst(9);
            ll.AddFirst(8);
            ll.AddFirst(7);
            ll.AddFirst(6);
            ll.AddFirst(5);
            ll.AddFirst(4);
            ll.AddFirst(3);
            ll.AddFirst(2);
            ll.AddFirst(1);

            ll.Reverse();

            int[] myAnswer = ll.ToArray();

            int[] answer = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 1 };

            for (int i = 0; i < answer.Length; i++)
            {
                Assert.AreEqual(answer[i], myAnswer[i]);
            }

            LinkedList<int> l2 = new LinkedList<int>();
            l2.AddFirst(9);
            l2.AddFirst(8);
            l2.AddFirst(7);
            l2.AddFirst(6);
            l2.AddFirst(5);
            l2.AddFirst(4);
            l2.AddFirst(3);
            l2.AddFirst(2);
            l2.AddFirst(1);

            l2.ReverseRecursive();

            int[] myRecursiveAnswer = l2.ToArray();

            for (int i = 0; i < answer.Length; i++)
            {
                Assert.AreEqual(answer[i], myRecursiveAnswer[i]);
            }
        }
Esempio n. 37
0
        //Below method works correctly
        //public static ListNode MergeSort(ListNode head)
        //{
        //    if (head == null) return null;
        //    if (head.Next == null) return head;

        //    int length = GetLength(head);
        //    int mid = length / 2;

        //    LinkedList.LinkedList listA = new LinkedList.LinkedList();
        //    LinkedList.LinkedList listB = new LinkedList.LinkedList();

        //    for (int i = 0; i <= length - 1; i++)
        //    {
        //        ListNode temp = new ListNode();
        //        temp.Data = head.Data;

        //        if (i < mid)
        //        {
        //            listA.AddLast(temp);
        //        }
        //        else
        //        {
        //            listB.AddLast(temp);
        //        }

        //        head = head.Next;
        //    }

        //    var sortedHeadA = MergeSort(listA.Head);
        //    var sortedHeadB = MergeSort(listB.Head);
        //    return MergeLists(sortedHeadA, sortedHeadB);
        //}

        private static ListNode MergeLists(ListNode head1, ListNode head2)
        {
            if (head1 == null)
            {
                return(head2);
            }
            if (head2 == null)
            {
                return(head1);
            }

            LinkedList.LinkedList result = new LinkedList.LinkedList();

            while (head1 != null && head2 != null)
            {
                ListNode temp = new ListNode();
                if (head1.Data <= head2.Data)
                {
                    temp.Data = head1.Data;
                    head1     = head1.Next;
                }
                else
                {
                    temp.Data = head2.Data;
                    head2     = head2.Next;
                }

                result.AddLast(temp);
            }

            if (head1 != null)
            {
                result.AddLast(head1);
            }

            if (head2 != null)
            {
                result.AddLast(head2);
            }

            return(result.Head);
        }
Esempio n. 38
0
        public static ListNode MergeAlternateIterative(ListNode headA, ListNode headB)
        {
            if (headA == null && headB == null)
            {
                return(null);
            }
            if (headA == null)
            {
                return(headB);
            }
            if (headB == null)
            {
                return(headA);
            }

            LinkedList.LinkedList result = new LinkedList.LinkedList();
            while (headA != null && headB != null)
            {
                ListNode tempA = new ListNode();
                ListNode tempB = new ListNode();

                tempA.Data = headA.Data;
                tempB.Data = headB.Data;
                tempA.Next = tempB;
                result.AddLast(tempA);

                headA = headA.Next;
                headB = headB.Next;
            }

            if (headA != null)
            {
                result.AddLast(headA);
            }

            if (headB != null)
            {
                result.AddLast(headB);
            }

            return(result.Head);
        }
Esempio n. 39
0
        public void TestPrint2()
        {
            LinkedList.LinkedList linkedList = new LinkedList.LinkedList();
            linkedList.AddFront(1);
            linkedList.AddFront(2);
            linkedList.AddFront(3);
            linkedList.AddFront(4);
            linkedList.AddFront(5);

            List <int> expextedResult = new List <int>()
            {
                5, 4, 3, 2, 1
            };
            List <int> result = new List <int>();

            for (int i = 0; i < result.Count; i++)
            {
                Assert.AreEqual(expextedResult[i], result[i]);
            }
        }
Esempio n. 40
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 1, 5, 2, 3, 4, 2, 5, 9 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.AddLast(new ListNode()
                {
                    Data = input[i]
                });
            }

            list.Print();
            Console.WriteLine();
            Console.WriteLine(KthNodeFromEnd(list.Head, 5));
            Console.WriteLine(KthNodeFromEndAlt(list.Head, 5));
            Console.ReadLine();
        }
Esempio n. 41
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 12, 15, 10, 11, 5, 6, 2, 3 };
            //int[] input = new int[] { 10, 20, 30, 40, 50 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.AddLast(new ListNode()
                {
                    Data = input[i]
                });
            }

            LinkedList.LinkedList listA = new LinkedList.LinkedList();
            listA.Head = RemoveIfGreaterAtRight(list.Head);
            listA.Print();

            Console.ReadLine();
        }
Esempio n. 42
0
        public void TestDeleteFront()
        {
            LinkedList.LinkedList linkedList = new LinkedList.LinkedList();
            linkedList.Add(1);
            linkedList.Add(2);
            linkedList.Add(3);
            linkedList.Add(4);
            linkedList.Add(5);

            linkedList.DeleteFront();
            List <int> expextedResult = new List <int>()
            {
                2, 3, 4, 5
            };
            List <int> result = new List <int>();

            for (int i = 0; i < result.Count; i++)
            {
                Assert.AreEqual(expextedResult[i], result[i]);
            }
        }
Esempio n. 43
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 1, 5, 2, 3, 4, 2, 5, 9 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.AddLast(new ListNode()
                {
                    Data = input[i]
                });
            }

            list.Print();
            Console.WriteLine();
            DeleteMiddleNode(list.Head.Next.Next);

            list.Print();
            Console.ReadLine();
        }
Esempio n. 44
0
        static void Main(string[] args)
        {
            int[] inputA = new int[] { 7, 1, 6, 2 };

            ListNode node = new ListNode();

            node.Data = 3;
            node.Next = new ListNode()
            {
                Data = 10
            };

            LinkedList.LinkedList listA = new LinkedList.LinkedList();

            for (int i = 0; i < inputA.Length; i++)
            {
                listA.AddLast(new ListNode()
                {
                    Data = inputA[i]
                });
            }

            int[] inputB = new int[] { 5, 9, 6, 2 };

            LinkedList.LinkedList listB = new LinkedList.LinkedList();

            for (int i = 0; i < inputB.Length; i++)
            {
                listB.AddLast(new ListNode()
                {
                    Data = inputB[i]
                });
            }
            listA.AddLast(node);
            listB.AddLast(node);

            Console.WriteLine(GetIntersection(listA.Head, listB.Head).Data);

            Console.ReadLine();
        }
Esempio n. 45
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 0, 1, 3, 0, 4, 0, 9 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.InsertAtEnd(new LinkedList.ListNode()
                {
                    Data = input[i]
                });
            }

            list.Print();

            list.Head = MoveZerosToFront2(list.Head);

            list.Print();

            Console.ReadLine();
        }
Esempio n. 46
0
        static void Main(string[] args)
        {
            int[] inputA = new int[] { 10, 3, 2, 11, 34, 1, 76 };

            LinkedList.LinkedList listA = new LinkedList.LinkedList();

            for (int i = 0; i < inputA.Length; i++)
            {
                listA.AddLast(new ListNode()
                {
                    Data = inputA[i]
                });
            }

            listA.Print();

            LinkedList.LinkedList list = new LinkedList.LinkedList();
            list.Head = MergeSort(listA.Head);

            list.Print();
            Console.ReadLine();
        }
Esempio n. 47
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 1, 5, 2, 3, 4, 2, 5, 9 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.AddLast(new ListNode()
                {
                    Data = input[i]
                });
            }

            list.Print();
            Console.WriteLine();
            RemoveDupsWithoutBuffer(list.Head);
            //RemoveDups(list.Head);

            list.Print();
            Console.ReadLine();
        }
Esempio n. 48
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 2, 1, 3, 4, 5, 6, 7 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.AddLast(new ListNode()
                {
                    Data = input[i]
                });
            }

            list.Print();
            Console.WriteLine();
            list.Head = MoveEvenToFront(list.Head);

            list.Print();
            Console.WriteLine();

            Console.ReadLine();
        }
Esempio n. 49
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 1, 2, 3, 4, 5 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.InsertAtEnd(new LinkedList.ListNode()
                {
                    Data = input[i]
                });
            }

            list.Print();

            //list.Head = ReversePairRecursive(list.Head);
            list.Head = ReversePairIterative(list.Head);

            list.Print();

            Console.ReadLine();
        }
Esempio n. 50
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 1, 2, 3, 4, 5, 6, 7 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.AddLast(new ListNode()
                {
                    Data = input[i]
                });
            }
            list.Print();
            LinkedList.LinkedList test  = new LinkedList.LinkedList();
            LinkedList.LinkedList testB = new LinkedList.LinkedList();
            test.Head = ReverseInGroups(list.Head, 2);
            //testB.Head = ReverseInPairs(list.Head);
            //test.Head = ReverseInGroupsRecursive(list.Head, 3);
            test.Print();
            //testB.Print();
            Console.ReadLine();
        }
Esempio n. 51
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 3, 5, 8, 5, 10, 2, 1 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.AddLast(new ListNode()
                {
                    Data = input[i]
                });
            }

            list.Print();
            Console.WriteLine();
            //Partition(list.Head, 5);

            PartitionAlt(list.Head, 5);

            list.Print();
            Console.ReadLine();
        }
Esempio n. 52
0
        static void Main(string[] args)
        {
            int[] inputA = new int[] { 7, 1 };

            LinkedList.LinkedList listA = new LinkedList.LinkedList();

            for (int i = 0; i < inputA.Length; i++)
            {
                listA.AddLast(new ListNode()
                {
                    Data = inputA[i]
                });
            }

            int[] inputB = new int[] { 5, 9, 2 };

            LinkedList.LinkedList listB = new LinkedList.LinkedList();

            for (int i = 0; i < inputB.Length; i++)
            {
                listB.AddLast(new ListNode()
                {
                    Data = inputB[i]
                });
            }

            LinkedList.LinkedList sum = new LinkedList.LinkedList();
            sum.Head = SumLists(listA.Head, listB.Head);

            LinkedList.LinkedList sumForwardRepresentation = new LinkedList.LinkedList();
            sumForwardRepresentation.Head = SumListsForwardRepresentation(listA.Head, listB.Head);

            sum.Print();
            sumForwardRepresentation.Print();

            Console.ReadLine();
        }
Esempio n. 53
0
        static void Main(string[] args)
        {
            int[] input = new int[] { 1, 2, 3, 4, 5, 6, 7 };

            LinkedList.LinkedList list = new LinkedList.LinkedList();

            for (int i = 0; i < input.Length; i++)
            {
                list.AddLast(new ListNode()
                {
                    Data = input[i]
                });
            }

            list.Print();

            LinkedList.LinkedList test = new LinkedList.LinkedList();
            test.Head = ReverseList(list.Head);
            ///test.Head = ReverseListIterative(list.Head);

            test.Print();

            Console.ReadLine();
        }
Esempio n. 54
0
        static void Main(string[] args)
        {
            int[] inputA = new int[] { 1, 3, 5, 7, 9 };

            LinkedList.LinkedList listA = new LinkedList.LinkedList();

            for (int i = 0; i < inputA.Length; i++)
            {
                listA.AddLast(new ListNode()
                {
                    Data = inputA[i]
                });
            }


            int[] inputB = new int[] { 2, 4, 6, 8, 10, 11, 12, 13 };

            LinkedList.LinkedList listB = new LinkedList.LinkedList();

            for (int i = 0; i < inputB.Length; i++)
            {
                listB.AddLast(new ListNode()
                {
                    Data = inputB[i]
                });
            }

            LinkedList.LinkedList result = new LinkedList.LinkedList();
            result.Head = MergeAlternate(listA.Head, listB.Head);
            result.Print();

            LinkedList.LinkedList resultA = new LinkedList.LinkedList();
            resultA.Head = MergeAlternateIterative(listA.Head, listB.Head);
            resultA.Print();
            Console.ReadLine();
        }
Esempio n. 55
0
        static void Main(string[] args)
        {
            LinkedList.LinkedList lista1 = new LinkedList.LinkedList();

            lista1.add(1);
            lista1.add(4);
            lista1.add(3);
            lista1.add(7);

            Iterator it = lista1.getIterator();

            System.Console.WriteLine("-----Imprimimos Lista Original-----");

            while (it.hasNext())
            {
                int element = it.next();

                System.Console.WriteLine("Dato: " + element);
            }

            System.Console.WriteLine("-----Insertamos según posición-----");

            it = lista1.getIterator();

            while (it.hasNext())
            {
                Iterator backupIt = new Iterator(it);
                int      element  = it.next();

                if (element == 3)
                {
                    lista1.insert(10, LinkedList.LinkedList.BEFORE, backupIt);
                }

                if (element == 7)
                {
                    lista1.insert(15, LinkedList.LinkedList.AFTER, backupIt);
                }
            }

            it = lista1.getIterator();

            while (it.hasNext())
            {
                int element = it.next();

                System.Console.WriteLine("Dato: " + element);
            }

            System.Console.WriteLine("-----Eliminamos el valor 3-----");

            lista1.delete(3);

            System.Console.WriteLine("--- El tamaño es:" + lista1.getSize() + " ---");

            it = lista1.getIterator();

            while (it.hasNext())
            {
                int element = it.next();

                System.Console.WriteLine("Dato: " + element);
            }

            System.Console.WriteLine("-----Recorremos la lista con el ReverseIterator-----");

            ReverseIterator reverseIterator = lista1.getReverseIterator();

            while (reverseIterator.hasNext())
            {
                int element = reverseIterator.next();

                System.Console.WriteLine("Dato: " + element);
            }

            Console.ReadKey();
            Console.ReadKey();
        }