Leetcode 445. Add Two Numbers II

本题就是实现两个链表表示的数的加法, 之前考虑的是将链表表示的值都取出来, 然后想加之后再用链表表示出来, 但是感觉这并不是这题考察的本意. 比较麻烦的地方是从链表尾的数字开始相加而不是从链表头.(同时这也是重要特征)  并没有想到啥思路, 就准备看一下大神的思路, 看到了代码中的栈, 联想到之前的麻烦之处, 栈不就是先进后出, 完美满足了要求.

我的思路 

其实也很直接, 将两个链表放到栈中, 依次取出栈中的元素, 相加, 加法要注意的就是进位. 然后将结果放到新栈中, 依次取出新栈中的元素, 形成新链表. 代码 :

import java.util.Stack;
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        Stack<Integer> stack1 = buildStack(l1);
        Stack<Integer> stack2 = buildStack(l2);
        Stack<Integer> stack = new Stack<>();
        int bit = 0;
        ListNode result = new ListNode(0);
        ListNode cur = result;
        
        while(!stack1.isEmpty() && !stack2.isEmpty()) {
            int s1 = stack1.pop();
            int s2 = stack2.pop();
            int add = s1 + s2 + bit;
            if(add >= 10) {
                bit = 1;
                add -= 10;
            } else {
                bit = 0;
            }
            stack.push(add);
        }
        while(!stack1.isEmpty()) {
            // 这里也是没有考虑到进位的情况
            if(bit != 0) {
                int add = stack1.pop() + 1;
                if(add >= 10) {
                    add -= 10;
                    bit = 1;
                } else {
                    bit = 0;
                }
                stack.push(add);
            } else {
                stack.push(stack1.pop());
            }
        }
        while(!stack2.isEmpty()) {
            if(bit != 0) {
                int add = stack2.pop() + 1;
                if(add >= 10) {
                    add -= 10;
                    bit = 1;
                } else {
                    bit = 0;
                }
                stack.push(add);
            } else {
                stack.push(stack2.pop());
            }
        }
        // 这是最后两个栈都为空, 剩下一个进位的情况,所以代码修改了挺多, 都是进位的问题, 最初的考虑不周全
        if(bit != 0) 
            stack.push(1);
        while(!stack.isEmpty()) {
            ListNode node = new ListNode(stack.pop());
            cur.next = node;
            cur = cur.next;
        }
        return result.next;
        
    }
    private Stack<Integer> buildStack(ListNode l) {
        Stack<Integer> stack = new Stack<>();
        while(l != null) {
            stack.push(l.val);
            l = l.next;
        }
        return stack;
    }
}

可以过, 但是太复杂, 将上面的代码改进一下 : 

当 stack1 和 stack2 两者中一个为空的情况时, 操作基本是相同的, 所以这个地方是可以减少的.

import java.util.Stack;
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        Stack<Integer> stack1 = buildStack(l1);
        Stack<Integer> stack2 = buildStack(l2);
        Stack<Integer> stack = new Stack<>();
        int bit = 0;
        ListNode result = new ListNode(0);
        ListNode cur = result;
        
        while(!stack1.isEmpty() && !stack2.isEmpty()) {
            int s1 = stack1.pop();
            int s2 = stack2.pop();
            int add = s1 + s2 + bit;
            if(add >= 10) {
                bit = 1;
                add -= 10;
            } else {
                bit = 0;
            }
            stack.push(add);
        }
        while(!stack1.isEmpty() || !stack2.isEmpty()) {
            Stack<Integer> stack3 = stack1.isEmpty() ? stack2 : stack1;
            if(bit != 0) {
                int add = stack3.pop() + 1;
                if(add >= 10) {
                    add -= 10;
                    bit = 1;
                } else {
                    bit = 0;
                }
                stack.push(add);
            } else {
                stack.push(stack3.pop());
            }
        }
        if(bit != 0) 
            stack.push(1);
        while(!stack.isEmpty()) {
            ListNode node = new ListNode(stack.pop());
            cur.next = node;
            cur = cur.next;
        }
        return result.next;
        
    }
    private Stack<Integer> buildStack(ListNode l) {
        Stack<Integer> stack = new Stack<>();
        while(l != null) {
            stack.push(l.val);
            l = l.next;
        }
        return stack;
    }
}

按照我的逻辑, 没有找到其他的合适删减的地方了.

 

大神的思路

将所有的判断都放在一个 while 中, 同时用头插法, 这样就不需要一个多余的栈来实现结果链表的建立.

import java.util.Stack;
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        Stack<Integer> stack1 = buildStack(l1);
        Stack<Integer> stack2 = buildStack(l2);
        int bit = 0;
        ListNode result = new ListNode(-1);
        ListNode cur = result;
        while(!stack1.isEmpty() || !stack2.isEmpty() || bit != 0) {
            int s1 = stack1.isEmpty() ? 0 : stack1.pop();
            int s2 = stack2.isEmpty() ? 0 : stack2.pop();
            int add = s1 + s2 + bit;
            ListNode node = new ListNode(add % 10);
            node.next = cur.next;
            cur.next = node;
            bit = add / 10;
        }
        return result.next;
    }
    
    private Stack<Integer> buildStack(ListNode l) {
        Stack<Integer> result = new Stack<>();
        while(l != null) {
            result.push(l.val);
            l = l.next;
        }
        return result;
    }
}

 

所有处理数据方向和取得数据方向相反的都可以考虑用栈来处理.

所有进位都考虑用除法和取余来实现, 不要用 if 来处理, 复杂且容易出错.