leetcode 21

最新推荐文章于 2022-01-21 11:22:05 发布

我的代码不是我的代码

最新推荐文章于 2022-01-21 11:22:05 发布

阅读量51

点赞数

分类专栏： leetcode刷题笔记文章标签： leetcode

本文链接：https://blog.csdn.net/CJMINGMING/article/details/119993933

版权

leetcode刷题笔记专栏收录该内容

47 篇文章 0 订阅

订阅专栏

思路一：普通迭代合并

1.将结果合并到l1中，所以采取的是将l2中的元素p一个个插入l1中。
2.利用l2遍历l2链表，设置两个指针p1和p2，p1指向l1中第一个比l2所指元素大的节点，p2为p1前驱。
3.插入时，只需要将p2的后继更新为l2，然而l2的后继更新为p1 ;p2更新为插入的l2，l2指向原先l2的后继。
4.注意初始p1和p2的初始值，p1=l1，而p2=NULL，如果需要在p1和p2之间插入元素l2的话需要特殊处理。让l1=l2(对应于3的p2后继更新)，l2的后继更新为p1，p2更新为插入的l2，l2指向原先l2的后继。
5.总结起来就是，如果l1不空，则设计两个相邻指针p1和p2，p2初始值为NULL(相对于其指向的val为无穷小)，p1初始值为l1，依次遍历完l1，在遍历过程中，如果l2所值元素值恰好夹在p1和p2之间，那么就将其插入到l1中，p1和p2沿着新l1链表继续向下遍历。直到遍历到l1尾部，也就是p1==NULL（相对于p1所指向的val无穷大)，如果此时l2还有元素未插入，则一并将l2剩余的元素插入在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* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(!l1)
        {
            l1=l2;
            return l1;
        }
        ListNode *p1=l1;
        ListNode *p2=NULL;
        if(l2&&p1->val>l2->val)
        {
            ListNode *t=l2->next;
            l2->next=p1;
            l1=l2;
            l2=t;
        }
        p2=l1;
        p1=l1->next;
        while(p1&&l2)
        {
            if(p1->val>l2->val)
            {
                ListNode *t=l2->next;
                p2->next=l2;
                l2->next=p1;
                p2=l2;
                l2=t;    
            }
            else
            {
                p2=p1;
                p1=p1->next;
            }
        }
        if(l2)
        {
            p2->next=l2;
        }
        return l1;
    }
};

思路二：递归

1.l1为l1[0,n1]，l2为l2[0,n2]，merge(l1,l2)为l1和l2合并结果。
2. $merge(l1[i1,j1],l2[i2,j2])=\begin{cases} l1[i1+]merge(l1[i1+1,j1],l2[i2,j2])，l1->val<l2->val\\ l2[i2]+merge(l1[i1,j1],l2[i2+1,j2])，l1->val>=l2->val\\ l2[i2,j2]，l1==NULL\\ l1[i1,j1]，l2==NULL\\ \end{cases}$

/**
 * 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* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1==NULL)
            return l2;
        if(l2==NULL)
            return l1;
        if(l1->val<l2->val)
        {
            l1->next=mergeTwoLists(l1->next,l2);
            return l1;
        }
        else
        {
            l2->next=mergeTwoLists(l1,l2->next);
            return l2;
        }
    }
};

思路三：迭代实现

1.同2，只不过要记录元素头

代码：

/**
 * 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* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *p;
        ListNode *head;
        if(!l1)
        {
            head=l2;
        }
        else if(!l2)
        {
             head=l1;
        }
        else if(l1->val<l2->val)
        {
            head=l1;
            p=l1;
            l1=l1->next;
        }
        else
        {
            head=l2;
            p=l2;
            l2=l2->next;
        }

        while(l1&&l2)
        {
            if(l1->val<l2->val)
            {
                p->next=l1;
                p=p->next;
                l1=l1->next;
            }
            else
            {
                p->next=l2;
                p=p->next;
                l2=l2->next;
            }
        }
        if(p&&!l1)
            p->next=l2;
        if(p&&!l2)
            p->next=l1;
        return head;
    }
};