在前面的博客当中，我们实现的排序算法有下面几种：

    （1） 冒泡排序、插入排序、希尔排序

    （2） 快速排序

    （3） 合并排序

    （4） 堆排序

    （5） 选择排序

    （6） 基数排序

    那么是不是这8种算法都适合今天的题目呢？我简单的对它们进行了分析和归类：

    a）不到最后无法求出最大数据的算法，（插入算法，合并算法，基数排序）

    这些算法的特点就是可以保证局部的数据基本有序，但是无法保证全局的数据有序。在全部数据得到正确地排序之前，没有人知道最大的数据是什么。所以针对这个题目而言，要想知道最大的n个数，那就等于要对所有的数据全部排序一遍。

    b）每次求出一个最大的数据，依次类推，直到所有的数据都已经排序。（冒泡排序、希尔排序、选择排序、堆排序）

    这些算法的特点就是，排序的时候，所有的数据都是按照从大到小排列出来的。按照冒泡排序来说，首先我们选出最大的数据，然后是第二大的数据，依次类推，直到第n大的数据找到为止。堆排序也是这样，我们在构建堆之后，也是每次从堆顶获得一个数据，不断调整堆，再接着获得第二大、第三大......第n大的数据的。我们以冒泡排序为例，看看这一次的算法应该怎么写？

void find_n_max_number(int array[], int length, int number)
{
	int inner ;
	int outer;
	int median;

	if(NULL == array || 0 == length)
		return;

	if(number > length)
		return;

	for(outer = length -1; outer > (length - 1 - number); outer --){
		for(inner = 0; inner < outer; inner ++){
			if(array[inner] > array[inner +1]){
				median = array[inner];
				array[inner]  = array[inner + 1];
				array[inner + 1]= median;
			}
		}
	}
}

int partion(int array[], int start, int end, int swap[])
{
	int loop;
	int left = 0;
	int right = end - start;
	int value = array[start];

	for(loop = start +1; loop <= end; loop++){
		if(array[loop] < value)
			swap[left ++] = array[loop];
		else
			swap[right --] = array[loop];
	}
	swap[left] = value;
	memmove(&array[start], swap, sizeof(int) * (end - start +1));
	return left + start;
}

void _quick_sort(int array[], int start, int end, int swap[], int number)
{
	int middle;

	if(start < end){
		middle = partion(array, start, end, swap);

		if((number - 1) > (end - middle))
		    _quick_sort(array, start, middle -1, swap, number - (end - middle + 1));
		else
		    _quick_sort(array, middle + 1, end, swap, number);
	}
}

void find_n_max_number(int array[], int length, int number)
{
	int* swap ;
	if(NULL == array || 0 == length)
		return;

	swap = (int*)malloc(sizeof(int) * length);
	_quick_sort(array, 0, length-1, swap, number);
	free(swap);
}

总结：

    至于这些算法的结果怎么样，各位朋友们可以自己利用自己的电脑好好测试一下。