剑指Offer----面试题29：扩展----数组中第K小的数字

题目：

求数组中第K小的数字。

方法一：

思想：对输入的数组进行排序，设计一个计数器。然后一次遍历数组中的元素，非前后非重复的数字使计数器加1.

代码如下：

#include<iostream>

using std::cout;
using std::endl;

class ThrowError{};

void show(int *arr, int length)
{
	for (int i = 0; i < length; i++)
	{
		cout << arr[i] << "  ";
	}
	cout << endl;
}

void QuickSort(int *arr, int left, int right)
{
	if (arr == NULL || left < 0 || left > right)
		return;

	if (left < right)
	{
		int i = left;
		int j = right;
		int X = arr[left];

		while (i < j)
		{
			while (i<j && arr[j]>X)
				--j;
			if (i < j)
				arr[i++] = arr[j];
			while (i < j && arr[i] < X)
				++i;
			if (i < j)
				arr[j--] = arr[i];
		}
		arr[j] = X;
		QuickSort(arr, left, i - 1);
		QuickSort(arr, i + 1, right);
	}
}

int MinK(int *arr, int length, int k)
{
	if (arr == NULL || length <= 0 || k > length)
		throw ThrowError{};

	if (k == 1)//当取第一个数字的时候
		return arr[0];

	int count = 1;
	for (int i = 1; i < length; ++i)
	{
		if (arr[i-1] != arr[i])
			++count;

		if (k == count)
			return arr[i];
	}
	cout << "没有第" << k << "小的数字" << endl;
	throw ThrowError{};
}

int main()
{
	int arr[] = { 1, 2, 9, 8,8,6,6,1,2,4 };
	show(arr, 10);
	QuickSort(arr, 0, 9);
	show(arr, 10);
	int minK = MinK(arr, 10, 6);
	cout << "minK = " << maxK << endl;
	system("pause");
	return 0;
}

运行结果：

1  2  9  8  8  6  6  1  2  4
1  1  2  2  4  6  6  8  8  9
minK = 9
请按任意键继续. . .

注意：当数组中没有第K小的数字的时候，程序将会抛出异常，终止程序。

以下内容引自<http://blog.csdn.net/ljianhui/article/details/14215883>

一、问题描述

给定一个数组，数组中的数据无序，在一个数组中找出其第k个最小的数，例如对于数组x，x = {3，2，1，4，5，6}，则其第2个最小的数为2。

二、解题思路

本算法跟快排的思想相似，首先在数组中选取一个数centre作为枢纽，将比centre小的数，放到centre的前面将比centre大的数，放到centre的后面。如果此时centre的位置刚好为k，则centre为第k个最小的数；如果此时centre的位置比k前，则第k个最小数一定在centre后面，递归地在其右边寻找；如果此时centre的位置比k后，则第k个最小数一定在centre后面，递归地在其左边寻找。

注意：centre的位置=其下标值+1，因为数组中的第一个元素的下标为0。

从上面的描述中，我们可以看到这个算法运用了减治的方法求解。减治的思想与分治非常相似，同样是在一次操作中，削减问题的规模，只是分治把每个子问题求解后，要合并每个子问题的解才能得到问题，而减治的方法，却不用合并子问题的解，子问题的解，直接就是原问题的解。举个例子来说，就像快排和二分查找算法，前者是分治，后者是减治。因为快排要等到所有的子数组都排完序，原数组才有序，而二分查找却不用，它每执行一次查找，直接丢弃一半的数组，而不用合并子问题的解。不过也有不少书，把他们都归为分治法。

三、代码实现

考虑到代码的通用性，使用了模板函数，如果看不懂模板函数，则只需要忽略template<typename T>，并把T看作是一个类型即可。代码如下：

[cpp]  view plain  copy

 print ?

1. //返回数组中的第k个最小元素的启动函数，注意会破坏原数组  
2. template<typename T>  
3. T FindTheKMin(T *x, int x_size, int k);  
4. //实现查找数组中第K个最小元的功能函数  
5. template<typename T>  
6. T TheKMin(T *x, int left, int right, int k);  
7. template<typename T>  
8. T FindTheKMin(T *x, int x_size, int k)  
9. {  
10.     //判断k的值是否过大，即超过数组的大小  
11.     //若是则返回第0个元素，主要是为了防止无效的递归  
12.     if(x_size < k)  
13.         return x[0];  
14.     return TheKMin(x, 0, x_size-1, k);  
15. }  
16. template<typename T>  
17. T TheKMin(T *x, int left, int right, int k)  
18. {  
19.     //取数组最后一个元素为枢纽  
20.     T centre = x[right];  
21.     int i = left;  
22.     int j = right - 1;  
23.     while(true)  
24.     {  
25.         //从前向后扫描，找到第一个小于枢纽的值，  
26.         //在到达数组末尾前，必定结束循环,因为最后一个值为centre  
27.         while(x[i] < centre)  
28.             ++i;  
29.         //从后向前扫描，此时要检查下标，防止数组越界  
30.         while(j >= left && x[j] > centre)  
31.             --j;  
32.         //如果没有完成一趟交换，则交换  
33.         if(i < j)  
34.             Swap(x[i], x[j]);  
35.         else  
36.             break;  
37.     }  
38.     //把枢纽放在正确的位置  
39.     Swap(x[i], x[right]);  
40.     //如果此时centre的位置刚好为k，则centre为第k个最小的数  
41.     if(i+1 == k)  
42.         return x[i];  
43.     else if(i+1 < k)  
44.     {  
45.         //如果此时centre的位置比k前,递归地在其右边寻找  
46.         TheKMin(x, i+1, right, k);  
47.     }  
48.     else  
49.     {  
50.         //如果此时centre的位置比k后,递归地在其左边寻找  
51.         TheKMin(x, left, i-1, k);  
52.     }  
53. }  

代码说明：

在上面的代码中，我们要注意，TheKMin函数的最后的if-else，这个算法不同于快排，当枢纽不是要找到元素时，它只会选择其中一个方向的子数组继续寻找，而不像快排那样，会在两个方向的子数组中继续。从上面的代码来看，其运行速度应该在使用相同选取枢纽的策略的快排之上，时间复杂度为O(N)。

同时，当K值不合理时，我们只能返回第0个元素，这点有一点的不合理，但是，我不知道该返回一个什么样的合适的值，因为它是泛型的。

其实，这段代码有两个缺陷，第一个，就是在查找时，破坏了数组原来的数据（交换了位置）；第二个是，当类型T的复制和构造开销较大时，直接多次交换两个元素，可能会带来相当大。

另一种实现

下面，再来看看另一种实现，算法的思想和策略相同，但是使用了一个跟踪数组track，用来跟踪使用第一种方法下的数据的交换情况，利用跟踪数组的元素交换代替原数组中元素的交换，解决了上面提到的两个问题。它的实现如下：

[cpp]  view plain  copy

 print ?

1. //返回数组中的第中个最小元素的下标的启动函数，不破坏原数组  
2. template<typename T>  
3. int IndexOfKMin(const T *x, int x_size, int k);  
4. //实现查找数组中第K个最小元下标的功能函数  
5. template<typename T>  
6. int TheKMin(const T *x, int *track, int left, int right, int k);  
7. template<typename T>  
8. int IndexOfKMin(const T *x, int x_size, int k)  
9. {  
10.     //判断k的值是否过大，即超过数组的大小  
11.     //若是则返回下标-1，主要是为了防止无效的递归  
12.     if(x_size < k)  
13.         return -1;  
14.     //创建一个跟踪数组，其内容为原数组中元素的下标，  
15.     //用于记录元素的交换（即代替元素的交换）  
16.     //按顺序以track数组中的数据为下标访问元素，访问顺序与上一方法相同  
17.     int *track = new int[x_size];  
18.     for(int i = 0; i < x_size; ++i) //初始化跟踪数组，其值与下标值相对应  
19.         track[i] = i;  
20.     int i = TheKMin(x, track, 0, x_size-1, k);  
21.     delete []track;  
22.     return i;  
23. }  
24. template<typename T>  
25. int TheKMin(const T *x, int *track, int left, int right, int k)  
26. {  
27.     //取数组最后一个元素为枢纽  
28.     T centre = x[track[right]];  
29.     int i = left;  
30.     int j = right - 1;  
31.     while(true)  
32.     {  
33.         //从前向后扫描，找到第一个小于枢纽的值，  
34.         //在到达数组末尾前，必定结束循环,因为最后一个值为centre  
35.         //注意此时的数据的下标不是i，而是track[i]  
36.         while(x[track[i]] < centre)  
37.             ++i;  
38.         //从后向前扫描时要检查下标，防止数组越界  
39.         while(j >= left && x[track[j]] > centre)  
40.             --j;  
41.         //如果没有完成一趟交换，则交换，注意，是交换跟踪数组的值  
42.         if(i < j)  
43.             Swap(track[i], track[j]);  
44.         else  
45.             break;  
46.     }  
47.     //把枢纽放在正确的位置  
48.     Swap(track[i], track[right]);  
49.     //如果此时centre的位置刚好为k，则centre为第k个最小的数，  
50.     //返回其在真实数组中的下标，即track[i]  
51.     if(i+1 == k)  
52.         return track[i];  
53.     else if(i+1 < k)  
54.     {  
55.         //如果此时centre的位置比k前,递归地在其右边寻找  
56.         TheKMin(x, track, i+1, right, k);  
57.     }  
58.     else  
59.     {  
60.         //如果此时centre的位置比k后,递归地在其左边寻找  
61.         TheKMin(x, track, left, i-1, k);  
62.     }  
63. }  

代码说明：

从上面的代码，我们可以看出，这个函数是返回数组中的第k个最小元的下标，所以当k不合理时，就可以返回-1来表示这个错误，同时，它使用了一个跟踪数组，track数组中的内容，实质是原数组中数据的一个索引，利用跟踪数组的元素的交换来代替了原数组元素的交换，因为该跟踪数组的数据类型是int，所以其交换速度相当快，从而解决了上面提到的两个问题。

从上面的代码，我们也可以看到，其时间复杂度与前面的实现是一样的，也为O(N)，但是，这个实现方法却带来了一定的空间开销，它开辟了一个与原数组元素个数相等的一维数组，用于跟踪原数组中的元素的交换情况。

至于在实际中，要使用哪一种算法，取决于使用者的需要！