Leetcode23-Merge k Sorted Lists

原创 2015年07月11日 01:14:41

欢迎参观我的博客Huhaoyu’s Blog

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

分析

合并k个已排序的链表,并分析时间复杂度。k为可大可小的参数,表示需要合并的链表数目。
自定义一个Heap类:

  • vector<ListNode*> heap成员变量作为最小堆。
  • vector<ListNode*> indexHeap记录最小堆内各元素来自于lists中的那个链表。与最小堆heap内的元素一一对应。
  • Heap(vector<ListNode*>& lists);构造Heap对象,抽取lists各链表头部的第一个元素。
  • void push(ListNode*, int);heap中插入一个元素,对应地向indexHeap中插入其链表编号。
  • int pop();删除堆顶元素并调整堆,同时返回删除元素所在的链表编号,下一步可以在该链表中抽取下一个元素。
  • ListNode* front();返回堆顶元素(不删除)。
  • bool empty();返回堆是否为空。
  • adjustUp(int index);将堆中编号为index的元素向上调整。
  • adjustDown(int index);将堆中编号为index的元素向下调整。

时间复杂度:设第i个链表的长度为ni,则时间复杂度为O(sum(ni)*logk)。每从堆中取出一个节点,需要O(logk)调整堆,最坏情况总共需要sum(ni)次调整。

注意

  • lists中某链表已经完全插入到合并链表中时,应避免向堆中插入NULL
  • adjustDown中循环体应注意s != index,否则会进入死循环,详见代码。

AC代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

class Heap {
public:
    Heap(vector<ListNode*>& lists) {
        for (int i = 0; i != lists.size(); ++i) {
            if (lists[i]) {
                push(lists[i], i);
                lists[i] = lists[i]->next;
            }
        }
        // for (int i = heap.size() - 1; i >= 0; --i) {
        //  adjustDown(i);
        // }
    }
    int size() {
        return heap.size();
    }
    bool empty() {
        return heap.empty() && indexHeap.empty();
    }
    void push(ListNode* pointer, int index) {
        heap.push_back(pointer);
        indexHeap.push_back(index);
        adjustUp(heap.size() - 1);
    }
    int pop() {
        int index = indexHeap.front();
        heap.front() = heap.back();
        indexHeap.front() = indexHeap.back();
        heap.pop_back();
        indexHeap.pop_back();
        adjustDown(0);
        return index;
    }
    ListNode* front() {
        return heap.front();
    }
private:
    vector<ListNode*> heap;
    vector<int> indexHeap;
    void adjustDown(int index) {
        if (heap.empty()) {
            return;
        }
        ListNode* save = heap[index];
        int saveIndex = indexHeap[index];
        for (int s = index * 2 + 1; s < heap.size(); s = s * 2 + 1) {
            if (s + 1 < heap.size() && heap[s]->val > heap[s+1]->val) {
                s += 1;
            }
            if (heap[s]->val < save->val) {
                heap[index] = heap[s];
                indexHeap[index] = indexHeap[s];
                index = s;
            } else {
                break;
            }
        }
        heap[index] = save;
        indexHeap[index] = saveIndex;
    }
    void adjustUp(int index) {
        ListNode* save = heap[index];
        int saveIndex = indexHeap[index];
        for (int s = (index - 1) / 2; s >= 0 && s != index; s = (s - 1) / 2) {
            if (heap[s]->val > save->val) {
                heap[index] = heap[s];
                indexHeap[index] = indexHeap[s];
                index = s;
            } else {
                break;
            }
        }
        heap[index] = save;
        indexHeap[index] = saveIndex;
    }
};

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        ListNode* root = NULL, *current;
        Heap heap(lists);
        while (!heap.empty()) {
            if (root) {
                current->next = heap.front();
                current = current->next;
            } else {
                root = current = heap.front();
            }
            int index = heap.pop();
            if (lists[index]) {
                heap.push(lists[index], index);
                lists[index] = lists[index]->next;
            }
        }
        return root;
    }
};

如代码或分析有误,请批评指正,谢谢。

LeetCode Merge k Sorted Lists 解题报告

合并K个已排序的数组,并分析整个算法的复杂度。 最朴素的方法TLE,借鉴归并排序的算法顺利AC,算法时间复杂度:NlogK...
  • worldwindjp
  • worldwindjp
  • 2014年10月11日 15:23
  • 8266

【LeetCode】23. Merge k Sorted Lists 基于Java的解法

23. Merge k Sorted Lists Total Accepted: 88102 Total Submissions: 372066 Difficulty: Hard Merge k...
  • Jin_Kwok
  • Jin_Kwok
  • 2016年06月04日 00:46
  • 1562

LeetCode 23: Merge K Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. ...
  • sunao2002002
  • sunao2002002
  • 2015年05月31日 02:04
  • 3429

[Leetcode]23. Merge k Sorted Lists @python

题目Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity....
  • qian2729
  • qian2729
  • 2016年01月16日 15:32
  • 544

[LeetCode] 023. Merge k Sorted Lists (Hard) (C++/Java/Python)

[LeetCode] 023. Merge k Sorted Lists (Hard) (C++/Java/Python)
  • hcbbt
  • hcbbt
  • 2015年03月05日 11:19
  • 2552

Merge k Sorted Lists -- LeetCode

原题链接: http://oj.leetcode.com/problems/merge-k-sorted-lists/  这道题目在分布式系统中非常常见,来自不同client的sorted list要...
  • linhuanmars
  • linhuanmars
  • 2014年02月25日 09:45
  • 26088

LeetCode 23 Merge k Sorted Lists(合并K个已排序链表)

翻译合并K个已排序的链表,并且将其排序并返回。 分析和描述其复杂性。原文Merge k sorted linked lists and return it as one sorted list. An...
  • NoMasp
  • NoMasp
  • 2015年11月12日 17:30
  • 3383

K链表合并 Merge k Sorted Lists

思想:分布式常见题型。 刚开始的思路:逐一合并,合并的时间复杂度用O(N) ——> TLE ListNode *mergeKLists(vector &lists) { ...
  • yeruby
  • yeruby
  • 2015年04月20日 20:05
  • 2947

LeetCode Merge K Sorted Lists 问题和解答程序 C++ priority queue实现方法

到了现在这种题居然变得这么简单了,实现第二种方法感觉就像势如破竹,一下子通过了。 这种经典的合并程序,基本上可以一口气写出来了,还可以任意变换。以前是不敢想象。 不过这个跟某些网上的所谓达到盲打有点不...
  • kenden23
  • kenden23
  • 2013年10月28日 15:39
  • 2913

leetcode -- Merge k Sorted Lists -- 重点有trick

https://leetcode.com/problems/merge-k-sorted-lists/思路就是把所有的head节点入heap,然后把root,heappop出来。再把被pop出来的no...
  • xyqzki
  • xyqzki
  • 2015年12月11日 16:01
  • 356
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Leetcode23-Merge k Sorted Lists
举报原因:
原因补充:

(最多只允许输入30个字)