int quickSelect(vector<int>& nums, int lo, int hi, int kth) {
if (lo == hi) {
return nums[lo];
}
if (lo + 1 == hi) {
int smaller = nums[lo] < nums[hi] ? nums[lo] : nums[hi];
int larger = nums[lo] > nums[hi] ? nums[lo] : nums[hi];
return (kth == lo ? smaller : larger);
}
//CAUTION: Choosing first element as pivot is bad for sorted or reverse sorted data
int pivot = nums[lo];
int plhs=lo+1, prhs=hi;
while (1) {
while (nums[plhs] < pivot) {
if (plhs == hi) break;
plhs++;
}
while (nums[prhs] > nums[lo]) {
if (prhs == lo) break;
prhs--;
}
if (plhs >= prhs) break;
std::swap(nums[plhs++], nums[prhs--]);
}
std::swap(nums[lo], nums[prhs]);
if (kth == prhs) return nums[prhs];
if (kth > prhs) return quickSelect(nums, prhs+1, hi, kth);
return quickSelect(nums, lo, prhs-1, kth);
}
int quickSelect(vector<int>& nums, int lo, int hi, int kth) {
if (lo == hi) {
assert(kth == lo);
return (nums[lo]);
}
int pivotind = (rand() % (hi - lo + 1)) + lo;
std::swap(nums[lo], nums[pivotind]);
int lp = lo+1;
int hp = hi;
int pivot = nums[lo];
while (lp <= hp) {
while (nums[lp] <= pivot) lp++;
while (nums[hp] > pivot) hp--;
if (lp > hp) break;
if (lp <= hi) {
std::swap(nums[lp], nums[hp]);
lp++; hp--;
}
}
std::swap(nums[lo], nums[hp]);
//hp is the pivot
if (kth == hp) { return nums[hp]; }
if (kth < hp) {
return quickSelect(nums, lo, hp-1, kth);
}
return quickSelect(nums, hp+1, hi, kth);//(kth - (hp-lo+1)));
}
int quickSelect(vector<int> &nums, int begin, int end, const int &k){
if(begin > end) return INT_MAX;
int idx = partition(nums, begin, end);
if(idx - begin + 1 == k) return nums[idx];
else if(idx - begin + 1 < k) return quickSelect(nums, idx + 1, end, k - idx + begin - 1);
return quickSelect(nums, begin, idx - 1, k);
}
void quickSelect( vector<Comparable> & a, int left, int right, int k )
{
if( left + 10 <= right )
{
Comparable pivot = median3( a, left, right );
// Begin partitioning
int i = left, j = right - 1;
for( ; ; )
{
while( a[ ++i ] < pivot ) { }
while( pivot < a[ --j ] ) { }
if( i < j )
swap( a[ i ], a[ j ] );
else
break;
}
swap( a[ i ], a[ right - 1 ] ); // Restore pivot
// Recurse; only this part changes
if( k <= i )
quickSelect( a, left, i - 1, k );
else if( k > i + 1 )
quickSelect( a, i + 1, right, k );
}
else // Do an insertion sort on the subarray
insertionSort( a, left, right );
}
// note this return index rather than value
int quickSelect(vector<int>& nums, int p, int r, int k) {
int q = partition(nums, p, r);
if (k == q-p) {
return q;
} else if (k < q-p) {
return quickSelect(nums, p, q-1, k);
} else {
return quickSelect(nums, q+1, r, k-(q-p+1));
}
}
int quickSelect(int* a, int l, int r, int k) {
if (l==r)
return a[l];
int p=partitionate(a,l,r,k);
if (k-1==p)
return a[p];
else if (k-1<p)
return quickSelect(a,l,p-1,k);
else
return quickSelect(a,p+1,r,k);
}
int quickSelect(vector<int>& nums, int left, int right,int k)
{
// 1 2-- 21 ..
if(left==right&&k==1) return nums[left];
if(left>right) return -1;
int p=partition(nums, left, right);
if(right-p==k-1) return nums[p];
if(right-p>k-1)
return quickSelect(nums, p+1 ,right, k);
else return quickSelect(nums, left, p-1, k-(right-p+1));
}
void quickSelect(int a[],int l,int r,int rank)
{
int i=l,j=r,mid=a[(l+r)/2];
do
{
while(a[i]<mid)++i;
while(a[j]>mid)--j;
if(i<=j)
{
swap(a[i],a[j]);
++i;--j;
}
}while(i<=j);
if(l<=j&&rank<=j-l+1)quickSelect(a,l,j,rank);
if(i<=r&&rank>=i-l+1)quickSelect(a,i,r,rank-(i-l));
}
bool DemoApp::camMouseReleased( const OIS::MouseEvent &arg, OIS::MouseButtonID id )
{
if (mTrayMgr->injectMouseUp(arg, id))
return true;
switch (id)
{
case OIS::MB_Left:
{
// If visible set to invisible
if(mSelectionBox->isVisible())
{
mSelectionBox->setVisible(false);
mSelecting = false;
}
if(boxTimeout<6)
{
quickSelect();
}
boxTimeout=0;
mousePressedVar=false;
}
break;
case OIS::MB_Right:
{
generatePath();
}
break;
default:
break;
}
return true;
}
void main() {
int a[5]={4,2,7,6,1};
int n=5;
int i=5;
int x=quickSelect(a,0,n,i);
printf("The nr %i min element of the array is %i.",i,x);
putchar('\n');
}
int quickSelect(int start, int end, vector<int>& nums, int lessNum)
{
int mid = (start + end) / 2;
int pivot = nums[mid];
int l = start;
int r = end;
while( true )
{
while(nums[l] < pivot && l < nums.size())
{
l++;
}
while(nums[r] >= pivot && r >= 0)
{
r--;
}
if(l > r)
break;
swap(nums, l, r);
}
/*Doing this in case the pivot is the minimum or maximum element of the array*/
if( l <= mid)
swap(nums, l, mid);
else
swap(nums, r, mid);
if(l == lessNum)
{
return pivot;
}
else if(l < lessNum)
{
return quickSelect(l+1, end, nums, lessNum);
}
else
{
return quickSelect(start, l-1, nums, lessNum);
}
}
vector<int> majorityElement(vector<int>& nums) {
if (nums.size() <=1) { return nums;}
if (nums.size() == 2) {
if (nums[0] == nums[1]) return vector<int>(1, nums[0]);
else return nums;
}
int n = nums.size();
int posnby3 = n/3 + ((n%3) ? 1 : 0);
int posn2by3 = 2*n/3 + (((2*n)%3) ? 1 : 0);
int nby3 = quickSelect(nums, 0, nums.size()-1, posnby3 - 1);
int n2by3 = quickSelect(nums, 0, nums.size()-1, posn2by3 - 1);
int cnby3 = std::count(nums.begin(), nums.end(), nby3);
int cn2by3 = std::count(nums.begin(), nums.end(), n2by3);
vector<int> retval;
if (cnby3 > (nums.size()/3)) { retval.push_back(nby3);}
if (cn2by3 > (nums.size()/3) && nby3 != n2by3) { retval.push_back(n2by3);}
return retval;
}
/**
* @param nums: A list of integers.
* @return: An integer denotes the middle number of the array.
*/
int median(vector<int> &nums) {
// write your code here
// brute force
// sort(nums.begin(), nums.end());
// return nums[(nums.size()-1) / 2];
//quicksort
return quickSelect(0, nums.size()-1, nums, (nums.size()-1)/2);
}
// Quick select algorithm: find k th smallest number in the sub-array[l..r]
int quickSelect(int *arr, const int &l, const int &r, const int &k) {
const int n = r - l + 1;
// if k is out of range, throw exception
if (k <= 0 || n < k)
throw std::invalid_argument("invalid k-th");
int pivot_i = l + rand() % n; // random pick up a pivot
// partition arr[l..r] around pivot
int pos = partition(arr, l, r, pivot_i);
if (pos - l + 1 == k) // if the pos is the kth number, return it
return arr[pos];
else if (pos - l + 1 > k) // if position is more than kth, find kth within left sub-array
return quickSelect(arr, l, pos - 1, k);
else // if position is less than kth, find kth within right sub-array
return quickSelect(arr, pos + 1, r, k - pos + l - 1);
}
int quickSelect(vector<int> &a, int l, int r, int k)
{
if(l == r) return a[k];
int pivot = a[l];
int i = l + 1;
int j = r;
while(i <= j)
{
while(i <= j && a[i] < pivot) ++i;
while(i <= j && a[j] > pivot) --j;
if(i <= j)
{
swap(a[i++], a[j--]);
}
}
swap(a[j], a[l]);
if(j == k) return a[k];
else if(j < k) return quickSelect(a, j + 1, r, k);
else return quickSelect(a, l, j - 1, k);
}
/* Perform running median filtering */
static void medianFilter
(
REAL *x, /* Input signal */
REAL *m, /* Output signal buffer */
REAL *xic, /* Initial condition */
REAL *xfc, /* Final condition */
long N, /* Size of input signal */
long W, /* Size of sliding window (odd) W = 2*W2+1*/
long W2 /* W2 in above */
)
{
long i, k, idx;
REAL *w;
w = (REAL *)mxCalloc(W, sizeof(REAL)); /* Allocate sliding window */
for (i = 0; i < N; i ++)
{
/* Fill up the sliding window */
for (k = 0; k < W; k++)
{
idx = i - W2 + k;
if (idx < 0)
{
/* Need to get values from the initial condition vector */
w[k] = xic[W2 + idx];
}
else if (idx >= N)
{
/* Need to get values from the final condition vector */
w[k] = xfc[idx - N];
}
else
{
w[k] = x[idx];
}
}
/* Select the median of the sliding window */
m[i] = quickSelect(w, W);
}
/* Clean up */
mxFree(w);
}
void wiggleSort(vector<int>& nums) {
int n = nums.size();
if (n <= 1) {
return;
}
int p = quickSelect(nums, 0, n-1, (n+1)/2);
swap(nums[p], nums[n-1]);
partition(nums, 0, n-1);
p = (n+1) / 2;
// Note: this is not in-place
vector<int> dup = nums;
int i = 0, j = p, k = 0;
while (i < p && j < n) {
nums[k++] = dup[i++];
nums[k++] = dup[j++];
}
if (i < p) {
nums[k++] = dup[i++];
}
}
//Returns the lower median
int64_t get_median(int64_t* vector)
{
if (g_existCalcs[arg1].medianFlag == 1)
return g_existCalcs[arg1].median;
g_existCalcs[arg1].medianFlag = 1;
//Median of a uniform vector is any value in it - as it equals the lower median
if (g_length == 1 || g_vec_properties[arg1][0] == UNIFORM)
{
g_existCalcs[arg1].median = vector[0];
return vector[0];
}
//Calculate middle index
int64_t n = g_length/2;
if (g_length % 2 == 0)
n = g_length/2 - 1;
//Median of sorted vectors is simply at n
if (g_vec_properties[arg1][0] == UP || g_vec_properties[arg1][0] == SEQUP ||
g_vec_properties[arg1][0] == PRIME)
{
g_existCalcs[arg1].median = vector[n];
return vector[n];
}
else if (g_vec_properties[arg1][0] == DOWN || g_vec_properties[arg1][0] == SEQDOWN)
{
g_existCalcs[arg1].median = vector[n-1];
return vector[n-1];
}
int64_t * result = vector;
int64_t median = quickSelect(result, 0, g_length, n);
g_existCalcs[arg1].median = median;
return median;
}
virtual Pixel compute()
{
return static_cast<Pixel>( quickSelect(pixelValues) );
}
void Gear_MedianFilter::runVideo()
{
_image = _VIDEO_IN->type();
if (_image->isNull())
return;
_outImage = _VIDEO_OUT->type();
_outImage->resize(_image->width(), _image->height());
_sizeY = _image->height();
_sizeX = _image->width();
_data = (unsigned char*)_image->data();
_outData = (unsigned char*)_outImage->data();
_medianSize = (int) CLAMP((int)_AMOUNT_IN->type()->value(), 0, 7);
////////////////////////////
for (int y=0;y<_sizeY;y++)
{
for (int x=0;x<_sizeX;x++)
{
_x1 = x - _medianSize;
_x2 = x + _medianSize;
_y1 = y - _medianSize;
_y2 = y + _medianSize;
_x1 = CLAMP(_x1,0,_sizeX-1);
_x2 = CLAMP(_x2,0,_sizeX-1);
_y1 = CLAMP(_y1,0,_sizeY-1);
_y2 = CLAMP(_y2,0,_sizeY-1);
// if (_x1 < 0)_x1 = 0;
// if (_x2 < 0)_x2 = 0;
// if (_y1 < 0)_y1 = 0;
// if (_y2 < 0)_y2 = 0;
// if (_x1 >= _sizeX)_x1 = _sizeX-1;
// if (_x2 >= _sizeX)_x2 = _sizeX-1;
// if (_y1 >= _sizeY)_y1 = _sizeY-1;
// if (_y2 >= _sizeY)_y2 = _sizeY-1;
int nCols = _y2-_y1+1;
int nRows = _x2-_x1+1;
int nextRow = (_sizeX-nCols)*4;
unsigned char *startIterData = _data + (_y1*_sizeX+_x1)*4;
for (int z=0; z<4; ++z)
{
_iterMedianSelect = _medianSelect;
//{
_iterData = startIterData + z;
for (int ySub=_y1; ySub<=_y2; ++ySub)
{
for (int xSub=_x1; xSub<=_x2; ++xSub)
{
*_iterMedianSelect++ = *_iterData;
_iterData+=4;
}
_iterData += nextRow;
}
//}
*_outData++ = quickSelect(_medianSelect, nRows*nCols);
}
}
}
}
/**
* @param nums: A list of integers.
* @return: An integer denotes the middle number of the array.
*/
int median(vector<int> &nums) {
// write your code here
if(nums.empty()) return 0;
int length = nums.size();
return quickSelect(nums, 0, length - 1, (length - 1) / 2);
}
int findKthLargest(vector<int>& nums, int k) {
srand(time(NULL));
return quickSelect(nums, 0, nums.size()-1, nums.size()-k);
}
int quick_select(int a[],int n,int k)
{
quickSelect(a,1,n,k);
return a[k-1];
}
int findKthLargest(vector<int>& nums, int k) {
return quickSelect(nums, 0, nums.size() - 1, k);
}
