LeetCode-2AddTwoNumbers(C#)

# 题目

2. Add Two Numbers

You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8

# 思路

不知道各位能不能看懂题目，简单解释一下，就是把整数每一位颠倒进行加法。题目中给出的例子，最初对应342 + 465 = 807，然后颠倒变成243 + 564 = 708，在转换为链表。

这下题目给出链表的定义，我们需要对这种类型的链表进行操作。

        // Definition for singly-linked list.
        public class ListNode
        {
            public int val;
            public ListNode next;
            public ListNode(int x) { val = x; }
        }

方法一：普通遍历，链表l1和l2相应位置相加，再加进位，存入链表result中。

注意点:

1. 对于一段长于另外一段的链表部分，单独处理。
2. 进位。
3. 结果之和长于两个链表的情况，如1 + 999 = 1000。

普通遍历，时间复杂度O(n)，空间复杂度O(n)，时间204ms。

        // normal traversal: time O(n) space O(n) result: 204ms
        public void calculateSum(ListNode tresult, ref int carry, int sum)
        {
            )
            {
                carry = ;
                tresult.next = );
            }
            else
            {
                carry = ;
                tresult.next = new ListNode(sum);
            }
        }

        public ListNode AddTwoNumbers(ListNode l1, ListNode l2)
        {
            ListNode tl1 = l1, tl2 = l2;
            ListNode result = );
            ListNode tresult = result;
            ;

            // both ListNode 1 and ListNode 2 have values
            while (tl1 != null && tl2 != null)
            {
                calculateSum(tresult, ref carry, tl1.val + tl2.val + carry);
                tl1 = tl1.next;
                tl2 = tl2.next;
                tresult = tresult.next;
            }

            // Debug.Assert(!(tl1 != null && tl2 != null), "tl1 and tl2 aren't null");
            // either ListNode 1 or ListNode 2 has values (maybe) and don't forget carry.
            while (tl1 != null)
            {
                calculateSum(tresult, ref carry, tl1.val + carry);
                tl1 = tl1.next;
                tresult = tresult.next;
            }
            while (tl2 != null)
            {
                calculateSum(tresult,ref carry, tl2.val + carry);
                tl2 = tl2.next;
                tresult = tresult.next;
            }

            // at this time, ListNode 1 and ListNode 2 should be null, however, carry could be null or not
            // Debug.Assert(tl1 == null && tl2 == null, "calculation doesn't finish");
            ) tresult.next = );

            // neither ListNode 1 nor ListNode 2 have values
            return result.next;
        }
        */

方法二：空间优化遍历，链表l1和l2相应位置相加，再加进位，存入链表l1中。方法二的代码没有方法一的代码清晰。

空间优化遍历，时间复杂度O(n)，空间复杂度O(1)，时间208ms。

        // use ListNode 1 to restore result
        // space (and time, I think, but result doesn't prove) optimized traversal: time O(n) space O(1) result: 208ms
        public ListNode AddTwoNumbers(ListNode l1, ListNode l2)
        {
            if (l1 == null) return l2;
            if (l2 == null) return l1;

            , sum = ;
            ListNode pre = null, result = l1;
            )
            {
                // calculate sum and carry
                sum = ;
                if (l1 != null) sum += l1.val;
                if (l2 != null)
                {
                    sum += l2.val;
                    l2 = l2.next; // ListNode1 will be used below, ListNode2 not, so if ListNode 2 next exists, ListNode 2 move to next
                }
                sum += carry;
                )
                {
                    carry = ;
                    sum -= ;
                }
                else
                {
                    carry = ;
                }

                // find a place for sum in ListNode 1, l1 is in use
                if (l1 != null)
                {
                    pre = l1;
                    ) sum -= ;
                    l1.val = sum;
                    l1 = l1.next;
                }
                else
                {
                    ) sum -= ;
                    pre.next = new ListNode(sum);
                    pre = pre.next;
                }

            }
            return result;
        }
        */

方法三：递归，链表l1和l2相应位置相加，再加进位，存入链表node中。速度最快，是比较好的解决方案。

# 解决（递归）

递归，时间复杂度O(n)，空间复杂度O(n)，时间196ms。

        // recursive tranversal: time O(n) space:O(n) time: 196ms (why it is faster than normal loop)
        public ListNode AddTwoNumbers(ListNode l1, ListNode l2)
        {
            );
        }

        public ListNode AddTwoNumbers(ListNode l1, ListNode l2, int carry)
        {
            ) return null;

            // calculate sum
            ;
            if (l1 != null) sum += l1.val;
            if (l2 != null) sum += l2.val;
            sum += carry;
            )
            {
                carry = ;
                sum -= ;
            }
            else
            {
                carry = ;
            }

            // set node's next and val and return
            ListNode node = new ListNode(sum);
            node.next = AddTwoNumbers(l1 != null ? l1.next : null, l2 != null ? l2.next : null, carry);
            return node;
        }

# 题外话

为何递归会比循环快呢？百思不得其解，若有高人知道，请指教。

# 测试用例

        static void Main(string[] args)
        {
            _2AddTwoNumbers solution = new _2AddTwoNumbers();
            ListNode l1 = );
            ListNode l2 = );
            ListNode result = );

            // ListNode doesn't have a null constructor, so we can igonore this case
            Debug.Assert(Test.match(solution.AddTwoNumbers(l1, l2), result), "wrong 1");

            // ListNode 1 length is larger than ListNode 2 length
            l1 = );
            l1.next = );
            l1.next.next = );
            l2 = );
            result.next = );
            result.next.next = );
            Debug.Assert(Test.match(solution.AddTwoNumbers(l1, l2), result), "wrong 2");

            // ListNode 2 length is larger than ListNode 1 length and has carries
            l1 = );
            l1.next = );
            l2 = );
            l2.next = );
            l2.next.next = );
            result = );
            result.next = );
            result.next.next = );
            result.next.next.next = );
            Debug.Assert(Test.match(solution.AddTwoNumbers(l1, l2), result), "wrong 3");
        }

  class Test
  {

        public static bool match(_2AddTwoNumbers.ListNode l1, _2AddTwoNumbers.ListNode l2)
        {
            _2AddTwoNumbers.ListNode tl1 = l1, tl2 = l2;
            while(tl1 != null && tl2 != null)
            {
                if (tl1.val != tl2.val) return false;
                tl1 = tl1.next;
                tl2 = tl2.next;
            }
            if (tl1 == null && tl2 == null) return true;
            else return false;
        }

  }

# 地址

Q： https://leetcode.com/problems/add-two-numbers/

A： https://github.com/mofadeyunduo/LeetCode/tree/master/2AddTwoNumbers

（希望各位多多支持本人刚刚建立的GitHub和博客，谢谢，有问题可以邮件609092186@qq.com或者留言，我尽快回复）