(LeetCode 热题 100)21. 合并两个有序链表(链表，递归 || 迭代)

岁忧

于 2024-09-16 17:45:55 发布

阅读量215

点赞数 6

分类专栏： LeetCode LeetCode 热题 100 文章标签： leetcode 链表算法 c++ 数据结构递归迭代

本文链接：https://blog.csdn.net/weixin_46028214/article/details/142304408

版权

LeetCode 同时被 2 个专栏收录

456 篇文章 0 订阅

订阅专栏

LeetCode 热题 100

10 篇文章 0 订阅

订阅专栏

题目：21. 合并两个有序链表

在这里插入图片描述

方法一：迭代。比较两个链表的当前元素，主要是链表的操作。时间复杂度0(n+m)，细节看注释。

/**
 * 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* list1, ListNode* list2) {
        ListNode * start= new ListNode();
        ListNode *p=start;
        //当两个链表都不为空的时候才退出循环
        while(list1||list2){
            if(list1==nullptr){
                p->next=list2;
                p=p->next;
                list2=list2->next;
            }else if(list2==nullptr){
                p->next=list1;
                p=p->next;
                list1=list1->next;
            }else if(list1->val<list2->val){
                p->next=list1;
                p=p->next;
                list1=list1->next;
            }else{
                p->next=list2;
                p=p->next;
                list2=list2->next;
            }
        }
        return start->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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode * start= new ListNode();
        ListNode *p=start;
        //两个链表都不为空才进行比较
        while(list1&&list2){
            if(list1->val<list2->val){
                p->next=list1;
                list1=list1->next;
            }else{
                p->next=list2;
                list2=list2->next;
            }
            p=p->next;
        }
        //处理单个链表不为空
        if(list1) p->next=list1;
        else p->next=list2;
        return start->next;
    }
};

方法二：递归。细节看注释，时间复杂度0(n+m)。

/**
 * 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* list1, ListNode* list2) {
    	//list1为空时
        if(list1==nullptr){
            return list2;
        }else if(list2==nullptr){
        	//list2为空时
            return list1;
        }else if(list1->val<list2->val){
        	//list1当前的元素<list2当前的元素
            list1->next=mergeTwoLists(list1->next,list2);
            return list1;
        }else{
             list2->next=mergeTwoLists(list1,list2->next);
             return list2;
        }
    }
};