ListNode* mergeTwo(ListNode* a, ListNode* b) { // This is implemented using a recursive way. // We can also use iterative while loop to achieve // the same effect. if (!a) return b; if (!b) return a; // At this point, both are not NULL. if (a->val < b->val) { a->next = mergeTwo(a->next, b); return a; } else { b->next = mergeTwo(b->next, a); return b; } }
ListNode* mergeKLists(vector<ListNode*>& lists) { // Divide and Conquer approach. // The complexity of merging two lists is O(m+n) // Thus theoratically we should merge smaller ones // First to avoid unnecessarily processing large ones // continuously. int n = lists.size(); if (n == 0) return NULL; while (n > 1) { int mid = (n + 1) / 2; // we merge list i and list (i+mid) repeatively. for (int i = 0; i < n / 2; i++) { lists[i] = mergeTwo(lists[i], lists[i + mid]); } n = mid; } return lists[0]; }
struct segment *mergeSegs(struct segment *segList) /* Return a segment that is merged from all segments in list. */ { struct segment *seg, *lastSeg = NULL, *merged; int geneId = 0, featureId = 0; for (seg = segList; seg != NULL; seg = seg->next) { offsetGenesInSeg(seg); if (lastSeg != NULL) mergeTwo(lastSeg, seg); lastSeg = seg; } AllocVar(merged); for (seg = segList; seg != NULL; seg = seg->next) { struct genScanGene *gene, *nextGene; struct genScanFeature *gsf, *nextGsf; for (gene = seg->geneList; gene != NULL; gene = nextGene) { nextGene = gene->next; gene->id = ++geneId; slAddHead(&merged->geneList, gene); for (gsf = gene->featureList; gsf != NULL; gsf = gsf->next) gsf->geneId = geneId; } for (gsf = seg->suboptList; gsf != NULL; gsf = nextGsf) { nextGsf = gsf->next; gsf->featId = ++featureId; slAddHead(&merged->suboptList, gsf); } if (merged->end < seg->end) seg->end = merged->end; } slReverse(&merged->geneList); slReverse(&merged->suboptList); return merged; }