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;
}
