17_leetcode_merge k Sorted List

最新推荐文章于 2026-01-05 22:36:07 发布

原创最新推荐文章于 2026-01-05 22:36:07 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #编程语言 #面试

编程同时被 3 个专栏收录

155 篇文章

订阅专栏

leetcode

155 篇文章

订阅专栏

算法

155 篇文章

订阅专栏

本文介绍了一种通过归并排序方法来合并多个有序链表的算法实现，并详细阐述了其实现过程及其复杂度分析。

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

1:当链表数组为NULL或者只有一个链表的情况，直接返回；2:采用归并的方法合并链表数组中的链表；3:注意NULL链表的情况；4:在合并过程中，当一个链表较长的时候，处理较长的部分。

    ListNode* mergeKLists(vector<ListNode* > &lists)
    {
        if(lists.size() == 0)
            return NULL;
        if(lists.size() == 1)
            return lists[0];
        
        int size = (int)lists.size();
        
        return mergeKListsCore(lists, 0, size - 1);
    }
    
    ListNode* mergeKListsCore(vector<ListNode* > &lists, int start, int end)
    {
        if(start == end)
        {
            return lists[start];
        }
        
        int middle = (start + end) / 2;
        
        ListNode* leftList = mergeKListsCore(lists, start, middle);
        ListNode* rightList = mergeKListsCore(lists, middle + 1, end);
        
        if(leftList == NULL)
            return rightList;
        if(rightList == NULL)
            return leftList;
        
        ListNode* head = NULL;
        ListNode* index = NULL;
        
        ListNode* indexA = leftList;
        ListNode* indexB = rightList;
        
        while(indexA && indexB)
        {
            if(indexA->val < indexB->val)
            {
                if(head == NULL)
                {
                    head = indexA;
                    index = head;
                }
                else
                {
                    index->next = indexA;
                    index = index->next;
                }
                indexA = indexA->next;
            }
            else
            {
                if(head == NULL)
                {
                    head = indexB;
                    index = head;
                }
                else
                {
                    index->next = indexB;
                    index = index->next;
                }
                indexB = indexB->next;
            }
        }
        
        index->next = (indexA == NULL ? indexB : indexA);
        
        return head;
    }