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)