23. Merge k Sorted Lists 合并k个链表

最新推荐文章于 2024-09-18 18:16:42 发布

孤独的根号13

最新推荐文章于 2024-09-18 18:16:42 发布

阅读量342

点赞数

分类专栏： leetcode c++ 文章标签： list divide and conquer

本文链接：https://blog.csdn.net/u010005161/article/details/52435309

版权

leetcode 同时被 2 个专栏收录

146 篇文章 0 订阅

订阅专栏

c++

113 篇文章 0 订阅

订阅专栏

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

1.我的思路超时了

开辟一个n个的指针空间，用来存放每一个链表的当前运行到的节点，然后依次连入到root上

//
//  main.cpp
//  23. Merge k Sorted Lists
//
//  Created by zjl on 16/9/4.
//  Copyright © 2016年 zjl. All rights reserved.
//

#include <iostream>
#include <vector>
using namespace std;


struct ListNode {
        int val;
        ListNode *next;
        ListNode(int x) : val(x), next(NULL) {}
    };

vector<ListNode*> init(vector<vector<int>> num){
    
    vector<ListNode*>res;
    for(int i = 0; i < num.size(); i++){
        ListNode* root = new ListNode(0);
        ListNode* p = root;
        if(num[i].size() == 0){
            res.push_back(NULL);
        }else{
            for(int j = 0; j < num[i].size(); j++){
                ListNode* t = new ListNode(num[i][j]);
                p->next = t;
                p = p->next;
            }
            res.push_back(root->next);
        }
    }
    return res;
}


ListNode* mergeKLists(vector<ListNode*>& lists) {
    int n = lists.size();
    if(n == 0 || (lists.size() == 1 && lists[0] == NULL)) return NULL;
    ListNode* root = new ListNode(INT_MAX);
    ListNode* p = root;
    if(lists.size() == 1) return lists[0];
    vector<ListNode*>ptr;
    for(int i = 0; i < n; i++){
        if(lists[i] == NULL)
            ptr.push_back(NULL);
        else
            ptr.push_back(lists[i]);
    }
    while(p != NULL){
        ListNode* minn = new ListNode(INT_MAX);
        int pos = -1;
        for(int i = 0; i < n; i++){
            if(ptr[i] == NULL) continue;
            /*ListNode* t = ptr[i];
            if(p->val == t->val){
                ptr[i] = t->next;
                continue;
            }*/
            if(minn->val > ptr[i]->val){
                minn = ptr[i];
                pos = i;
            }
        }
        if(minn->val == INT_MAX){
            p->next = NULL;
            break;
        }else{
            p->next = minn;
            p = p->next;
            ptr[pos] = minn->next;
        }
    }
    return root->next;
}


int main(int argc, const char * argv[]) {
    // insert code here...
    vector<vector<int>>num={{1,1,2},{0,1,2,2}};
    vector<ListNode*>lists = init(num);
    ListNode* root = mergeKLists(lists);
    while(root != NULL){
        cout<<root->val<<" ";
        root = root->next;
    }
    return 0;
}

2. 别人的想法

两两合并，然后长度缩短一半....最后只剩下一个长度，即输出

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergelist(ListNode* l1, ListNode* l2){
        if(l1 == NULL)
            return l2;
        if(l2 == NULL)
            return l1;
        if(l1->val < l2->val){
            l1->next = mergelist(l1->next, l2);
            return l1;
        }else{
            l2->next = mergelist(l1, l2->next);
            return l2;
        }
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int n = lists.size();
        if(n == 0) return NULL;
        while(n > 1){
            for(int i = 0; i < n/2; i++){
                lists[i] = mergelist(lists[i], lists[n-1-i]);
            }
            n = (n+1) / 2;
        }
        return lists[0];
    }
};