예제 #1
0
 ListNode* mergeKLists(vector<ListNode*>& lists, int low, int high) {
     if(high > low) {
         return mergeTwoLists(mergeKLists(lists, low, (low+high)/2), mergeKLists(lists, (low+high)/2+1, high));
     } else {
         return lists[low];
     }
 }
예제 #2
0
 ListNode *mergeKLists(vector<ListNode *> &lists, int begin, int end) {
     if(begin > end)
         return NULL;
     if(begin == end)
         return lists[begin];
     return mergeTwoLists(mergeKLists(lists, begin, (begin + end) / 2), mergeKLists(lists, (begin + end) / 2 + 1, end));
 }
예제 #3
0
struct ListNode *mergeKLists(struct ListNode **lists, int listsSize)
{
	int	mid;
	struct ListNode *newhead, **headpp;
	struct ListNode *left, *right;

	if (!listsSize)
		return(0);
	if (listsSize == 1)
		return(lists[0]);
	mid = listsSize / 2;

	left = mergeKLists(lists, mid);
	right = mergeKLists(lists + mid, listsSize - mid);

	newhead = 0;
	headpp = &newhead;
	while (left && right) {
		if (left->val < right->val) {
			*headpp = left;
			left = left->next;
			headpp = &(*headpp)->next;
		} else {
			*headpp = right;
			right = right->next;
			headpp = &(*headpp)->next;
		}
	}
	if (left)
		*headpp = left;
	if (right)
		*headpp = right;
	return(newhead);
}
예제 #4
0
 ListNode* mergeKLists(vector<ListNode*>& lists) {
     if (lists.size()==0) return NULL;
     if (lists.size()==1) return lists[0];
     if (lists.size()==2) return merge2Lists(lists[0],lists[1]);
     vector<ListNode*> vec1(lists.begin(),lists.begin()+lists.size()/2);
     vector<ListNode*> vec2(lists.begin()+lists.size()/2,lists.end());
     return merge2Lists(mergeKLists(vec1),mergeKLists(vec2));
     
 }
    ListNode * mergeKLists (vector<ListNode *> & lists, int start, int end) {

        if (start == end) return lists[start];
        if (start + 1 == end) return merge(lists[start], lists[end]);

        int mid = (start + end) / 2;

        return merge(mergeKLists(lists, start, mid), mergeKLists(lists, mid + 1, end));
    }
예제 #6
0
 ListNode* mergeKLists(vector<ListNode*>& lists, int start, int end) {
     if (start == end) {
         return lists[start];
     }
     
     int mid = (start + end) / 2;
     
     ListNode* left = mergeKLists(lists, start, mid);
     ListNode* right = mergeKLists(lists, mid+1, end);
     
     return mergeTwoLists(left, right);
 }
 ListNode* mergeKLists(vector<ListNode*>& lists) {
     if (lists.size() == 0) return NULL;
     if (lists.size() == 1) return lists[0];
     if (lists.size() == 2) return merge(lists[0], lists[1]);
     vector<ListNode*> left, right;
     left.insert(left.end(), lists.begin(), lists.begin() + lists.size()/2);
     right.insert(right.end(), lists.begin() + lists.size()/2, lists.end());
     ListNode *newleft = mergeKLists(left);
     ListNode *newright = mergeKLists(right);
     ListNode* mylist = merge(newleft, newright);
     return mylist;
 }//end margekLists
예제 #8
0
 ListNode *mergeKLists(vector<ListNode *> &lists, int lo, int hi) {
     if(lo > hi) {
         return NULL;
     }
     if(lo == hi) {
         return lists[lo];
     }
     
     int mid = (lo+hi)/2;
     ListNode *left = mergeKLists(lists, lo, mid);
     ListNode *right = mergeKLists(lists, mid+1, hi);
     return merge(left, right);
 }
	ListNode* mergeKLists(vector<ListNode*>& lists) {
		if (lists.empty())
			return NULL;
		if (lists.size() == 1)
			return lists[0];
		if (lists.size() == 2)
			return merge(lists[0], lists[1]);
		vector<ListNode*>part1(lists.begin(), lists.begin() + lists.size() / 2);
		vector<ListNode*>part2(lists.begin() + lists.size() / 2, lists.end());
		ListNode* l1 = mergeKLists(part1);
		ListNode* l2 = mergeKLists(part2);
		return merge(l1, l2);
	}
// -----------------------------------------------------------------------------
//virtual
bool Solution::Test()
{
    bool pass = true;

    {
        int a1[] = { -1, 1 };
        int a2[] = { -3, 1, 4 };

        ListNode * l1 = createList(a1, sizeof(a1) / sizeof(int));
        ListNode * l2 = createList(a2, sizeof(a2) / sizeof(int));

        std::vector<ListNode *> lists;
        lists.push_back(l1);
        lists.push_back(l2);

        ListNode * result = mergeKLists(lists);

        std::vector<int> vec = transform(result);

        pass = pass && ((vec[0] == -3) && (vec[1] == -1) && (vec[2] == 1)
            && (vec[3] == 1) && (vec[4] == 4)
        );
    }

    {
        int a1[] = { -1, 1 };
        int a2[] = { -3, 1, 4 };
        int a3[] = { -2, -1, 0, 2 };

        ListNode * l1 = createList(a1, sizeof(a1) / sizeof(int));
        ListNode * l2 = createList(a2, sizeof(a2) / sizeof(int));
        ListNode * l3 = createList(a3, sizeof(a3) / sizeof(int));

        std::vector<ListNode *> lists;
        lists.push_back(l1);
        lists.push_back(l2);
        lists.push_back(l3);

        ListNode * result = mergeKLists(lists);

        std::vector<int> vec = transform(result);

        pass = pass && ((vec[0] == -3) && (vec[1] == -2) && (vec[2] == -1)
            && (vec[3] == -1) && (vec[4] == 0) && (vec[5] == 1)
            && (vec[6] == 1) && (vec[7] == 2) && (vec[8] == 4)
        );
    }

    return pass;
}
예제 #11
0
파일: 023.cpp 프로젝트: dg8fv2010/LeetCode
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if (lists.size()==0) return NULL;
        if (lists.size()==1) return lists[0];

        int size=lists.size();
        int mid=(size)/2;
        vector<ListNode*> l11 = vector<ListNode*>(lists.begin(), lists.begin()+mid);
        ListNode* l1=mergeKLists(l11);
        vector<ListNode*> l22 = vector<ListNode*>(lists.begin()+mid, lists.end());
        ListNode* l2=mergeKLists(l22);

        ListNode* ret = merge2List(l1, l2);
        return ret;
    }
예제 #12
0
struct ListNode *mergeKLists(struct ListNode **lists, int listsSize) {
    if (listsSize == 0 || lists == NULL) {
        return NULL;
    }
    if (listsSize == 1) {
        return lists[0];
    }
    if (listsSize == 2) {
        return mergeTwoLists(lists[0], lists[1]);
    }
    struct ListNode *a = mergeKLists(lists, listsSize / 2);
    struct ListNode *b = mergeKLists(lists + listsSize / 2, listsSize - listsSize / 2);
    return mergeTwoLists(a, b);
}
예제 #13
0
int main() {
    struct ListNode** lists = NULL;
    int listsSize = 2;
    int i = 0;
    int len = 2;
    int a0[] = {1, 3};
    int *a1 = NULL;
    int **a;
    int count[] = {0, 2};
    struct ListNode * answer = NULL;
    a = (int **) malloc(sizeof(int *) * len);
    *(a + 0) = a1;
    *(a + 1) = a0;
    lists = (struct ListNode **) malloc(sizeof(struct ListNode *) * listsSize);
    for (i = 0; i < listsSize; i ++) {
        *(lists + i) = convert_int_to_ListNode(*(a + i), count[i]);
    }
    
    answer = mergeKLists(lists, listsSize);
    
    print_ListNode(answer);

    free_ListNode(answer);

    free(a);
    for (i = 0; i < listsSize; i ++) {
        free(*(lists + i));
    }
    free(lists);
    
    printf("end\r\n");
    
    return 0;
}
예제 #14
0
파일: 23.cpp 프로젝트: neoliang/leetcode
 ListNode *mergeKLists(vector<ListNode *> &lists) {
     if(lists.empty())
     {
         return NULL;
     }
     return mergeKLists(lists,0,lists.size()-1);
 }
예제 #15
0
파일: 23.cpp 프로젝트: neoliang/leetcode
 ListNode *mergeKLists(vector<ListNode *> &lists,unsigned int s,unsigned int e) {
     if(s == e)
     {
         return lists[s];
     }
     if(s + 1 == e)
     {
         return mergeTwoLists(lists[s],lists[e]);
     }
     else
     {
         ListNode* left = mergeKLists(lists,s,s + (e - s)/2);
         ListNode* right = mergeKLists(lists,s + (e - s)/2 + 1,e);
         return mergeTwoLists(left,right);
     }
 }
예제 #16
0
 //Divide and conquer, less time is needed but still needs to be optimized 
 ListNode* mergeKLists(vector<ListNode*>& lists) {
     int n=lists.size();
     if(n==0)
         return NULL;
     else if(n==1)
         return lists[0];
     int i=0;
     int mid=(n-1)/2;
     vector<ListNode*> l;
     vector<ListNode*> r;
     for(;i<mid+1;i++)
         l.push_back(lists[i]);
     for(;i<n;i++)
         r.push_back(lists[i]);
     ListNode* left=mergeKLists(l);
     ListNode* right=mergeKLists(r);
     return mergeTwoLists(left,right);
 }
예제 #17
0
int main(){
    int x[] = {1,3,5};
    int y[] = {2,4,6};
    ListNode *x1 = getList(x[],sizeof(x)/sizeof(x[0]));
    ListNode *x2 = getList(y[],sizeof(y)/sizeof(y[0]));
    vector<ListNode*> lists;
    lists.push_back(x1);
    lists.push_back(x2);
    ListNode* result = mergeKLists(lists);
    print(result);
}
예제 #18
0
 ListNode *mergeKLists(vector<ListNode *> &lists) {
     int k = (int) lists.size();
     if (k == 0){
         return NULL;
     }
     ListNode **minEle = min_element(&lists[0], &lists[k], comp);
     if (*minEle == NULL){
         return NULL;
     }
     ListNode *head = postNext(*minEle);
     head->next = mergeKLists(lists);
     return head;
 }
예제 #19
0
bool testMergeKLists() {
    int a[][4] = {
        {0, 1, 4, 7},
        {2, 3, 4, 8},
        {1, 4, 7, 9}
    };
    int n = COUNT_OF(a);
    struct ListNode **lists = malloc(sizeof(struct ListNode *) * n);
    int i;
    for (i = 0; i != n; i++) {
        lists[i] = buildLst(a[i], COUNT_OF(a[i]));
    }
    struct ListNode *r = mergeKLists(lists, n);
    showLst(r);
    return true;
}
예제 #20
0
    ListNode *mergeKLists(vector<ListNode *> &lists) {
        if(lists.size()==0) return NULL;
        if(lists.size()>=2)
        {
            vector<ListNode *> temp;
            for(int i=0;i<lists.size()/2;i++)
                temp.push_back(mergeTwoLists(lists[2*i],lists[2*i+1]));

            if(lists.size()%2==1)
                temp.push_back(lists.back());

            lists = temp;
            mergeKLists(lists);
        }

        return lists[0];
    }
예제 #21
0
파일: 023.c 프로젝트: hilings/leetcode
int main(int arg, char *argv[]) {
    // insert code here...
    printf("LeetCode 023 Merge k Sorted Lists, C ...\n");
    
    struct ListNode *a1 = 0;//(struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode *a2 = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode *a3 = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode *b1 = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode *b2 = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode *b3 = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode *c1 = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode *c2 = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode *c3 = (struct ListNode*)malloc(sizeof(struct ListNode));
    //a1->val = 1;
    a2->val = 4;
    a3->val = 7;
    b1->val = 2;
    b2->val = 5;
    b3->val = 8;
    c1->val = 3;
    c2->val = 6;
    c3->val = 9;
    //a1->next = a2;
    a2->next = a3;
    b1->next = b2;
    b2->next = b3;
    c1->next = c2;
    c2->next = c3;
    
    //printList(a1);
    //printList(mergeTwoLists(a1, b1));
    
    int n = 3;
    struct ListNode **lists = (struct ListNode**)malloc(sizeof(struct ListNode*) * n);
    lists[0] = a1;
    lists[1] = b1;
    lists[2] = c1;
    printVector(lists, n);
    mergeKLists(lists, n);
    
    
    return 0;
}
예제 #22
0
 ListNode* mergeKLists(vector<ListNode*>& lists) {
     if(lists.size() == 0) {
         return NULL;
     }
     if(lists.size() == 1) {
         return lists[0];
     }
     vector<ListNode*> res;
     
     for(int i=0; i<lists.size(); i+=2) {
         if(i+1< lists.size()) {
             res.push_back(merge(lists[i], lists[i+1]));    
         }
         else {
             res.push_back(lists[i]);
         }
     }
     
     return mergeKLists(res);
 }
예제 #23
0
파일: 23.c 프로젝트: unasm/utils
int main(int argc, const char *argv[])
{
	struct ListNode *arr[2], *p, *p1;	
	//p = arr[0];
	/*
	p1 = (struct ListNode * )malloc(sizeof(struct ListNode));
	p1->val = 232;
	p1->next = NULL;
	arr[0] = p1;

	p1 = (struct ListNode * )malloc(sizeof(struct ListNode));
	p1->val = 39;
	p1->next = NULL;

	arr[1] = p1;
	p1 = (struct ListNode * )malloc(sizeof(struct ListNode));
	p1->val = 239;
	p1->next = NULL;

	arr[1]->next = p1;
	*/
	/*
	for(int i = 0;i < 2;i++) {
		p = arr[i];
		printf("\n");
		while(p != NULL) {
			//printf("sdfadsf\n");
			//printf("%d\n" , p->val);
			p = p->next;
		}
	}
	*/
	p = mergeKLists(arr,2);
	while(p != NULL) {
		printf("%d\t", p->val);
		p = p->next;
	}
	printf("\n");
	return 0;
}
예제 #24
0
 /**
  * @param lists: a list of ListNode
  * @return: The head of one sorted list.
  */
 ListNode *mergeKLists(vector<ListNode *> &lists) {
     // write your code here
     return mergeKLists(lists, 0, lists.size()-1);
     
 }
예제 #25
0
 ListNode *mergeKLists(vector<ListNode *> &lists) {
     return mergeKLists(lists, 0, lists.size() - 1);
 }
예제 #26
0
 ListNode* mergeKLists(vector<ListNode*>& lists) {
     int num = lists.size();
     if(!num) return NULL;
     return mergeKLists(lists, 0, num-1);
 }