/*
* QuickSelect
* A average O(n) algorithm to select the kth element
* in array
*/
void QuickSelect(int* A, int p, int r, int k)
{
int q;
if (p < r)
{
q = Random_Partition(A, p, r);
if (q == k)
return;
if (q < k)
QuickSelect(A, q+1, r, k);
else
QuickSelect(A, p, q-1, k);
}
}
void
QuickSelect( Etype A[ ], int Low, int High, int k )
{
if( Low + Cutoff > High )
InsertionSort( &A[ Low ], High - Low + 1 );
else
{
// Sort Low, Middle, High
int Middle = ( Low + High ) / 2;
if( A[ Middle ] < A[ Low ] )
Swap( A[ Low ], A[ Middle ] );
if( A[ High ] < A[ Low ] )
Swap( A[ Low ], A[ High ] );
if( A[ High ] < A[ Middle ] )
Swap( A[ Middle ], A[ High ] );
// Place pivot at Position High-1
Etype Pivot = A[ Middle ];
Swap( A[ Middle ], A[ High - 1 ] );
// Begin partitioning
int i, j;
for( i = Low, j = High - 1; ; )
{
while( A[ ++i ] < Pivot )
;
while( Pivot < A[ --j ] )
;
if( i < j )
Swap( A[ i ], A[ j ] );
else
break;
}
// Restore pivot
Swap( A[ i ], A[ High - 1 ] );
// Recurse: only this part changes
if( k < i )
QuickSelect( A, Low, i - 1, k );
else if( k > i )
QuickSelect( A, i + 1, High, k );
}
}
int main(void) {
int n,k,i;
scanf("%d %d",&n,&k);
int a[n];
for(i=0;i<n;i++){
scanf("%d",&a[i]);
}
printf("%d\n",QuickSelect(a,n,k));
return 0;
}
int QuickSelect(int A[],int n,int k){
int r=0,si=0,li=0,A1[n],A2[n];
int pivot = A[r],i;
for(i=0;i<n;i++){
if(A[i] < pivot) {
A1[si++] = A[i];
}
else if(A[i] > pivot) {
A2[li++] = A[i];
}
}
if(k<=si){
return QuickSelect(A1,si,k);
}
else if(k > (n-li)){
return QuickSelect(A2,li,k-(n-li));
}
else
return pivot;
}
int main()
{
int i;
// QuickSort(A, 0, 9);
QuickSelect(A, 0, 9, 3);
for (i=0; i<10; i++)
{
printf("%d,", A[i]);
}
printf("\n");
return 0;
}
int QuickSelect(std::vector<int> &values, const int left, const int right, const int k)
{
if(left == right)
{
return values[left];
}
const int pivotIndex = partition(values, left, right);
const int length = pivotIndex - left + 1;
if(length == k)
{
return values[pivotIndex];
}
else if ( k < length )
{
return QuickSelect(values, left, pivotIndex - 1, k);
}
else
{
return QuickSelect(values, pivotIndex + 1, right, k - length);
}
}
static void MarkBorderPoints(int CurrentSubproblem, LKH::LKHAlg * Alg)
{
double Min[3], Max[3];
int dMin, dMax, d, i, axis, ActualSubproblemSize = 0, Size = 0;
LKH::LKHAlg::Node **A, *N;
assert(A = (LKH::LKHAlg::Node **) malloc(Alg->DimensionSaved * sizeof(LKH::LKHAlg::Node *)));
Min[0] = Min[1] = Min[2] = DBL_MAX;
Max[0] = Max[1] = Max[2] = -DBL_MAX;
if (Alg->WeightType == LKH::GEO || Alg->WeightType == LKH::GEOM ||
Alg->WeightType == LKH::GEO_MEEUS || Alg->WeightType == LKH::GEOM_MEEUS) {
N = Alg->FirstNode;
do {
N->Xc = N->X;
N->Yc = N->Y;
N->Zc = N->Z;
if (Alg->WeightType == LKH::GEO || Alg->WeightType == LKH::GEO_MEEUS)
GEO2XYZ(N->Xc, N->Yc, &N->X, &N->Y, &N->Z);
else
GEOM2XYZ(N->Xc, N->Yc, &N->X, &N->Y, &N->Z);
} while ((N = N->SubproblemSuc) != Alg->FirstNode);
Alg->CoordType = LKH::THREED_COORDS;
}
N = Alg->FirstNode;
do {
if (N->Subproblem == CurrentSubproblem) {
for (i = Alg->CoordType == LKH::THREED_COORDS ? 2 : 1; i >= 0; i--) {
if (Coord(N, i) < Min[i])
Min[i] = Coord(N, i);
if (Coord(N, i) > Max[i])
Max[i] = Coord(N, i);
}
ActualSubproblemSize++;
}
} while ((N = N->SubproblemSuc) != Alg->FirstNode);
do {
if (N->Subproblem == CurrentSubproblem ||
(N->X >= Min[0] && N->X <= Max[0] &&
N->Y >= Min[1] && N->Y <= Max[1] &&
(Alg->CoordType == LKH::TWOD_COORDS ||
(N->Z >= Min[2] && N->Z <= Max[2])))) {
N->Rank = INT_MAX;
for (i = Alg->CoordType == LKH::THREED_COORDS ? 2 : 1; i >= 0; i--) {
dMin = (int) (fabs(Coord(N, i) - Min[i]) + 0.5);
dMax = (int) (fabs(Coord(N, i) - Max[i]) + 0.5);
d = dMin < dMax ? dMin : dMax;
if (d < N->Rank)
N->Rank = d;
}
} else {
axis = -1;
if (Alg->CoordType == LKH::TWOD_COORDS) {
if (N->X >= Min[0] && N->X <= Max[0])
axis = 1;
else if (N->Y >= Min[1] && N->Y <= Max[1])
axis = 0;
} else if (N->X >= Min[0] && N->X <= Max[0]) {
if (N->Y >= Min[1] && N->Y <= Max[1])
axis = 2;
else if (N->Z >= Min[2] && N->Z <= Max[2])
axis = 1;
} else if (N->Y >= Min[1] && N->Y <= Max[1] &&
N->Z >= Min[2] && N->Z <= Max[2])
axis = 0;
if (axis != -1) {
dMin = (int) (fabs(Coord(N, axis) - Min[axis]) + 0.5);
dMax = (int) (fabs(Coord(N, axis) - Max[axis]) + 0.5);
N->Rank = dMin < dMax ? dMin : dMax;
} else {
N->Rank = 0;
for (i = Alg->CoordType == LKH::THREED_COORDS ? 2 : 1; i >= 0; i--) {
dMin = (int) (fabs(Coord(N, i) - Min[i]) + 0.5);
dMax = (int) (fabs(Coord(N, i) - Max[i]) + 0.5);
d = dMin < dMax ? dMin : dMax;
if (d > N->Rank)
N->Rank = d;
}
}
}
N->Subproblem = 0;
if (!Alg->SubproblemsCompressed ||
((N->SubproblemPred != N->SubBestPred ||
N->SubproblemSuc != N->SubBestSuc) &&
(N->SubproblemPred != N->SubBestSuc ||
N->SubproblemSuc != N->SubBestPred)))
A[Size++] = N;
} while ((N = N->SubproblemSuc) != Alg->FirstNode);
if (ActualSubproblemSize > Size)
ActualSubproblemSize = Size;
else
QuickSelect(A, Size, ActualSubproblemSize);
for (Size = 0; Size < ActualSubproblemSize; Size++)
A[Size]->Subproblem = CurrentSubproblem;
free(A);
if (Alg->WeightType == LKH::GEO || Alg->WeightType == LKH::GEOM ||
Alg-> WeightType == LKH::GEO_MEEUS || Alg->WeightType == LKH::GEOM_MEEUS) {
N = Alg->FirstNode;
do {
N->X = N->Xc;
N->Y = N->Yc;
N->Z = N->Zc;
} while ((N = N->SubproblemSuc) != Alg->FirstNode);
Alg->CoordType = LKH::TWOD_COORDS;
}
}
void
QuickSelect( Etype A[ ], int N, int k )
{
QuickSelect( A, 0, N - 1, k );
}
