lintcode 算法-- 221. 链表求和 II

链表求和 II

• 算法要求
• 算法的实现思路
• 算法实现

算法要求

221. 链表求和 II
中文English
假定用链表表示两个数，其中每一个节点仅包含一个数字。假设这两个数的数字顺序排列，请设计一种方法将两个数相加，并将其结果表现为链表的形式。

样例
样例 1:

输入: 6->1->7   2->9->5
输出: 9->1->2
样例 2:

输入: 1->2->3   4->5->6
输出: 5->7->9

算法的实现思路

1.最简单的实现方式，遍历 两个链表，将链表中的数据组合成数值类型，而后相加，以后从新生成链表
问题：可能会超出取值范围
2.遍历链表，将两个链表中的数据遍历到栈中，而后分别从两个栈顶取出数据相加，若是超过10，就进位
问题思考：

• 两个链表为空的状况
• 两个链表长度不一致的状况

算法实现

public class AddLists2 {
    /** * 1.遍历链表1 和链表 2 ，并将其存入到站中stack1 和 stack2 中 * 2.每次弹出栈中的一个元素相加，若是超过10 就进位1 * @param l1 链表1 * @param l2 链表2 * @return */
    public static ListNode addLists2(ListNode l1, ListNode l2) {
        // l1 或者 l2 为空的状况
        if(l1 == null && l2 != null){
            return l2;
        }
        if(l1 != null && l2 == null){
            return l1;
        }
        // TODO 进位的问题
        Stack<Integer> stack1 = new Stack<>();
        Stack<Integer> stack2 = new Stack<>();

        while (l1 != null){
            stack1.push(l1.val);
            l1 = l1.next;
        }
        while (l2 != null){
            stack2.push(l2.val);
            l2 = l2.next;
        }

        // 2.每次从两个栈中弹出元素的值,默认 stack1 中的元素不小于 stack2 中的元素的个数
        int flag = 0;
        Stack<Integer> stack3 = new Stack<>();
        while (!stack1.isEmpty() && !stack2.isEmpty()){
            Integer v1 = stack1.pop();
            Integer v2 = stack2.pop();
            Integer temp = v1 + v2 + flag;
            flag = putstack(stack3, temp);
        }
        // TODO 某一个statck1 或者 stack2 不为空 ，并且此时有进位产生

        // 须要考虑其中某一个stack1 或者 stack2 中长度不一致的问题
        while (!stack1.isEmpty()){
            int temp = stack1.pop() + flag;
            flag = putstack(stack3, temp);
        }
        while (!stack2.isEmpty()){
            int temp = stack2.pop() + flag;
            flag = putstack(stack3, temp);
        }
        if(flag==1){
            stack3.push(flag);
        }
        // 3. 须要将栈中保存的值，从新生成链表
        ListNode root = new ListNode(0);
        ListNode pre = root;
        while(!stack3.isEmpty()){
            ListNode node = new ListNode(stack3.pop());
            pre.next = node;
            pre = node;
        }
        return root.next;
    }

    private static int putstack(Stack<Integer> stack3, int temp) {
        int flag;
        if (temp >= 10) {
            // 获取余数和进位
            temp = temp % 10;
            flag = 1;
        } else {
            flag = 0;
        }
        stack3.push(temp);
        return flag;
    }

    public static void main(String[] args) {
        ListNode node6 = new ListNode(6);
        ListNode node1 = new ListNode(1);
        ListNode node7 = new ListNode(7);

        ListNode node3 = new ListNode(3);
        ListNode node2 = new ListNode(2);
        ListNode node9 = new ListNode(9);
        ListNode node5 = new ListNode(5);

        node6.next = node1;
        node1.next = node7;

        node3.next = node2;
        node2.next = node9;
        node9.next = node5;

        ListNode resutListNode = addLists2(node6, node3);
        while (resutListNode != null){
            System.out.print(resutListNode.val +" -> ");
            resutListNode = resutListNode.next;
        }
        System.out.print("null");
    }
}


public class ListNode {
	public int val;
	public ListNode next;

	public ListNode(int x) {
		val = x;
		next = null;
	}
}