LeetCode 23. Merge k Sorted Lists

最新推荐文章于 2025-05-03 16:06:16 发布

妙BOOK言

最新推荐文章于 2025-05-03 16:06:16 发布

阅读量143

点赞数 1

CC 4.0 BY-SA版权

分类专栏： LeetCode

本文链接：https://blog.youkuaiyun.com/qq_36159989/article/details/82560086

LeetCode 专栏收录该内容

15 篇文章

订阅专栏

本文探讨了如何合并K个已排序的链表，并提供两种解决方案：一种是通过循环逐个比较并选取最小元素；另一种是采用分治策略，逐步减少链表数量，直至只剩下一个链表。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

出处https://leetcode.com/problems/merge-k-sorted-lists/description/

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Example:

Input:
[
　 1->4->5,
　 1->3->4,
　 2->6
]
Output: 1->1->2->3->4->4->5->6

分析

这道题的主要考点是对多个链表进行从大到小排序,用两种方法解决

方法一：直接利用循环，循环的次数等于所有列表内数字数量，每次循环从所有列表中找出最小数字，将其添加在所求列表中，直到所有列表均到达结尾退出循环，得到最终列表。
方法二：利用分治算法的思想，将k个列表排序问题，分解为k/2个列表排序问题，经过多次分解，最终分解为2个列表排序问题，达到简化运算的效果。

最终结果

方法一：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if (lists.size() == 0)
            return NULL;
    if (lists.size() == 1)
        return lists[0];

        int n = 0;
        ListNode *res = new ListNode(0);
        ListNode *list = res;

        while (n < lists.size()) {
            int num = -1;
            for (int i = 0;i < lists.size(); i++) {
                if (lists[i] != NULL && num == -1) {
                    num = i;
                }
                if (lists[i] != NULL && lists[num]->val > lists[i]->val) {
                    num = i;
                }
            }

            if (num != -1) {
                list->next = lists[num];
                list = list->next;
                lists[num] = lists[num]->next;
            }

            if (lists[num] == NULL || num == -1)
                n++;
        }


        return res->next;
    }
};

方法二：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if (lists.size() == 0)
            return NULL;

        return merge(0, lists.size()-1, lists);
    }

    ListNode* merge(int start, int end, vector<ListNode*>& lists) {
        if (start == end) return lists[start];
        if (start > end) return NULL;

        int mid = (start + end) / 2;
        ListNode* left = merge(start, mid, lists);
        ListNode* right = merge(mid+1, end, lists);
        ListNode* res = new ListNode(0);
        ListNode* list = res;

        while (left != NULL && right != NULL) {
            if (left->val > right->val) {
                list->next = right;
                list = list->next;
                right = right->next;
            } else {
                list->next = left;
                list = list->next;
                left = left->next;
            }
        }
        if (left == NULL && right != NULL) {
            list->next = right;
        } else if (left != NULL && right == NULL) {
            list->next = left;
        }

        return res->next;      
    }
};