LeetCode题解(Week 3):445. Add Two Numbers II_leetcode 445 c++-优快云博客

原题目

You are given two non-empty linked lists representing two non-negative
integers. The most significant digit comes first and each of their
nodes contain a single digit. Add the two numbers and return it as a
linked list.

You may assume the two numbers do not contain any leading zero, except
the number 0 itself.

Follow up: What if you cannot modify the input lists? In other words,
reversing the lists is not allowed.

Example: Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4) Output: 7 -> 8 -> 0
-> 7

中文大意

给定两个非空链表，其中链表头部元素代表最高位，尾部代表最低位，计算出这两个链表作为两个十进制数相加的结果，如 (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4) = (7 -> 8 -> 0 -> 7)，另外，这道题能否通过不改变输入链表的结构（不将链表逆置）得到？

题解1：通过链表逆置实现

class Solution {
public:
    ListNode* reverseList(ListNode* head) 
    {
        if(head==NULL) return head;
        ListNode *tail = head;
        while(tail->next!=NULL)
            tail = tail->next;
        ListNode* curr = head;
        while(curr!=tail)
        {
            ListNode* currNext = curr->next;
            curr->next = tail->next;
            tail->next = curr;
            curr = currNext;
        }
        return tail;
    }

    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) 
    {
        ListNode* dummy = new ListNode(-1);  //创建结果的链表头部

        // 先将链表逆置
        ListNode* l1_reverse = reverseList(l1);
        ListNode* l2_reverse = reverseList(l2);

        int carry = 0; //处理进位
        while(l1_reverse!=NULL || l2_reverse!=NULL)
        {
            //处理两个链表不等长，遍历完其中的一个链表的情况
            if(l1_reverse==NULL)
            {
                ListNode* newNode = new ListNode((l2_reverse->val + carry)%10);
                carry = (l2_reverse->val + carry)/10;
                newNode->next = dummy->next;
                dummy->next = newNode;
                l2_reverse = l2_reverse->next;
            }
            else if(l2_reverse ==NULL)
            {
                ListNode* newNode = new ListNode((l1_reverse->val + carry)%10);
                carry = (l1_reverse->val + carry)/10;
                newNode->next = dummy->next;
                dummy->next = newNode;
                l1_reverse = l1_reverse->next;               
            }
            //常规情况
            else
            {
                ListNode* newNode = new ListNode((l1_reverse->val+ l2_reverse->val + carry)%10);
                carry = (l1_reverse->val+ l2_reverse->val + carry)/10;
                newNode->next = dummy->next;
                dummy->next = newNode;
                l1_reverse = l1_reverse->next;
                l2_reverse = l2_reverse->next;
            }
        }
        if(carry)  //如果最高位相加的结果还产生进位，这里需要加上
        {
            ListNode* newNode = new ListNode(carry);
            newNode->next = dummy->next;
            dummy->next = newNode;
        }
        return dummy->next;
    }
};

题解1分析

这道题实际上就是模拟两个数的竖式计算，关键是对链表的遍历以及对进位的处理，进位需要用一个额外的变量来存储，等于上一次进位加上当前位的两个加数除10取整。每一位相加的结果都要插入到新的链表的头部，从而避免最后还要对链表进行逆置

题解2：通过栈的实现

class Solution {
public:

    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        stack<int> s1,s2;
        //将两个链表中的数分别压到两个栈中
        while(l1!=NULL){
            s1.push(l1->val);
            l1 = l1->next;
        }
        while(l2!=NULL){
            s2.push(l2->val);
            l2 = l2->next;
        }
        ListNode *dummy = new ListNode(-1);
        int carry = 0;
        while(!s1.empty()||!s2.empty()){
            int sum = carry;
            if(!s1.empty()) {
                sum += s1.top();
                s1.pop();
            }
            if(!s2.empty())
            {
                sum += s2.top();
                s2.pop();
            }
            ListNode *newDigit = new ListNode(sum%10);
            carry = sum/10;
            //从头插入
            newDigit->next = dummy->next;
            dummy->next=newDigit;
        }
        if(carry)
        {
            ListNode *newDigit = new ListNode(carry);
            newDigit->next = dummy->next;
            dummy->next = newDigit;
        }
        return dummy->next;
    }
};