Esempio n. 1
0
        //This solution is used when reversing the linked list is allowed.
        public ListNode AddTwoNumbers(ListNode l1, ListNode l2)
        {
            ListNode reversedFirstNode = ReverseLinkedList(l1);
            ListNode reversedSecondNode = ReverseLinkedList(l2);

            //Display(reversedFirstNode);
            //Display(reversedSecondNode);

            int sum = 0, carry = 0;

            ListNode resultNode = null, lastNode = null;

            while (reversedFirstNode != null && reversedSecondNode != null)
            {
                //Console.WriteLine("First Node :- " + reversedFirstNode.val + " Second Node :- " + reversedSecondNode.val);

                sum = reversedFirstNode.val + reversedSecondNode.val + carry;

                carry = sum / 10;

                sum %= 10;

                //Console.WriteLine("Sum :- " + sum + " Carry :- " + carry);

                if (resultNode == null)
                {
                    resultNode = new ListNode(sum);
                    lastNode = resultNode;
                }
                else
                {
                    lastNode.next = new ListNode(sum);
                    lastNode = lastNode.next;
                }

                reversedFirstNode = reversedFirstNode.next;
                reversedSecondNode = reversedSecondNode.next;

                //Display(resultNode);
            }

            while (reversedFirstNode != null)
            {
                sum = reversedFirstNode.val + carry;

                carry = sum / 10;

                sum %= 10;

                if (resultNode == null)
                {
                    resultNode = new ListNode(sum);
                    lastNode = resultNode;
                }
                else
                {
                    lastNode.next = new ListNode(sum);
                    lastNode = lastNode.next;
                }

                reversedFirstNode = reversedFirstNode.next;
            }

            while (reversedSecondNode != null)
            {
                sum = reversedSecondNode.val + carry;

                carry = sum / 10;

                sum %= 10;

                if (resultNode == null)
                {
                    resultNode = new ListNode(sum);
                    lastNode = resultNode;
                }
                else
                {
                    lastNode.next = new ListNode(sum);
                    lastNode = lastNode.next;
                }

                reversedSecondNode = reversedSecondNode.next;
            }

            if (carry > 0)
            {
                lastNode.next = new ListNode(carry);
                lastNode = lastNode.next;
            }

            //Display(resultNode);

            return ReverseLinkedList(resultNode);
        }
Esempio n. 2
0
        //This solution is used when reversing the linked list is not allowed.
        public ListNode AddTwoNumbersWithoutReversing(ListNode nodeA, ListNode nodeB)
        {
            Stack<int> firstNodeStack = new Stack<int>();
            Stack<int> secondNodeStack = new Stack<int>();

            PushLinkedListIntoStack(nodeA, firstNodeStack);
            PushLinkedListIntoStack(nodeB, secondNodeStack);

            int sum = 0, carry = 0;

            ListNode resultNode = null, lastNode = null;

            while (firstNodeStack.Count != 0 && secondNodeStack.Count != 0)
            {
                sum = firstNodeStack.Pop() + secondNodeStack.Pop() + carry;

                carry = sum / 10;

                sum %= 10;

                //Console.WriteLine("Sum :- " + sum + " Carry :- " + carry);

                if (resultNode == null)
                {
                    resultNode = new ListNode(sum);
                    lastNode = resultNode;
                }
                else
                {
                    lastNode.next = new ListNode(sum);
                    lastNode = lastNode.next;
                }

                //Display(resultNode);
            }

            while (firstNodeStack.Count != 0)
            {
                sum = firstNodeStack.Pop() + carry;

                carry = sum / 10;

                sum %= 10;

                if (resultNode == null)
                {
                    resultNode = new ListNode(sum);
                    lastNode = resultNode;
                }
                else
                {
                    lastNode.next = new ListNode(sum);
                    lastNode = lastNode.next;
                }

            }

            while (secondNodeStack.Count != 0)
            {
                sum = secondNodeStack.Pop() + carry;

                carry = sum / 10;

                sum %= 10;

                if (resultNode == null)
                {
                    resultNode = new ListNode(sum);
                    lastNode = resultNode;
                }
                else
                {
                    lastNode.next = new ListNode(sum);
                    lastNode = lastNode.next;
                }

            }

            if (carry > 0)
            {
                lastNode.next = new ListNode(carry);
                lastNode = lastNode.next;
            }

            //Display(resultNode);

            return ReverseLinkedList(resultNode);
        }