两个正序链表求和

原题：

 

 

拓展：

 

 

思路：

   如何链表是反序的，那么就与我们正常情况下的计算相同了，只需要考虑进位就可以了。

   因此解决方案自然就想到了将两个链表反序存储，并不需要对单链表进行反置操作，只需借助 stack 就可以了。

 

步骤：

    1、创建两个空栈s1和s2，创建结果栈rs。

    2、将链表l1压入栈s1，将l2压入栈s2。

    3、弹出栈s1和s2的元素，进行进位计算，将结果压入栈rs中；注意考虑最后s1和s2为空但是进位不为空的情况。

    4、创建空单链表empty，以单链表empty的next元素为真实开始，放入rs全部弹出元素。

    5、返回empty.next。

 

 代码：

package questions;
 
import java.util.Stack;
 
public class Question2Ext {
    
    public ListNode addTwoNumbers(ListNode l1,ListNode l2) {
        //创建两个栈，并对两个正序链表进行反置
        Stack<Integer> s1 = new Stack();
        Stack<Integer> s2 = new Stack();
        while(l1 != null) {
            s1.push(l1.val);
            l1 = l1.next;
        }
        while(l2 != null) {
            s2.push(l2.val);
            l2 = l2.next;
        }
        //进行反序计算
        //结果栈，稍后还需要反置，创建结果链表
        Stack<Integer> rs = new Stack<>();
        //初始化进位标志
        int carry = 0;
        while(!s1.empty() || !s2.empty()) {
            int x = (s1.peek() != null) ? s1.pop() : 0;
            int y = (s2.peek() != null) ? s2.pop() : 0;
            int sum = x + y + carry;
            carry = sum/10;
            rs.push(sum%10);
        }
        if(carry > 0)
            rs.push(1);
        //设置一个假的头结点，计算完成后返回它的下一个结点
        ListNode emptyHead = new ListNode(0);
        ListNode curr = emptyHead;
        while(!rs.empty()) {
            curr.next = new ListNode(rs.pop());
            curr = curr.next;
        }
        return emptyHead.next;
    }
 
    public static void main(String[] args) {
        ListNode l1 = new ListNode(3);
        l1.next = new ListNode(4);;
        l1.next.next = new ListNode(2);
        ListNode l2 = new ListNode(4);
        l2.next = new ListNode(6);
        l2.next.next = new ListNode(5);
 
        ListNode result = new Question2Ext().addTwoNumbers(l1, l2);
        while(result != null) {
            System.out.print(result.val + "-->");
            result = result.next;
        }
    }
}
 
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) {
        val = x;
    }
}

　　

 

时间复杂度：O(max(m,n))

空间复杂度：O(max(m,n))

原文地址：

https://blog.csdn.net/xiaowei132/article/details/82826633