Seeking the array k-th smallest number of the array required minimum number of k-th

Seeking the array k-th minimum number

I. Description of the problem

Given an array, the data array of the disorder, to find out the k-th smallest number in an array, for example arrays x, x = {3,2,1,4,5,6}, it first the minimum number of 2 2.

Second, problem-solving ideas

This algorithm is similar to the idea with the fast row, first select a number in the array as a hub centre, centre than small numbers, larger numbers than centre centre to the front and into the rear centre. If at this time was exactly Center position k, the Center for the k-th smallest number; Center at this time, if the previous position k, the k-th smallest number of certain behind centre, recursively find the right thereof; if at this position Center, the k-th smallest number of certain behind Center, recursively find the ratio of k to its left.

Note: position = Center value +1 subscript, as index of the first element of the array is zero.

From the above description, we can see that this algorithm uses a method of solving the reduction treatment. Less government's thinking and the partition is very similar, the same scale in one operation, reducing the problem, just divide and conquer to each sub-problem solving later, to merge solution to each sub-problem to get the problem, and rule reduction method, but do not merge sub-problem solution, the solution of the problem child, is a direct solution of the original problem. Take, for example, as fast row and binary search algorithm, the former is divide and conquer, which is cut rule. Because fast row until all the sub-arrays are exactly the sort, the original array was orderly, and binary search but do not have it every execute a search, discards half of the array, rather than merging sub-problem solution. But there are also many books to them the property of the divide and conquer.

Third, code implementation

Considering the universal code, using the template function, if not read a template function, you only need to ignore template <typename T>, and the T can be seen as a type. code show as below:

  
  
// return start function array k-th smallest elements, attention will destroy the original array
template< typename T>
T FindTheKMin(T *x, int x_size, int k);
// Find the array to achieve the K-th smallest element performance function
template< typename T>
T TheKMin(T *x, int left, int right, int k);
template < typename T>
T FindTheKMin(T *x, int x_size, int k)
{
// determines whether the value of k is too large, i.e. exceeds the size of the array
// If the element 0 is returned, mainly to prevent invalid recursion
if(x_size < k)
return x[ 0];
return TheKMin(x, 0, x_size -1, k);
}
template < typename T>
T TheKMin(T *x, int left, int right, int k)
{
// get the last element of the array as a hub
T centre = x[right];
int i = left;
int j = right - 1;
while( true)
{
// back front scan, to find a value smaller than the first hub,
// before reaching the end of the array, will the end of the cycle, because the last value centre
while(x[i] < centre)
++i;
// scan from back to front, this time to check the index against the array bounds
while(j >= left && x[j] > centre)
--j;
// If the trip is not completed exchange, the exchange
if(i < j)
Swap(x[i], x[j]);
else
break;
}
// the hub in the right place
Swap(x[i], x[right]);
// If at this time was exactly centre position k, the k-th smallest centre number
if(i+ 1 == k)
return x[i];
else if(i+ 1 < k)
{
// If at this time centre position than before k, recursively looking at its right
TheKMin(x, i+ 1, right, k);
}
else
{
// If this time centre position than k, recursively looking to its left
TheKMin(x, left, i -1, k);
}
}
  
  

Code Description:

In the above code, we should pay attention to the final if-else TheKMin function, this algorithm is different from fast row, when the hub is not to find the elements, it will only select sub-arrays continue to look in one direction, rather than fast row that will continue in the direction of the two sub-arrays. From the above point of view of the code, in which the speed should use the same strategy on fast row selected hub, the time complexity is O (N).

Meanwhile, when the K value is unreasonable, we can only return element 0, this is a little unreasonable, but I do not know what kind of return to a proper value, because it is generic.

In fact, there are two defective code, first, that when looking, destroyed the original data array (exchange position); the second is, when the copy type T and construction costs of large, multi directly secondary swap two elements, could bring considerable.

Another implementation

Next, look at another implementation, the same idea and the strategy algorithm, but uses a tracking array Track, to exchange information for tracking data using the first method, using the array element tracking array instead of the original exchange switching elements, solves two problems mentioned above. Its implementation is as follows:

  
  
// returns an array of the smallest elements of the subject under startup function, does not destroy the original array
template< typename T>
int IndexOfKMin(const T *x, int x_size, int k);
// Find the array to achieve the K-th subject of minimum performance function yuan
template < typename T>
int TheKMin(const T *x, int *track, int left, int right, int k);
template < typename T>
int IndexOfKMin(const T *x, int x_size, int k)
{
// determines whether the value of k is too large, i.e. exceeds the size of the array
// If the superscript -1 is returned, mainly to prevent invalid recursion
if(x_size < k)
return -1;
// Create a tracking array, which reads subscript original elements in the array,
// exchanging recording element (i.e., instead of switching element)
// in order to track the data in the array for the next access to standard elements, a method for accessing the same order of
int *track = new int[x_size];
for ( int I = 0 ; I <x_size; I ++) // initialize tracking array, which is the value corresponding to the value of the subscript
track[i] = i;
int i = TheKMin(x, track, 0, x_size -1, k);
delete []track;
return i;
}
template< typename T>
int TheKMin(const T *x, int *track, int left, int right, int k)
{
// get the last element of the array as a hub
T centre = x[track[right]];
int i = left;
int j = right - 1;
while( true)
{
// back front scan, to find a value smaller than the first hub,
// before reaching the end of the array, will the end of the cycle, because the last value centre
// note data at this time is not the index i, but the track [i]
while(x[track[i]] < centre)
++i;
// After scanning forward from the index to be checked, to prevent cross-border array
while(j >= left && x[track[j]] > centre)
--j;
// If the trip is not completed exchange, the exchange of note, is the value of the exchange tracking array
if(i < j)
Swap(track[i], track[j]);
else
break;
}
// the hub in the right place
Swap(track[i], track[right]);
// If at this time was exactly centre position k, the k-th smallest centre number,
// returns to its index in the real array, i.e. track [i]
if(i+ 1 == k)
return track[i];
else if(i+ 1 < k)
{
// If at this time centre position than before k, recursively looking at its right
TheKMin(x, track, i+ 1, right, k);
}
else
{
// If this time centre position than k, recursively looking to its left
TheKMin(x, track, left, i -1, k);
}
}
  
  

Code Description:

From the above code, we can see that this function returns the array element of the k-th smallest index, it is unreasonable when k, -1 can be represented by the error, while it uses a track array, the contents of track array, the substance is an index of the original data in the array, the exchange elements using the tracking arrays instead of exchange of the original array elements, because the data type of the tracking array is int, so its switching speed is quite fast , so as to solve the two problems mentioned above.

From the above code, we can also see that the time complexity of implementation is the same as the previous, but also for O (N), but the implementation has brought a certain amount of space overhead, it opens up a original equal to the number of array elements one-dimensional array, for tracking the exchange of information elements in the original array.

As for the practice, what kind of algorithm to be used, depending on the needs of the user!