LeetCode 23 Merge k Sorted Lists (C,C++,Java,Python)

Problem:

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

Solution:

采用胜者树的方法，胜者树介绍：胜者树，假如链表数组长度为n，链表元素总个数为k，那么时间复杂度为O(k*log(n))

题目大意：

给定一个数组有序链表（数组元素可能为空），要求将这些链表合并为一个有序的链表。

Java源代码（522ms）：

/** * Definition for singly-linked list. * public class ListNode { *     int val; *     ListNode next; *     ListNode(int x) { val = x; } * } */public class Solution {    private int[] tree;    public ListNode mergeKLists(ListNode[] lists) {        int len=lists.length;        if(len==0)return null;        else if(len==1)return lists[0];        tree=new int[len];        initTree(lists,len);        if(lists[tree[1]]==null)return null;        ListNode p,head;        p=lists[tree[1]];        lists[tree[1]]=lists[tree[1]].next;        head=p;        adjustToRoot(lists,(tree[1]+len)/2,len);        while(lists[tree[1]]!=null){            p.next=lists[tree[1]];            lists[tree[1]]=lists[tree[1]].next;            p=p.next;            adjustToRoot(lists,(tree[1]+len)/2,len);        }        return head;    }    private void adjustToRoot(ListNode[] lists,int tar,int len){        while(tar>0){            adjustTree(lists,tar,len);            tar=tar/2;        }    }    private void initTree(ListNode[] lists,int len){        for(int i=len-1;i>=1;i--){            adjustTree(lists,i,len);        }    }    private void adjustTree(ListNode[] lists,int i,int len){        int l,r;        if(i+i < len){            l=tree[i+i];        }else{            l=i+i-len;        }        if(i+i+1 < len){            r=tree[i+i+1];        }else{            r=i+i+1-len;        }        if(lists[l]==null)tree[i]=r;        else if(lists[r]==null)tree[i]=l;        else tree[i]= lists[l].val > lists[r].val ? r:l;    }}

C语言源代码（389ms）：

/** * Definition for singly-linked list. * struct ListNode { *     int val; *     struct ListNode *next; * }; */void adjustTree(struct ListNode** lists,int i,int length,int* tree){    int l,r;    if(i*2 < length){        l=tree[i*2];    }else{        l=i*2-length;    }    if(i*2+1 < length){        r=tree[i*2+1];    }else{        r=i*2-length+1;    }if(lists[l]==NULL)tree[i]=r;else if(lists[r]==NULL)tree[i]=l;else tree[i]= lists[l]->val > lists[r]->val ?r:l;}void buildWinnerTree(struct ListNode** lists,int length,int* tree){    int i;    for(i=length-1;i>=1;i--){        adjustTree(lists,i,length,tree);    }}void adjustToRoot(struct ListNode** lists,int tar,int length,int* tree){    while(tar>0){        adjustTree(lists,tar,length,tree);        tar=tar/2;    }}struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) {    struct ListNode *p,*head;    int* tree=(int*)malloc(sizeof(int)*(listsSize));    if(listsSize==0)return NULL;    else if(listsSize==1)return lists[0];    buildWinnerTree(lists,listsSize,tree);if(lists[tree[1]]==NULL)return NULL;p=lists[tree[1]];lists[tree[1]]=lists[tree[1]]->next;head=p;adjustToRoot(lists,(tree[1]+listsSize)/2,listsSize,tree);while(lists[tree[1]]!=NULL){    p->next=lists[tree[1]];    lists[tree[1]]=lists[tree[1]]->next;    p=p->next;    adjustToRoot(lists,(tree[1]+listsSize)/2,listsSize,tree);}    return head;}

C++源代码（419ms）：

/** * 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) {        int len=lists.size();        if(len==0)return NULL;        else if(len==1)return lists[0];        WinnerTree=(int*)malloc(sizeof(int)*len);        initTree(lists,len);        if(lists[WinnerTree[1]]==NULL)return NULL;        ListNode *p,*head;        p=lists[WinnerTree[1]];        lists[WinnerTree[1]]=lists[WinnerTree[1]]->next;        head=p;        adjustToRoot(lists,(WinnerTree[1]+len)/2,len);        while(lists[WinnerTree[1]]!=NULL){            p->next=lists[WinnerTree[1]];            lists[WinnerTree[1]]=lists[WinnerTree[1]]->next;            p=p->next;            adjustToRoot(lists,(WinnerTree[1]+len)/2,len);        }        return head;    }private:    int *WinnerTree;    void initTree(vector<ListNode*>& lists,int len){        for(int i=len-1;i>=1;i--){            adjustWinnerTree(lists,i,len);        }    }    void adjustToRoot(vector<ListNode*>& lists,int tar,int len){        while(tar>0){            adjustWinnerTree(lists,tar,len);            tar=tar/2;        }    }    void adjustWinnerTree(vector<ListNode*>& lists,int i,int len){        int l,r;        if(i+i < len){            l=WinnerTree[i+i];        }else{            l=i+i-len;        }        if(i+i+1 < len){            r=WinnerTree[i+i+1];        }else{            r=i+i+1-len;        }        if(lists[l]==NULL)WinnerTree[i]=r;        else if(lists[r]==NULL)WinnerTree[i]=l;        else WinnerTree[i]= lists[l]->val > lists[r]->val ?r:l;    }};

Python源代码（618ms）：

# Definition for singly-linked list.# class ListNode:#     def __init__(self, x):#         self.val = x#         self.next = Noneclass Solution:    tree=[]    # @param {ListNode[]} lists    # @return {ListNode}    def mergeKLists(self, lists):        length=len(lists)        if length==0:return None        elif length==1:return lists[0]        self.tree=[0 for i in range(length)]        self.initTree(lists,length)        if lists[self.tree[1]]==None:return None        p=lists[self.tree[1]]        lists[self.tree[1]]=lists[self.tree[1]].next        head=p        self.adjustToRoot(lists,(self.tree[1]+length)/2,length)        while lists[self.tree[1]]!=None:            p.next=lists[self.tree[1]]            lists[self.tree[1]]=lists[self.tree[1]].next            p=p.next            self.adjustToRoot(lists,(self.tree[1]+length)/2,length)        return head    def adjustToRoot(self,lists,tar,length):        while tar>0:            self.adjustTree(lists,tar,length)            tar=tar/2    def initTree(self,lists,length):        for i in range(length-1,0,-1):            self.adjustTree(lists,i,length)    def adjustTree(self,lists,i,length):        l=0;r=0        if i+i < length:l=self.tree[i+i]        else:l=i+i-length        if i+i+1 < length:r=self.tree[i+i+1]        else:r=i+i+1-length        if lists[l]==None:self.tree[i]=r        elif lists[r]==None:self.tree[i]=l        else:self.tree[i]=r if lists[l].val > lists[r].val else l