How could I rearrange an array to get the minimum, median and maximum faster?

Question

I want to repeatedly rearrange an array or std::vector so that the minimum is the first element, the maximum is the last element, and arr[(0+lastIdx)/2] would be the median, elements before the median is less than median, elements after the median would be greater. After each time I query for the min, max and median, I will make changes to the data and I want to quickly query those three values again.

Every time I want to rearrange the array, the array is a different array with same size.

Using std::nth_element I can get the median in the right place, and then I could iterate the array to get min and max. For a single array, this achieves O(n) complexity, and clearly this cannot be improved upon. (Except perhaps, the constant of complexity in front of O(n))

I need to operate on an array, firstly, I rearrange the array, and then do something else, this would make the arranged array totally unarranged again, but no new values are inserted. then, I repeat this procedure over and over again.

Answer 1

Even if you somehow manage to cut the cost of locating min, max, median to zero, You still need to put the misplaced elements below or above the median. Which means worst case of n/2 - 1 permutations each time.

1. First pass, find the minimum and its position (O(n) time, O(1) space)
2. Second pass, find the maximum and its position (O(n) time, O(1) space)
3. Third pass, find the median and its position using the median of median algorithm (O(n) time, O(1) space)
4. Put min, max, median at their respective positions (0, n-1, n/2) by swapping
5. Now you have two indexes: One for below starting at 0, and one for above starting at n-1. While the current below element is where it should be, increment that index.While the current above element is where it should be, decrement that index. When misplaced elements are founds, swap below and above. Repeat as long as below < above. (O(n) time, O(1) space)

Logic of step 4, 5 : The number of elements which are below the median when they should be above is exactly the number of elements which are above and should be below.

Of course you can merge pass 1, 2 ,3 in one function, but that doesnt affect complexity

Let's run with :

{3, 7, 9, 6, 8, 1, 4, 5, 2}

pass 1, 2, 3 : min_pos = 5, max_pos = 2, median_pos = 7, median = 5

swap (0, min_pos)    -> {1, 7, 9, 6, 8, 3, 4, 5, 2}
swap (9, max_pos)    -> {1, 7, 2, 6, 8, 3, 4, 5, 9}
swap (4, median_pos) -> {1, 7, 2, 6, 5, 3, 4, 8, 9}

Now below_pos = 0 above_pos = 8. Elements are not misplaced. Next misplaced below is 7 at position 1. Next misplaced above is 4 at position 6.

swap (1, 6) -> {1, 4, 2, 6, 5, 3, 7, 8, 9}

Next mispaced below is 6 at pos 3. Next misplaced is 3 at position 5.

swap (3, 5) -> {1, 4, 2, 3, 5, 6, 7, 8, 9}

And the algorithm output

{1, 4, 2, 3, 5, 6, 7, 8, 9}

Answer 2

You can do it in something like O (log n sqrt (n)) amortized time if you make many changes and many lookups.

Initially, you sort the array. Then you extract the sqrt (n) smallest, the sort (n) largest, and the sqrt (n) values around the median. So you will know "there are n1 elements <= x1" (where n1 is about sqrt (n) and x1 is the n1-smallest element), "there are n2 elements <= x2" (where n2 is about n/2 - sqrt (n)/n, and x2 is the n2-smallest element), "there are n3 elements <= x3" (where n3 is about n/2 + sqrt (n)/n, and x3 is the n3-smallest element) and "there are n4 elements <= x4" where n4 is close to n - sqrt (n) and n4 is the x4-smallest element. You keep track of the elements number 0 to n1, number n2 to n3, and number n4 to n-1.

To get the minimum, maximum, or median, you need to examine about sqrt (n) elements.

When you make a change to an array element, or add or insert an element, you adjust the values n1, n2, n3 and n4 according to what has happened, and the lists of numbers 0 to n1, n2 to n3, and n4 to n-1. After making too many changes, the numbers n1, n2, n3, n4 will be changed so that either the search for min, max, medium takes too long or isn't of any use anymore. When that happens, you sort the data again.

BTW. I think the idea with heaps will work better.

Answer 3

If you have A LOT of memory, you can use two heaps to store the median and two variables to store the min/max:

Pros:

• Minimum and Maximum can be update in O(1);
• Median can be updated in O(log N);

Cons:

• You will need additional memory, N for two heaps (N/2 each) and N for your vector - 2N memory instead of N in your O(N) solution.

There is a built-in STL function in C++ that helps you to build and update the heaps easily: std::make_heap, std::push_heap and std::pop_heap.

More details of how to use two heaps for finding median is described here.

Well, you can also get more tricky - use two vectors to save your data. In that case, you'll need only N memory, but your data will be splitted into two vectors.

Answer 4

O(n) seems to be the best you can do to arrange the array and the way you do it seems to be fine.

In your last paragraph you state that you do something with the array so that it is in a random order again, but no new values are added. Maybe instead of creating a heap, as some suggested, would it not be sufficient to just make a copy of the arranged array?

Pro: you have to arrange the array only once.

Con: you need twice the memory.

Answer 5

Definitely you can not do it faster that in O(N), because you have to look through all elements even to find the minimum.

You can, of course, talk about optimizing the code within O(N) complexity (that is, optimizing the constant before N).

Or will you be doing the same operation several times on a slightly modified array?