算法题（快速排序）

快速排序的基本思想是：通过一趟排序将待排记录分割成独立的 两部分，其中一部分记录的关键字比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

快速排序代码（C实现）

#include <stdio.h>
#include <malloc.h>

#define MAXSIZE 9

typedef struct
{
	int r[MAXSIZE];
	int length;
} SqList;

//交换指定的两个值
void swap(SqList* L, int low, int high)
{
	int temp = L->r[low];
	L->r[low] = L->r[high];
	L->r[high] = temp;
}

/*
** 交换顺序表中L中子表的记录，使枢轴记录到位，并返回其位置
** 此时在他之前（后）的记录均不大（小）于它
*/
int Partition(SqList* L, int low, int high)
{
	int pivotkey;
	pivotkey = L->r[low];
	while (low < high)
	{
		while (low < high && L->r[high] >= pivotkey)
		{
			high--;
		}
		swap(L, low, high);//将比枢轴小的值交换到低端
		while (low < high && L->r[low] <= pivotkey)
		{
			low++;
		}
		swap(L, low, high);//将比枢轴大的值交换到高端
	}

	//打印出每一趟排序的结果
	for (int i = 0; i < MAXSIZE; i++)
	{
		printf("%d ", L->r[i]);
	}
	printf("\n");

	return low;
}

/*
** 对顺序表中的子序列（low,high）作快速排序
*/
void QSort(SqList* L, int low, int high)
{
	int pivot;
	if (low < high)
	{
		pivot = Partition(L, low, high);
		QSort(L, low, pivot - 1);
		QSort(L, pivot + 1, high);
	}
}

void QuickSort(SqList* L)
{
	QSort(L, 1, L->length);
}

int main()
{
	SqList* L = (SqList*)malloc(sizeof(SqList));
	L->r[0] = 50;
	L->r[1] = 10;
	L->r[2] = 90;
	L->r[3] = 30;
	L->r[4] = 70;
	L->r[5] = 40;
	L->r[6] = 80;
	L->r[7] = 60;
	L->r[8] = 20;

	QSort(L, 0, 8);
	return 0;
}

结果是：

20 10 40 30 50 70 80 60 90
10 20 40 30 50 70 80 60 90
10 20 30 40 50 70 80 60 90
10 20 30 40 50 60 70 80 90
10 20 30 40 50 60 70 80 90

快速排序在最优的情况下，其算法的时间复杂度为O(nlogn)，最坏的情况下时间复杂度是O(n * n)，因此平均情况下其时间复杂度是O(nlogn)，可惜的是，由于关键字的比较和交换是条约进行的，因此快速排序是一种不稳定的排序方法。