median_search.cpp File Reference

Implementation of Median search algorithm. @cases from here More...

`#include <iostream>`
`#include <algorithm>`
`#include <vector>`
`#include <cassert>`
Include dependency graph for median_search.cpp:

## Namespaces

| search
| Search algorithms.
| median_search
| Functions for Median search algorithm.

## Functions

int | search::median_search::median_of_medians (const std::vector< int > &A, const int &idx)
void | test ()
int | main ()

## Detailed Description

Implementation of Median search algorithm. @cases from here

Given an array A[1,...,n] of n numbers and an index i, where 1 ≤ i ≤ n, find the i-th smallest element of A. median_of_medians(A, i): #divide A into sublists of len 5 sublists = [A[j:j+5] for j in range(0, len(A), 5)] medians = [sorted(sublist)[len(sublist)/2] for sublist in sublists] if len(medians) <= 5: pivot = sorted(medians)[len(medians)/2] else: #the pivot is the median of the medians pivot = median_of_medians(medians, len(medians)/2) #partitioning step low = [j for j in A if j < pivot] high = [j for j in A if j > pivot] k = len(low) if i < k: return median_of_medians(low,i) elif i > k: return median_of_medians(high,i-k-1) else: #pivot = k return pivot

Note
  this algorithm implements median search for only arrays which have distinct elements

Here are some example lists you can use to see how the algorithm works A = [1,2,3,4,5,1000,8,9,99] (Contain Unique Elements) B = [1,2,3,4,5,6] (Contains Unique Elements) print median_of_medians(A, 0) #should be 1 print median_of_medians(A,7) #should be 99 print median_of_medians(B,4) #should be 5

Author
  Unknown author
  Sushil Kumar

## Function Documentation

## main()

int main | ( | void |  | ) |

Main function

{
test();
int n = 0;
std::cout << "Enter Size of Array: ";
std::cin >> n;
std::vector<int> a(n);
std::cout << "Enter Array: ";
for(int i = 0; i < n; i++){
std::cin >> a[i];
}
std::cout << "Median: "; // Median defination: https://en.wikipedia.org/wiki/Median
int x = search::median_search::median_of_medians(a, (n - 1) / 2);
if(n % 2 == 0){
int y = search::median_search::median_of_medians(a, n / 2);
std::cout << (float(x) + float(y))/2.0;
}
else{
std::cout << x;
}
std::cout << "\nTo find i-th smallest element ";
std::cout << "\nEnter i: ";
int idx = 0;
std::cin >> idx;
idx--;
std::cout << idx + 1<< "-th smallest element: " << search::median_search::median_of_medians(a, idx) << '\n';
return 0;
}
std::cin
std::cout
search::median_search::median_of_medians
int median_of_medians(const std::vector< int > &A, const int &idx)
Definition: median_search.cpp:62
test
void test()
Definition: median_search.cpp:107
std::vector< int >
Here is the call graph for this function:

## median_of_medians()

int search::median_search::median_of_medians | ( | const std::vector< int > & | A,
|  | const int & | idx
| ) |  |

This function search the element in an array for the given index.

Parameters

  A | array where numbers are saved
  idx | current index in array

Returns
  corresponding element which we want to search.

{
int pivot = 0; // initialized with zero
std::vector<int> a(A.begin(), A.end());
std::vector<int> m;
int r = a.size();
for(int i = 0; i < r; i += 5){
std::sort(a.begin() + i, a.begin() + std::min(r, i + 5));
int mid = (i + std::min(r, i + 5)) / 2;
m.push_back(a[mid]);
}
int sz = int(m.size());
if(sz <= 5){
std::sort(m.begin(), m.end());
pivot = m[(sz- 1) / 2];
}
else{
pivot = median_of_medians(m, idx);
}
std::vector<int> low;
std::vector<int> high;
for(int i = 0; i < r; i++){
if(a[i] < pivot){
low.push_back(a[i]);
}
else if(a[i] > pivot){
high.push_back(a[i]);
}
}
int k = int(low.size());
if(idx < k){
return median_of_medians(low, idx);
}
else if(idx > k){
return median_of_medians(high, idx-k-1);
}
else{
return pivot;
}
}
std::vector::begin
T begin(T... args)
std::vector::end
T end(T... args)
std::min
T min(T... args)
std::vector::push_back
T push_back(T... args)
std::vector::size
T size(T... args)
std::sort
T sort(T... args)
Here is the call graph for this function:

## test()

void test | ( |  | ) |

Function to test above algorithm

{
std::vector<int> A{25,21,98,100,76,22,43,60,89,87};
int i = 3;
assert(A[6] == search::median_search::median_of_medians(A, i)); // A[6] = 43, is the fourth smallest element.
std::cout << "test case:1 passed\n";
std::vector<int> B{1,2,3,4,5,6};
int j = 4;
assert(B[4] == search::median_search::median_of_medians(B, j)); // B[4] = 5, is the fifth smallest element.
std::cout << "test case:2 passed\n";
std::vector<int> C{1,2,3,4,5,1000,8,9,99};
int k = 3;
assert(C[3] == search::median_search::median_of_medians(C, k)); // C[3] = 4, is the fourth smallest element.
std::cout << "test case:3 passed\n";
std::cout << "--All tests passed--\n";
}