#Macvector reorder according to tree code#

A use case here is for performing genomic sequencing on GPUs where maximal speed efficiency is obtained by having sequences of similar lengths processed in batches. Having the reordering vector allows you to do this. You might also want to sort and then unsort data. But, if you know you'll be sorting several vectors in the same way, such as in a Structure of Arrays (SoA) context, you can sort once and then reuse the results. We might want that reordering vector! Sorting costs O(N log N). In other words, a move-based solution requires O(N) allocations for any objects and O(1) allocations for the new vector itself.

However, moving still requires a place to move things to and an object like an std::string has both a length variable and a pointer. Your original answer allocates new space and then copies data into it while Tim MB suggests using move semantics. Potatoswatter's answer works in O(N²) time with O(1) additional space and doesn't mutate the reordering vector.Ĭhmike and rcgldr give answers which use O(N) time with O(1) additional space, but they achieve this by mutating the reordering vector. But what do you mean by efficient and what are your requirements? You ask if there is 'a more efficient way'. * every move puts an element into place */ Example C code, reorders A according to indexes in I, also sorts I : void reorder(int *A, int *I, int n) A temp object is needed to hold an element during the moves. This can also be implemented a bit more efficiently using moves instead swaps. every swap places at least one element in it's proper place If vA contained the values 0 through n-1 in order, then after reorder, vA would end up where vOrder started.

#Macvector reorder according to tree code#

This code example effectively reorders vA according to vOrder, while 'unordering' or 'unpermuting' vOrder back to its original state (0 :: n-1). In the following example, every swap places at least one element in it's proper place. The code example here follows the 'cycles' in vOrder, where following a sub-set (could be all of vOrder) of indexes will cycle through the sub-set, ending back at the first index of the sub-set. It appears to me that vOrder contains a set of indexes in the desired order (for example the output of sorting by index). Void reorder(vector &v, vector const &order ) įor (size_t vv = 0 vv < vec.size() ++vv) See below for an optimized O(N) solution which modifies the input. The complexity is O(N^2), taking N as the size of the input, or more precisely, the size of the largest orbit. This function agrees with his for all 11! permutations of.

This is my code so far that uses an incorrect approach (that is making two separate trees and inserting them using different rules).This algorithm is based on chmike's, but the vector of reorder indices is const. The reordering must not involve building a new tree from the input integers (I have already achieved this) instead it must simply reorder them within the same tree.

this property applies over all nodes in the tree.

all values in right subtree are less than root.

all values in left subtree are greater than root.

Re-orders the tree so that values appear in descending order, that is, the new tree has: I would like some helpful suggestions or code to implement a program that behaves according to:īuild a binary search tree from a sequence of integers on the command line (in the order given)