Position of median within a list - c++

Question

I have an unsorted array and I need the position of the median. I know there are several algorithms to calculate the median of a given array in O(n), but all of them include some kind of reordering of the array, like in median of medians and random selection.
I'm not interested int he median itself, only its position within the array interests me.
Is there any way I can do this in O(n)? Keeping track of all the swaps will create a massive overhead, so I'm looking for another solution.

Answer 1

Let's say you have an array of data, and you would like to find its median:
double data[MAX_DATA] = ...
Create an array of indexes, and initialize each index to its own position, like this:
int index[MAX_DATA];
for (int i = 0 ; i != MAX_DATA ; i++) {
index[i] = i;
}
Now implement the linear median algorithm with the following changes:
When the original algorithm compares data[i] to data[j], replace with a comparison of data[index[i]] to data[index[j]]
When the original algorithm swaps data[i] and data[j], swap index[i] and index[j] instead.
Since the elements of data remain in their place all the time, the modified algorithm will produce the position of the median in the unmodified array, rather than its position in the array with some elements moved to different spots.
In C++ you can implement this with pointers instead of indexes, and use std::nth_element on the container of pointers, like this:
vector<int> data = {1, 5, 2, 20, 10, 7, 9, 1000};
vector<const int*> ptr(data.size());
transform(data.begin(), data.end(), ptr.begin(), [](const int& d) {return &d;});
auto mid = next(ptr.begin(), data.size() / 2);
nth_element(ptr.begin(), mid, ptr.end(), [](const int* lhs, const int* rhs) {return *lhs < *rhs;});
ptrdiff_t pos = *mid - &data[0];
cout << pos << endl << data[pos] << endl;
Here is a link to a demo on ideone.

Answer 2

Here's working example that generates a secondary array of indices, and finds the median of the input array through std::nth_element and an indirect comparison
#include <algorithm>
#include <string>
#include <vector>
#include <iostream>
#include <iterator>
int main()
{
// input data, big and expensive to sort or copy
std::string big_data[] = { "hello", "world", "I", "need", "to", "get", "the", "median", "index" };
auto const N = std::distance(std::begin(big_data), std::end(big_data));
auto const M = (N - 1) / 2; // 9 elements, median is 4th element in sorted array
// generate indices
std::vector<int> indices;
auto value = 0;
std::generate_n(std::back_inserter(indices), N, [&](){ return value++; });
// find median of input array through indirect comparison and sorting
std::nth_element(indices.begin(), indices.begin() + M, indices.end(), [&](int lhs, int rhs){
return big_data[lhs] < big_data[rhs];
});
std::cout << indices[M] << ":" << big_data[indices[M]] << "\n";
// check, sort input array and confirm it has the same median
std::sort(std::begin(big_data), std::end(big_data));
std::cout << M << ":" << big_data[M] << "\n";
}
Online output.
This algorithm is guaranteed of O(N) complexity, since it is the sum of std::generate_n and std::nth_element, both of which are O(N) in their input data.

Answer 3

There is an O(n log n) algorithm for keeping track of median on an infinite stream of numbers. (As you don't want to alter the list, you can as well treat it as a stream.) The algorithm involves two heaps; one always points to the maximum number in the lower half and the other points to the minimum number in the higher half. The algorithm is explained here: http://www.ardendertat.com/2011/11/03/programming-interview-questions-13-median-of-integer-stream/. You can use the same code with minimum customization.