Вычисление суммы значений в связанном списке

другие ответы, которые я видел, часто полагаются на дополнительный стек. На самом деле это можно решить только с помощью O(1) дополнительное пространство. Я изменил пример в другом ответе, чтобы сделать два списка разными по длине:

list a is: 1->2->3->4
list b is: 5->6->7->8->3->6

мы можем просто перебрать оба списка, хранить значения текущих значений в a и b, в значении нового списка c. Но мы не можем просто взять сумму двух значений как значение в c, потому что в случае, если два списка отличаются в длина, мы не смогли восстановить исходные значения в list a и b. Небольшой трюк заключается в создании двухзначного значения, первая цифра которого является значением в a и второе значение b, например:

list c: 15 <- 26 <- 37 <- 48 <- 3 <- 6
                                     ^ pointer "p1"
                           ^ pointer "p2" here to mark the end of list a

когда-то полностью создан, перематываем с указателя "p1". Сначала мы разделяем два числа в узле по указателю "p2", затем добавляем правильное число к значению в p1. Затем мы переворачиваем p1 и устанавливаем p1->next, и p2 и p2->next, а затем продолжить к предыдущим узлам.

list c: 15 <- 26 <- 37 <- 8 <- 3 -> 4
                               ^ p1
                     ^ p2
                               carry = 1

сложность времени 2*max( length(a), length(b) ).

Привет @rtindru: как вы сказали, что хотите добавить два связанных списка. Первый связанный список a:1->2->3->4 Второй связанный список b:5->6->7->8

в вопросе не упоминается, что цифры, хранящиеся в связанном списке, хранятся в том же порядке или в обратном порядке, что и число. Первый подход сложнее.

Первый Подход:

list a: 1234
list b: 5678

ответ должен быть: 6->9->1->2

   1 2 3 4
+  5 6 7 8
-----------------
   6 9 1 2

Второй Подход

если номер хранится в обратном порядке, то

первый связанный список a:1->2->3->4. Фактическое число:N1=4321. И второй связанный список b:5->6->7->8. Фактическое число:N2=8765. Сумма будет 6->8->0->3->1. Это легкий подход.

в вопросе, который вы задаете для первого подхода, и данный пример также для первого подхода, но ваш исходный код для второго подхода. Пожалуйста соответствуй ему.

вот мой ответ на этот вопрос (используется C# вместо Java, но логика может быть легко воспроизведен на любом языке). Я использовал разворот связанного списка для прямого суммирования, а для обратного хранения я использовал подход переноса вперед.

/*  Program: Given two numbers represented in a linked list in reverse order, sum them and store the result in a third linked list
 *  
 *  Date: 12/25/2015
 */

using System;

namespace CrackingTheCodingInterview
{
    /// <summary>
    /// Singly Linked List with a method to add two numbers stored in two linked lists in reverse order
    /// </summary>
    public partial class SinglyLinkedList
    {
        /// <summary>
        /// Adding two numbers stored in a linked list in reverse order
        /// </summary>
        /// <param name="num1">Linked List 1 storing number 1</param>
        /// <param name="num2">Linked List 2 storing number 2</param>
        /// <param name="result">Linked List 3 storing sum of number 1 and number 2</param>
        public static void SumNumbersReverse(SinglyLinkedList num1, SinglyLinkedList num2, SinglyLinkedList result)
        {
            int carryForward = 0;
            int sum = 0;

            Node num1Digit = num1.head;
            Node num2Digit = num2.head;

            int sum1 = 0;
            int sum2 = 0;

            while (num1Digit != null || num2Digit != null)
            {
                if (num1Digit == null)
                {
                    sum1 = 0;
                }
                else
                {
                    sum1 = (int)num1Digit.Data;
                }

                if (num2Digit == null)
                {
                    sum2 = 0;
                }
                else
                {
                    sum2 = (int)num2Digit.Data;
                }

                sum = sum1 + sum2 + carryForward;

                if (sum > 9)
                {
                    carryForward = 1;
                }
                else
                {
                    carryForward = 0;
                }

                result.Insert(sum % 10);

                if (num1Digit != null)
                {
                    num1Digit = num1Digit.Next;
                }

                if (num2Digit != null)
                {
                    num2Digit = num2Digit.Next;
                }
            }

            result.ReverseList();
        }

        /// <summary>
        /// Adding two numbers stored in a linked list in reverse order
        /// </summary>
        /// <param name="num1">Linked List 1 storing number 1</param>
        /// <param name="num2">Linked List 2 storing number 2</param>
        /// <param name="result">Linked List 3 storing sum of number 1 and number 2</param>
        public static void SumNumbersForward(SinglyLinkedList num1, SinglyLinkedList num2, SinglyLinkedList result)
        {
            num1.ReverseList();
            num2.ReverseList();

            SumNumbersReverse(num1, num2, result);

            result.ReverseList();
        }

        /// <summary>
        /// Reverse a singly linked list
        /// </summary>
        public void ReverseList()
        {
            Node prev = null;
            Node curr = head;
            Node currNext;

            while(curr != null)
            {
                currNext = curr.Next;
                curr.Next = prev;
                prev = curr;
                curr = currNext;
            }

            head = prev;
        }
    }


    internal class SumNumbersLinkedListTest
    {
        static void Main()
        {
            SinglyLinkedList num1 = new SinglyLinkedList();
            SinglyLinkedList num2 = new SinglyLinkedList();

            num1.Insert(6);
            num1.Insert(1);
            num1.Insert(7);

            num2.Insert(2);
            num2.Insert(9);
            num2.Insert(5);

            num1.Print();
            num2.Print();

            SinglyLinkedList resultReverseSum = new SinglyLinkedList();
            SinglyLinkedList resultForwardSum = new SinglyLinkedList();

            SinglyLinkedList.SumNumbersReverse(num1, num2, resultReverseSum);
            Console.WriteLine("After summing reverse: ");
            resultReverseSum.Print();

            SinglyLinkedList num3 = new SinglyLinkedList();
            SinglyLinkedList num4 = new SinglyLinkedList();

            num3.Insert(7);
            num3.Insert(1);
            num3.Insert(6);

            num4.Insert(5);
            num4.Insert(9);
            num4.Insert(2);

            SinglyLinkedList.SumNumbersForward(num3, num4, resultForwardSum);
            Console.WriteLine("After summing forward: ");
            resultForwardSum.Print();

            Console.ReadLine();
        }
    }
}

вы можете сделать это, изменив linkedlists. Это реализация c# и Это O (n).

    public LinkedList ElementSum(LinkedList other)
    {
        LinkedList linkedListSum = new LinkedList();
        this.Reverse();
        other.Reverse();
        Node n1 = this.head, n2 = other.head;
        int toAdd = 0, carryOver = 0;
        while ((n1 != null) || (n2 != null))
        {
            int num1 = (int) (n1 == null ? 0 : n1.NodeContent);
            int num2 = (int) (n2 == null ? 0 : n2.NodeContent);
            toAdd = (num1 + num2 + carryOver) % 10;
            carryOver = (int)(num1 + num2 + carryOver) / 10;
            linkedListSum.Add(toAdd);
            n1 = (n1 == null ? null : n1.Next);
            n2 = (n2 == null ? null : n2.Next);
        }
        this.Reverse();
        other.Reverse();
        linkedListSum.Reverse();
        return linkedListSum;
    }