Leetcode：445.两数相加Ⅱ

最新推荐文章于 2025-12-20 20:19:18 发布

原创最新推荐文章于 2025-12-20 20:19:18 发布 · 187 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #堆栈 #leetcode #数据结构 #manjaro

数据结构刷题同时被 2 个专栏收录

26 篇文章

订阅专栏

Leetcode

12 篇文章

订阅专栏

本文详细解析了LeetCode上第445题“两数相加Ⅱ”的解题思路，介绍了如何使用两个堆栈处理链表数值相加的问题，并考虑了各种特殊情况，如进位处理等。最后通过链表反转得到最终答案。

Leetcode：445.两数相加Ⅱ

题目描述

给定两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储单个数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

进阶:

如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。

示例:

输入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
输出: 7 -> 8 -> 0 -> 7

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：
这道题其实不难，在最后处理的时候要考虑一些特殊情况。思路还是比较清晰，用两个堆栈将链表的数值放入，然后分别pop相加形成一个新的节点（考虑进位），这样将会得到一个新的链表，然后反转即可。
主要麻烦的地方在这两个堆栈其中一个已经为空但另一个还没有pop完，这时我们要把剩下的元素放到链表尾端并考虑进位。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 #include<stack>
class Solution {
public:
	//链表反转函数，见Leetcode.206
    ListNode* reverse(ListNode *head){
        ListNode *pre = NULL, *first = head, *last = first->next;
        while(last){
            first->next = pre;
            pre = first; 
            first = last;
            last = last->next;
        }
        first->next = pre;
        return first;
    }
	
	//原函数
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *dummy = new ListNode(-1);
        ListNode *p1 = l1, *p2 = l2, *head, *p = dummy; //用哑结点表示新链表的开头
        stack<int> s1, s2;
        int carry = 0, value, num1, num2; //carry为进位数
        
        //链表元素全部入栈
        while(p1) {s1.push(p1->val); p1 = p1->next;}
        while(p2) {s2.push(p2->val); p2 = p2->next;}
		
		//两数相加，形成新节点放到链表尾端
        while(!s1.empty() && !s2.empty()){
            num1 = s1.top(); s1.pop();
            num2 = s2.top(); s2.pop();

            if(num1+num2+carry >= 10)
                {value = num1+num2+carry-10; carry = 1;}
            else {value = num1+num2+carry; carry = 0;}
            
            p->next = new ListNode(value);
            p = p->next;
        }
		
		//s1中还有元素
        if(!s1.empty()){
            while(!s1.empty()){
            	//考虑进位
                if(s1.top()+carry >= 10) {p->next = new ListNode(s1.top()+carry-10); s1.pop(); p = p->next; carry = 1;}
                else {p->next = new ListNode(s1.top()+carry); s1.pop(); p = p->next; carry = 0;}
            }
        }
        
		//s2中还有元素
        if(!s2.empty()){
            while(!s2.empty()){
            	//考虑进位
                if(s2.top()+carry >= 10) {p->next = new ListNode(s2.top()+carry-10); s2.pop(); p = p->next; carry = 1;}
                else {p->next = new ListNode(s2.top()+carry); s2.pop(); p = p->next; carry = 0;}
            }
        }
        //两个同时为空并且考虑进位
        if(s1.empty()&&s2.empty()&&carry == 1) {p->next = new ListNode(1);}
		
		//释放哑结点
        head = dummy->next; dummy->next = NULL;
        
        return reverse(head);
    }
};