算法：最小的k个数

输出一个数组中最小的k个数，最暴力的求解方法是先排序，然后循环输出最小的k个数，这样的时间复杂度是O(nlogn)，很显然效率低下。

方法1：基于快排思想，利用Partition函数来解决这个问题，如果基于数组的第k个数字来调整，这使得比k小的数字在数组k的左边，比k大的数字在数字k的右边，下面看看代码：

//快排
int Partition(int data[], int length, int start, int end)
{
	if(data == NULL || length <= 0 || start < 0 || end >= length)
		return 0;
	//随机选择主元
	int index = RandomInRange(start, end);
	Swap(&data[index], &data[end]);
	int small = start - 1;
	for(index = start; index < end; ++index)
	{
		if(data[index] < data[end])
		{
			++small;
			if(small != index)
				Swap(&data[index], &data[small]);
		}
	}
	++small;
	Swap(&data[small], &data[end]);
	return small;
}

//最小的k个数
void GetLeastNumbers(int* input, int n, int* output, int k)
{
	if(input == NULL || out putout == NULL || k > n || n <= 0 || k <=0)
		return;
	int start = 0;
	int end = n - 1;
	int index = Partition(input, n, start, end);
	while(index != k - 1)
	{
		if(index > k - 1)
		{
			end = index - 1;
			index = Partition(input, n, start, end);
		}
		else
		{
			start = index + 1;
			index = Partition(input, n, start, end);
		}
	}
	for(int i = 0; i < k; ++i)
		output[i] = input[i];
}

这种算法的复杂度是O(n),我相信很多人会觉得纳闷，会觉得这个算法的时间复杂度是O(nlogn),因为觉得每次只操作一边，那么遍历的次数也是logn次，每次遍历是O(n)，因此是O(nlogn),其实学过算法导论这本书的话，我们可以建立递归公式，

平均情况下：T(n) = T(n/2) + n;                                           第一次划分

                             = T(n/4) + n/2 + n;                                  第二次划分

                             = T(n/8) + n/4 + n/2 + n;                         第三次划分

                             = .....................................

                             = T(n/n) + 2 + 4 + ..... + n;                      第n次划分

很显然这个是等比数列的求和公式，T(n) = 2n

因此该算法的复杂度是O(2n)。

但是这个方法有一个缺点，就是快排会修改输入数组的顺序，不稳定。

方法2：基于红黑树O(nlogk)的算法，特别适合处理海量数据

我们可以先创建一个大小为k的数据容器来存储最小的k个数字，接下来我们每次输入的n个整数中读入一个数。如果容器中已有的数字少于k，那么直接读入容器中；如果容器中已有k个数字，也就是容器已满，此时我们不能再插入新的数字，而只能替代已有的数字。找出已有的k个数中的最大值，然后那这个值跟插入的值进行比较，插入的数比k个数中最大的数小，那么就删除最大数，将新的数插入，这里可以借助红黑树，然后调整红黑树；如果大于就抛弃这个整数。

我们采用红黑树来实现我们的容器，红黑树通过把结点分为红黑两种颜色并根据一些规则（重新上色，旋转）来把持平衡，从而保证在红黑树中查找，删除和插入操作都只需要O(logk)时间，在STL中的set和multiset都是基于红黑树来实现的。下面是基于STL的multiset来实现，参考代码：

typedef multiset<int, greater<int>>  intSet;
typedef multiset<int, greater<int>>::iterator setIterator;

void GetLeastNumbers(const vector<int>& data, intSet& leastNumbers, int k)
{
	leastNumbers.clear();
	if(k < 1 || data.size() < k)
		return;
	vector<int>::const_iterator iter = data.begin();
	for(; iter != data.end(); ++iter)
	{
		if((leastNumbers.size()) < k)
			leastNumbers.insert(*iter);
		else
		{
			setIterator iterGreatset = leastNumbers.begin();
			if(*iter < *(leastNumbers.begin()))
			{
				leastNumbers.erase(iterGreatset);
				leastNumbers.insert(*iter);
			}
		}
	}
}