Leetcode-Merge k Sorted Lists (C,c++,java,python)

Problem:Mergeksorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Solution:using the Winner Tree method, the winner Tree Introduction: Victor Tree, if the list array length is n, the total number of linked list elements is K, then the time complexity of O (K*log (n))
Main topic:given an array of ordered lists (the array elements may be empty), these lists are required to be merged into an ordered list.
Java source Code (522MS):

/** * Definition for singly-linked list. * public class ListNode {* int val; * ListNode Next; * ListNode (int x) {val = x;}}} */public class Soluti    On {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 Language Source code (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 + + source code (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) {Adjust            Winnertree (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 source code (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 I N range (length)] Self.inittree (lists,length) if Lists[self.tree[1]]==none:return None p=lists[self.tr EE[1]] Lists[self.tree[1]]=lists[self.tree[1]].next head=p self.adjusttoroot (lists, (Self.tree[1]+leng TH)/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) re            Turn Head def adjusttoroot (self,lists,tar,length): While Tar>0:self.adjusttree (Lists,tar,length)    Tar=tar/2def inittree (self,lists,length): For I in Range (length-1,0,-1): Self.adjusttree (lists,i,length) def a        Djusttree (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 lis Ts[r]==none:self.tree[i]=l else:self.tree[i]=r If lists[l].val > Lists[r].val else L

Leetcode-Merge k Sorted Lists (C,c++,java,python)