LeetCode刷题——两数相加 II#445#Medium

两数相加 II的思路探讨与源码
    两数相加 II的题目如下图，该题属于栈类型和数学类型的题目，主要考察对于数学方法的使用和栈结构的理解。本文的题目作者想到2种方法，分别是栈方法和递归方法，其中栈方法使用Java进行编写，而递归方法使用Python进行编写，当然这可能不是最优的解法，还希望各位大佬给出更快的算法。

    本人认为该题目可以使用栈方法的思路进行解决，首先初始化两个双端队列，判断链表1是否不为空，如果是就把元素加入到双端队列1里面。判断链表2是否不为空，如果是就把元素加入到双端队列2里面。初始化下标为0和最终结果的链表为空，开始循环遍历，判断队列1是否为空，如果是就把0赋值给变量，如果不是就把队列1的头部元素弹出并赋值给变量，而对于队列2也是按这个操作进行，计算两个变量和初使值的求和值并除以10得到新的初使下标元素，然后初始化一个链表，链表的元素指定到返回结果，再把初始化链表赋值给返回链表，以此迭代循环，直到遍历结束并返回结果。那么按照这个思路我们的Java代码如下：

#喷火龙与水箭龟
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        Deque<Integer> stack1 = new ArrayDeque<Integer>();
        Deque<Integer> stack2 = new ArrayDeque<Integer>();
        while (l1 != null) {
            stack1.push(l1.val);
            l1 = l1.next;
        }
        while (l2 != null) {
            stack2.push(l2.val);
            l2 = l2.next;
        }
        int ind = 0;
        ListNode res = null;
        while (!stack1.isEmpty() || !stack2.isEmpty() || ind != 0) {
            int left = stack1.isEmpty() ? 0 : stack1.pop();
            int right = stack2.isEmpty() ? 0 : stack2.pop();
            int cur = left + right + ind;
            ind = cur / 10;
            cur %= 10;
            ListNode curnode = new ListNode(cur);
            curnode.next = res;
            res = curnode;
        }
        return res;
    }
}

    显然，我们的栈方法的效果还不错，还可以用递归方法进行解决。首先定义一个迭代计算的方法，在方法内部判断链表的长度，如果链表1长度更大，则对于链表1的下一个元素和链表2进行迭代，迭代的结果加入到链表1的值以后，基于10进行除法运算，得到商和余数的结果并返回，如果链表1的长度大于1，则对于链表1和链表2的下一个元素均进行迭代计算，再次将结果进行基于10的除法运算，并返回结果。定义上述方法以后，开始初始化变量，对链表进行循环和赋值，并调用上述的迭代计算方法进行递归计算，得到最终的结果后进行判断，并返回判断后的结果。所以按照这个思路就可以解决，下面是Python代码：

#喷火龙与水箭龟
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        def helper(node1, node2, len1, len2, carry=0):
            if len1>len2:
                carry = helper(node1.next, node2, len1-1, len2)
                carry, node1.val = divmod(node1.val+carry, 10)
                return carry
            if len1>1:
                carry = helper(node1.next, node2.next, len1-1, len2-1)
            carry, node1.val = divmod(node1.val+node2.val+carry, 10)
            return carry

        len1 = 0
        len2 = 0
        node = l1
        while node:
            node, len1 = node.next, len1+1
        node = l2
        while node:
            node, len2 = node.next, len2+1
        if len1 < len2:
            l1, l2 = l2, l1
            len1, len2 = len2, len1
        carry = helper(l1, l2, len1, len2)
        if carry:
            head = ListNode(carry)
            head.next = l1
            return head
        else:
            return l1

    从结果来说Java版本的栈方法的效率还可以，而Python版本的递归方法的速度比较一般，但应该是有更多的方法可以进一步提速的，希望朋友们能够多多指教，非常感谢。