MultiwayMerge

Merges multiple sets. The input sets are passed as a range of ranges and each is assumed to be sorted by less. Computation is done lazily, one union element at a time. The complexity of one popFront operation is O(log(ror.length)). However, the length of ror decreases as ranges in it are exhausted, so the complexity of a full pass through MultiwayMerge is dependent on the distribution of the lengths of ranges contained within ror. If all ranges have the same length n (worst case scenario), the complexity of a full pass through MultiwayMerge is O(n * ror.length * log(ror.length)), i.e., log(ror.length) times worse than just spanning all ranges in turn. The output comes sorted (unstably) by less. The length of the resulting range is the sum of all lengths of the ranges passed as input. This means that all elements (duplicates included) are transferred to the resulting range. For backward compatibility, multiwayMerge is available under the name nWayUnion and MultiwayMerge under the name of NWayUnion . Future code should use multiwayMerge and MultiwayMerge as nWayUnion and NWayUnion will be deprecated.

Constructors

this
this()
this
this(RangeOfRanges ror)

Postblit

this(this)
this(this)

Members

Functions

popFront
void popFront()

Properties

empty
bool empty [@property getter]
front
auto ref front [@property getter]

Static functions

compFront
bool compFront(ElementType!RangeOfRanges a, ElementType!RangeOfRanges b)

Variables

_heap
BinaryHeap!(compFront, RangeOfRanges) _heap;

Heap

Parameters

less

Predicate the given ranges are sorted by.

Return Value

A range of the union of the ranges in ror. Warning: Because MultiwayMerge does not allocate extra memory, it will leave ror modified. Namely, MultiwayMerge assumes ownership of ror and discretionarily swaps and advances elements of it. If you want ror to preserve its contents after the call, you may want to pass a duplicate to MultiwayMerge (and perhaps cache the duplicate in between calls).

Examples

import mir.algorithm.iteration: equal;

static a =
[
    [ 1, 4, 7, 8 ],
    [ 1, 7 ],
    [ 1, 7, 8],
    [ 4 ],
    [ 7 ],
];
static witness = [
    1, 1, 1, 4, 4, 7, 7, 7, 7, 8, 8
];
assert(a.multiwayMerge.equal(witness));

static b =
[
    // range with duplicates
    [ 1, 1, 4, 7, 8 ],
    [ 7 ],
    [ 1, 7, 8],
    [ 4 ],
    [ 7 ],
];
// duplicates are propagated to the resulting range
assert(b.multiwayMerge.equal(witness));

Meta