[LeetCode]两数相加

news2024/10/6 22:32:51

解题思路1 :
先将每个链表的节点数求出来,将短的链表的每个节点的值加到长链表对应的节点上,在判断加上之后的值是否大于10,若大于则该节点减10,下一个节点加1,由此循环之后,只有长链表的最后一个节点的数可能大于10,则对最后一个节点进行判断,如果大于10,则new一个新的节点,将该节点值对10求商的值传入,该节点的值变为对10求余的数

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        // 拿到两个链表各自的长度
        ListNode* head1 = l1;
        int n1 = 0, n2 = 0; // 节点个数
        while (head1 != nullptr) {
            n1++; // 个数
            head1 = head1->next;
        }
        head1 = l2;
        while (head1 != nullptr) {
            n2++; // 个数
            head1 = head1->next;
        }
        ListNode* h_max = n1 >= n2 ? l1 : l2; // 拿到较长链表
        ListNode* h_min = n1 < n2 ? l1 : l2;  // 拿到较短链表

        // 将短链表每个节点的值加到长链表节点
        while (h_min != nullptr) {
            h_max->val += h_min->val;
            h_min = h_min->next;
            h_max = h_max->next;
        }
        
        h_max = n1 >= n2 ? l1 : l2; // 头节点置初始位置

        // 求最终的长链表
        ListNode* cur = h_max; // 存一份h_max
        while (h_max != nullptr) {
            // 若当前节点的值大于等于10
            if (h_max->val >= 10) {
                if (h_max->next == nullptr) {
                    h_max->next = new ListNode(h_max->val / 10);
                } else {
                    h_max->next->val += h_max->val / 10;
                }
                h_max->val %= 10;
            }
            h_max = h_max->next;
        }

        return cur;
    }
};

解题思路 2:

递归法 :
- 递归终止条件为l1,l2都为空,如果进位carry的值不等于0,则会创建一个新的节点保存这个进位,否则返回值为空
- 如果l1为空,则l2一定不会为空,如果为空,则在递归终止条件处就终止返回了,然后如果l1==nullptr,则会交换l1,l2的值,保证l1是一个长的链表,
- 在将l1,l2节点的值和进位carrry相加,在该节点保存的值为carry%10,然后继续递归,传进去的carry为carry/10
- 最后返回l1链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2,int carry = 0) {
        // int carry = 0;//进位
        if(l1 == nullptr && l2 == nullptr)
            return carry ?new ListNode(carry) : nullptr;

        if(l1 == nullptr) //如果l1为空 则l2一定不会为空
            swap(l1,l2);//交换l1,l2,保证l1非空

        carry +=l1->val +(l2 ?l2->val:0);//节点值和进位值加在一起

        l1->val = carry %10;//每个节点保存一个位数

        l1->next = addTwoNumbers(l1->next,(l2?l2->next:nullptr),carry/10);

        return l1;
    }
};

解题思路3 :

迭代
大致思路是创建一个新的链表,建立哨兵节点,用于开始指向下一个节点,将这两个链表每个节点的值和进位值相加经求余后得到该节点应该存放的值,如果l1,l2 或者carry有一个不为零,则一直循环,最后输出dummy->next

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {

        //迭代
        auto dummy = new ListNode();//创建一个空链表

        auto cur = dummy;
        int carry = 0 ;//保存进位

        while(l1 || l2 || carry){
            carry +=(l1?l1->val:0)+(l2?l2->val:0);
            cur ->next = new ListNode(carry %10);//每个节点保存一位数
            cur = cur -> next;
            carry /=10;//新的进位

            //下一个节点
            if(l1) l1 = l1 ->next;
            if(l2) l2 = l2 ->next;
        }
        //哨兵节点的下一个节点就是头节点
        return dummy->next;
    }
};