三种不同的快速排序

 一、通过覆盖实现的快速排序

#include <stdio.h>


int partition(int arr[], int low, int high) {
	//划分
	int pivotKey = arr[low];
	while (low < high) {
			//因为默认基准是从左边开始，所以从右边开始比较 
			//当队尾的元素大于等于基准数据 时,就一直向前挪动 high 指针 
			while (low < high && arr[high] >= pivotKey) 
				high--;
			//当找到比 arr[low] 小的时，就把后面的值 arr[high] 赋给它 
				arr[low] = arr[high];
			//当队首元素小于等于基准数据 时,就一直向后挪动 low 指针 
			while (low < high && arr[low] <= pivotKey) 
				low++;
			//当找到比 arr[high] 大的时，就把前面的值 arr[low] 赋给它
				arr[high] = arr[low];
		}
	//跳出循环时 low 和 high 相等,此时的 low 或 high 就是 pivotKey 的正确索引位置
	//把基准数据赋给正确位置 
	arr[low] = pivotKey;
	return low;
}

void quickSort(int arr[], int low, int high) {
	//开始默认基准为 low
	if (low < high) {
		//分段位置下标 
		int pivot = partition(arr, low, high);
		//递归调用排序
		//左边排序 
		quickSort(arr, low, pivot - 1);
		//右边排序 
		quickSort(arr, pivot + 1, high);
	}
}

// 合并到一起快速排序
// void quickSort(int arr[], int low, int high) {
// 	int i = low;
// 	int j = high;
// 	int key = arr[i];
// 	if (low < high) {
// 		while (i < j) {
// 			while (i < j && arr[j] >= key) {
// 				j--;
// 			}
// 			if (i < j) {
// 				arr[i] = arr[j];
// 			}
// 			while (i < j && arr[i] <= key) {
// 				i++;
// 			}
// 			if (i < j) {
// 				arr[j] = arr[i];
// 			}
// 		}
// 		arr[i] = key;
// 		int standard = i;
// 		quickSort(arr, low, standard - 1);
// 		quickSort(arr, standard + 1, high);
// 	}
// }

void display(int arr[], int size) {
	for (int i = 0; i < size; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main() {
	int arr[] = { 49,38,65,97,76,13,27,49,10 };
	int size = 9;
	quickSort(arr, 0, 8);
	display(arr, size);

	// int size = 20;
	// int arr[20] = { 0 };					//数组初始化 
	// for (int i = 0; i < 10; i++) {			//数组个数
	// 	for (int j = 0; j < size; j++) {	//数组大小
	// 		arr[j] = rand() % 1000;		//随机生成数大小 0~99
	// 	}
	// 	printf("原来的数组：");
	// 	display(arr, size);
	// 	quickSort(arr, 0, size - 1);
	// 	printf("排序后数组：");
	// 	display(arr, size);
	// 	printf("\n");
	// }

	return 0;
}

 二、通过交换实现的快速排序 

#include <stdio.h>
void swap(int a[], int i, int j)
{
	int temp = a[i];
	a[i] = a[j];
	a[j] = temp;
}
 
int partition(int a[], int low, int high)
{
	int pivotkey;
    	pivotkey = a[low];//单纯的记录值
	while (low < high)//以pivotkey为交换媒介（枢轴），将大于它的放在后边，小于它的放在前面
	{
		while (low < high && a[high] >= pivotkey)//条件判断 low < high
			high--;
		swap(a, low, high);//找到小于pivotKey的high，与low交换 
		while (low < high && a[low] <= pivotkey)
			low++;
		swap(a, low, high);//找大于pivotKey的low，与high交换 
	}
	return low;//返回枢轴所在位置
}
 
void QSort(int a[], int low, int high)
{
	int pivot;
	if (low < high)//是 if 
	{
		pivot = partition(a, low, high);//将a[]一分为二
		QSort(a, low, pivot - 1);//对低子表递归排序
		QSort(a, pivot + 1, high);//对高子表递归排序
	}
	
}
 
void quickSort(int a[], int low, int high)
{
	QSort(a, low, high);
}
 
 
int main()
{
	int i;
	int a[] = {1,2,5,7,9,6,4,2,6,1};
	quickSort(a, 0, 9);
	printf("\n");
	for (i = 0; i < 10; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

 三、顺序表的快速排序 

#include <stdio.h>
 
#define T 1
#define F 0
#define MAXSIZE 10		//要排序数组个数的最大值
 
typedef struct
{
	int r[MAXSIZE + 1];	//存储要排序数组，r[0]用作哨兵或临时变量
	int length;
}SqList;
 
void swap(SqList *L, int i, int j)
{
	int temp = L->r[i];
	L->r[i] = L->r[j];
	L->r[j] = 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);					//将比枢轴记录大的记录交换到高端
	}
	return low;								//返回枢轴所在位置
}
 
void QSort(SqList *L, int low, int high)
{
	int pivot;
	if (low < high)
	{
		pivot = partition(L, low, high);	//将L->r[low..high]一分为二
											//算出枢轴值pivot
		QSort(L, low, pivot-1);				//对低子表递归排序
		QSort(L, pivot+1, high);			//对高子表递归排序
	}
}
 
void quickSort(SqList *L)	//对顺序表L作快速排序
{
	QSort(L, 1, L->length);
}
 
int main()
{
	int i;
	SqList L;
	L.length = 10;
	for (i = 1; i < L.length+1; i++)
	{
		L.r[i] = i;
	}
	L.r[5] = 100;
	L.r[7] = 90;
	for (i = 1; i < L.length+1; i++)
	{
		printf("%d ", L.r[i]);
	}		
	quickSort(&L);
	printf("\n");
	for (i = 1; i < L.length+1; i++)
	{
		printf("%d ", L.r[i]);
	}
	printf("\n");
	return 0;
}