コード例 #1
0
ファイル: Program.cs プロジェクト: feifeiyu777/Algorithm
        static void Main(string[] args)
        {
            LinkListProblems llist = new LinkListProblems();

            ListNode l1 = new ListNode(1);
            //l1.next = new ListNode(4);
            //l1.next.next = new ListNode(3);

            ListNode l2 = new ListNode(9);
            l2.next = new ListNode(9);
            //l2.next.next = new ListNode(4);

            llist.AddTwoNumbers(l1,l2);
        }
コード例 #2
0
        public ListNode AddTwoNumbers(ListNode l1, ListNode l2)
        {
            ListNode resL = new ListNode(0);
            ListNode pL1 = l1;
            ListNode pL2 = l2;
            ListNode result = resL;

            int sum = int.MinValue;
            int preValue = 0;
            while (pL1 != null && pL2 != null)
            {
                sum = pL1.val + pL2.val + preValue;
                preValue = sum / 10;
                sum = sum % 10;

                resL.next = new ListNode(sum);
                pL1 = pL1.next;
                pL2 = pL2.next;
                resL = resL.next;
            }

            while (pL1 != null)
            {
                sum = pL1.val + preValue;
                preValue = sum / 10;
                sum = sum % 10;
                resL.next = new ListNode(sum);
                pL1 = pL1.next;
                resL = resL.next;
            }

            while (pL2 != null)
            {
                sum = pL2.val + preValue;
                preValue = sum / 10;
                sum = sum % 10;
                resL.next = new ListNode(sum);
                pL2 = pL2.next;
                resL = resL.next;
            }

            if (preValue > 0)
            {
                resL.next = new ListNode(preValue);
            }
            return result.next;
        }
コード例 #3
0
        private ListNode <T> this[long index]
        {
            get
            {
                if (index < 0 || index > this.Count - 1)
                {
                    throw new ArgumentOutOfRangeException("index", "Index cannot be negative or bigger than the count of elements - 1.");
                }

                long         i           = 0;
                ListNode <T> currentNode = this.head;
                while (i != index)
                {
                    currentNode = currentNode.NextNode;
                    i++;
                }

                return(currentNode);
            }
        }
コード例 #4
0
        public void Test(int[] input, int[] output, int target)
        {
            var head      = CreateLinkedList(input);
            var empty     = new ListNode(-1, head);
            var copyEmpty = empty;

            while (empty.next != null)
            {
                if (empty.next.val == target)
                {
                    empty.next = empty.next?.next;
                }
                else
                {
                    empty = empty.next;
                }
            }

            ToArray(copyEmpty.next).Should().BeEquivalentTo(output);
        }
コード例 #5
0
        private T RemoveAt(int index)
        {
            if (index >= count || index < 0)
            {
                throw new ArgumentOutOfRangeException("Invalid index: " + index);
            }

            // Find the element at the specified index
            int currentIndex = 0;
            ListNode currentNode = this.head;
            ListNode prevNode = null;
            while (currentIndex < index)
            {
                prevNode = currentNode;
                currentNode = currentNode.NextNode;
                currentIndex++;
            }

            // Remove the foung element from the list of nodes
            RemoveListNode(currentNode, prevNode);
            return currentNode.Element;
        }
コード例 #6
0
ファイル: Program.cs プロジェクト: vikas3045/oldprep
        public static LinkedList.ListNode MoveZerosToFront(LinkedList.ListNode head)
        {
            var currentNode = head;

            while (currentNode != null)
            {
                if (currentNode.Next != null)
                {
                    if (currentNode.Next.Data == 0)
                    {
                        var nodeToBeMoved = currentNode.Next;
                        currentNode.Next   = nodeToBeMoved.Next;
                        nodeToBeMoved.Next = head;
                        head = nodeToBeMoved;
                    }
                }

                currentNode = currentNode.Next;
            }

            return(head);
        }
コード例 #7
0
        public ListNode MergeTwoLists(ListNode l1, ListNode l2)
        {
            ListNode list1 = l1;
            ListNode list2 = l2;

            if (list1 == null && list2 == null)
            {
                return(list1);
            }
            List <ListNode> arrList = new List <ListNode>();

            while (list1 != null)
            {
                arrList.Add(list1);
                list1 = list1.next;
            }

            while (list2 != null)
            {
                arrList.Add(list2);
                list2 = list2.next;
            }

            List <ListNode> SortedList = arrList.OrderBy(o => o.val).ToList();
            ListNode        head       = new ListNode(SortedList[0].val);
            ListNode        temp       = head;

            for (int i = 1; i < SortedList.Capacity; i++)
            {
                ListNode newNode = new ListNode(SortedList[i].val);
                temp.next = newNode;
                temp      = newNode;
            }

            return(head);
        }
コード例 #8
0
 private void RemoveListNode(ListNode node, ListNode prevNode)
 {
     count--;
     if (count == 0)
     {
         // The list becomes empty
         this.head = null;
         this.tail = null;
     }
     else if (prevNode == null)
     {
         // The head node was removed --> update the head
         this.head = node.NextNode;
     }
     else
     {
         prevNode.NextNode = node.NextNode;
     }
     // Fix the tail in case it was removed
     if (object.ReferenceEquals(this.tail, node))
     {
         this.tail = prevNode;
     }
 }
コード例 #9
0
        public ListNode CreateLinkedList(int[] numbers)
        {
            if (numbers == null || !numbers.Any())
            {
                return(null);
            }

            if (numbers.Length == 1)
            {
                return(new ListNode(numbers.First()));
            }

            var root    = new ListNode(numbers.First());
            var current = root;

            foreach (var number in numbers.Skip(1))
            {
                var newNode = new ListNode(number);
                current.next = newNode;
                current      = newNode;
            }

            return(root);
        }
コード例 #10
0
 public DynamicList()
 {
     this.head = null;
     this.tail = null;
     this.count = 0;
 }
コード例 #11
0
ファイル: Program.cs プロジェクト: prolificcoder/csharpcoding
        static void Main(string[] args)
        {
            Program p = new Program();
            //FrequencyLinkedListNode root= p.GetWordCountsInLinkedList("this is a this is mega a a a this this this ".Split().ToList());
            //Console.WriteLine(root);
            //FrequencyLinkedListNode cur = root;
            //while (cur != null)
            //{
            //  Console.WriteLine(cur.word+"  "+cur.frequency);
            //    cur=cur.next;
            //}
            //VertexedLinkedListNode root, n1, n2,n3,n4,n5,n6;
            //n6 = new VertexedLinkedListNode(8, null, true);
            //n5 = new VertexedLinkedListNode(8, n6, true);
            //n4 = new VertexedLinkedListNode(8, n5, true);
            //n3 = new VertexedLinkedListNode(8, n4, true);
            //n2 = new VertexedLinkedListNode(8, n3, true);
            //n1 = new VertexedLinkedListNode(8, n2, true);
            //root = new VertexedLinkedListNode(5, n1, true);

            //Console.WriteLine(p.MaxDistanceBetweenVertices(root));

            //ListNode n2 = null;
            //ListNode n4 = new ListNode(6, n2);
            //ListNode n3 = new ListNode(5, n4);

            //n2 = new ListNode(4, n3);
            //n4.next = n2;
            //ListNode root = new ListNode(3, n2);
            //LinkedList ll = new LinkedList(root);
            //// root1 = p.Merge(root1, root2);
            //while (root1 != null)
            //{
            //    Console.WriteLine(root1.data);
            //    root1 = root1.next;
            //}
               // Console.WriteLine(ll.ToString());
            //Console.Write(ll.DetectCycle(ll.head));
            //Console.WriteLine(ll.GetCycleListLength(ll.head));
            //DoubleListNode n1, n2, n3, n4, n5;
            //n1 = new DoubleListNode(1, 0);
            //n2 = new DoubleListNode(2, 1);
            //n3 = new DoubleListNode(3, 2);
            //n4 = new DoubleListNode(4, 1);
            //PriorityQueue pq = new PriorityQueue();
            //pq.Enqueue(n1);
            //pq.Enqueue(n2);
            //pq.Enqueue(n3);
            //pq.Enqueue(n4);
            //DoubleListNode d = pq.Deque();
            //pq.Enqueue(new DoubleListNode(5, 0));
            //d = pq.Deque();
            //d = pq.Deque();
            //Console.WriteLine(d.data + " " + d.priority);
            ListNode root, n1,n2,n3,n4,n5,n6;
            n6 = new ListNode(7, null);
            n5 = new ListNode(6, n6);
            n4 = new ListNode(5, n5);
            n3 = new ListNode(4, n4);
            n2 = new ListNode(3, n3);
            n1 = new ListNode(2, n2);
            root = new ListNode(1, n1);

            //ListNode root1, n3, n4;
            //n4 = new ListNode(10, null);
            //n3 = new ListNode(6, n4);
            //root1 = new ListNode(3, n3);
            ListNode cur = p.SwapAdjacent2(root);
            while (cur != null)
            {
                Console.WriteLine(cur);
                cur = cur.next;
            }
        }
コード例 #12
0
ファイル: LinkedList.cs プロジェクト: petrlevin/linked-list
        public void Remove(ListNode <T> target)
        {
            var index = target._index;

            Remove(index);
        }
コード例 #13
0
ファイル: Program.cs プロジェクト: prolificcoder/csharpcoding
 internal bool DetectCycle(ListNode head)
 {
     if (head.next == null || head == null)
         return false;
     ListNode slow = head;
     ListNode fast = head.next;
     while (slow != null && fast != null && fast.next !=null)
     {
         if (fast.next == slow || fast == slow)
             return true;
         else
         {
             slow = slow.next;
             fast = fast.next.next;
         }
     }
     return false;
 }
コード例 #14
0
ファイル: LinkedList.cs プロジェクト: petrlevin/linked-list
 public ListNode <T> AddBefore(ListNode <T> target, T value)
 {
     return(_reverse.Add(target, value));
 }
コード例 #15
0
ファイル: LinkedList.cs プロジェクト: petrlevin/linked-list
 public ListNode <T> AddAfter(ListNode <T> target, T value)
 {
     return(_forward.Add(target, value));
 }
コード例 #16
0
ファイル: Program.cs プロジェクト: prolificcoder/csharpcoding
 public LinkedList(ListNode head)
 {
     this.head = head;
 }
コード例 #17
0
ファイル: Program.cs プロジェクト: prolificcoder/csharpcoding
 internal int GetCycleListLength(ListNode head)
 {
     if (head == null)
         return 0;
     int count = 0;
     ListNode slow = head;
     ListNode fast = head;
     while (fast.next != null)
     {
         slow = slow.next;
         fast = fast.next.next;
         count++;
         if (fast == slow)
             break;
     }
     slow = head;
     while (fast != slow)
     {
         count++;
         slow = slow.next;
         fast = fast.next;
     }
     return count;
 }
コード例 #18
0
ファイル: Program.cs プロジェクト: prolificcoder/csharpcoding
        ListNode SwapAdjacent2(ListNode head)
        {
            ListNode cur = head;
            ListNode temp= null;
             while (cur != null && cur.next != null)
            {
                ListNode forward = cur.next;
                cur.next = forward.next;
                forward.next = cur;
                if (cur == head)
                    head = forward;
                if (temp != null)
                    temp.next = forward;
                temp = cur;
                cur = cur.next;

            }
            return head;
        }
コード例 #19
0
 public ListNode(T element, ListNode prevNode)
 {
     this.Element = element;
     prevNode.NextNode = this;
 }
コード例 #20
0
ファイル: Program.cs プロジェクト: prolificcoder/csharpcoding
 internal ListNode GetCycleStartNode(ListNode head)
 {
     if (head == null )
         return null;
     ListNode slow = head;
     ListNode fast = head;
     while (fast.next !=null)
     {
         slow = slow.next;
         fast = fast.next.next;
         if (fast == slow)
             break;
     }
     slow = head;
     while (fast != slow)
     {
         slow = slow.next;
         fast = fast.next;
     }
     return fast;
 }
コード例 #21
0
ファイル: Program.cs プロジェクト: prolificcoder/csharpcoding
 public ListNode(int data, ListNode next)
 {
     this.data = data;
     this.next = next;
 }
コード例 #22
0
ファイル: Program.cs プロジェクト: prolificcoder/csharpcoding
 ListNode SwapAdjacent(ListNode head)
 {
     ListNode prev = null, cur = head;
     while (cur != null && cur.next != null)
     {
         if (prev == null)
         {
             head = cur.next;
             ListNode temp = cur.next.next;
             cur.next.next = cur;
             cur.next = temp;
             prev = cur;
         }
         else
         {
             prev.next = cur.next;
             cur.next = cur.next.next;
             prev.next.next = cur;
             prev = cur;
         }
         cur = cur.next;
     }
     return head;
 }
コード例 #23
0
ファイル: Program.cs プロジェクト: prolificcoder/csharpcoding
 //Merge in merge sort for linked list
 ListNode Merge(ListNode h1, ListNode h2)
 {
     if (h2 == null) return h1;
     if (h1 == null) return h2;
     ListNode cur1 = h1, cur2 = h2;
     while (cur2 != null)
     {
         if (cur1.data >= cur2.data)
         {
             ListNode temp = cur2.next;
             cur2.next = cur1;
             cur1 = cur2;
             cur2 = temp;
         }
         else
         {
             while ( cur1.next != null && cur1.next.data < cur2.data)
             {
                 cur1 = cur1.next;
             }
             if (cur1.next == null)
             {
                 cur1.next = cur2;
                 return cur1;
             }
             else
             {
                 ListNode temp = cur2.next;
                 cur2.next = cur1.next;
                 cur1.next = cur2;
                 cur2 = temp;
             }
         }
     }
     return h1;
 }
コード例 #24
0
 public ListNode(T element)
 {
     this.Element = element;
     NextNode = null;
 }