C快速排序玩法

最新推荐文章于 2024-03-31 14:29:23 发布

操作系统架构

最新推荐文章于 2024-03-31 14:29:23 发布

阅读量168

点赞数

分类专栏： c/c++ 文章标签：快速排序 c语言

有问题和建议欢迎加本人微信交流：xxdk101

本文链接：https://blog.csdn.net/u011583798/article/details/61438457

版权

c/c++ 专栏收录该内容

56 篇文章 2 订阅

订阅专栏

/*************************************************************************
	> File Name: quick_sort.c
	> Author: XXDK
	> Email: v.manstein@qq.com 
	> Created Time: Thu 09 Mar 2017 03:34:19 AM PST
 ************************************************************************/

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>

#define A_S(a)	(sizeof(a)/sizeof(a[0]))
/**********************************************
 * 思路
 *		1.首先我们需要选取Key就是基准，这里我们
 *	选取a[0] 为key
 *		2.设定两个位置索引head和tail，其中head
 *	指向a[0], tail指向a[len-1]
 *		3.tail索引的元素与key比较，如果a[tail] >
 *	key，tail前移一个位置，否则将tail位置的元素
 *	覆盖key的位置的元素
 *		4.覆盖后，head后移一个位置，比较此时head
 *	索引处的元素和key，如果a[head] < key,head继续
 *	后移否则将head处的元素放入tail索引的位置，并
 *	且tial前移head后移继续比较，直到head 等于 tail，
 *	完成一次快排
 *		快排的整个思想，就是以基准为参考点，所有		
 *      大于基准者放右边，小于基准放左边，最终完成排序
 ******************************************** */
int quick_sort(int a[], int low, int heigh)
{
	static int j = heigh;

	int tail = heigh;
	int head = low;
	int key = a[low];
	printf("##################################################################\n");
	printf("index:\n");
	printf("[0    1    2    3    4    5    6    7    8]\n");
	printf("--------------- key = %d ---------------------------\n", key);

	while(head < tail) { //头索引 小于 尾索引
		//1. 后面的元素大于等于 key 则尾索引前移 tail--
		//	 直到以下两种情况满足之时退出：
		//		a. head 和 tail 相遇（相等）
		//		b. a[tail] 小于 key
		
		for(int i = 0; i <= j; i++) {
			printf("<%d> ", a[i]);
		}
		printf("\n");

		while(head < tail && a[tail] >= key) {
			printf("a[%d] = %d >= key, ", tail, a[tail]);
			tail--;
			printf("tail--, tail = %d \n", tail);
		}
		//2. 判断如果是 b 条件导致的退出（此时 head < tail）
		//   则，将a[tail] 赋值给a[head], 相当于小的数据前置
		if(head < tail) { 
			printf("a[%d] = %d  < key, ", tail, a[tail]);
			printf("a[%d] overwrote by a[%d]\n", head, tail);
			a[head] = a[tail];
			printf("a[%d] = %d\n", head,  a[tail]);
			for(int i = 0; i <= j; i++) {
				printf("<%d> ", a[i]);
			}
			printf("\n\n");
		}
		//3. 前面的元素小于等于 key 则首索引后移 head++
		//	 直到以下两种情况满足之时退出：
		//		a. head 和 tail 相遇（相等）
		//		b. a[head] 大于 key
		while(head < tail && a[head] <= key) {
			printf("a[%d] = %d <= key, ", head, a[head]);
			head++;
			printf("head++, head = %d \n", head);
		}
		//4. 判断如果是 b 条件导致的退出（此时 head < tail）
		//   则，将a[head] 赋值给a[tail], 相当于大的数据后置
		if(head < tail) {
			printf("a[%d] = %d  > key, ", head, a[head]);
			printf("a[%d] overwrote by a[%d]\n", tail, head);
			a[tail] = a[head];
			printf("a[%d] = %d\n", tail,  a[head]);
			for(int i = 0; i <= j; i++) {
				printf("<%d> ", a[i]);
			}
			printf("\n\n");
		}
	}
	printf("head == tail, quit\n");


	// 此时head 等于 tail
	a[head] = key; // key 回归
	printf("put key: %d at a[%d](postion: head == tial)\n", key, head);
	printf("one time quick sort accomplished.\nResult: \n");
	sleep(1);
	for(int i = 0; i <= j; i++) {
		printf("<%d> ", a[i]);
	}
	printf("\n\n");
	// 对key的两侧的子数据再次处理
	// ------------------------------------------------------------------------------------------------------
	// x	x	x	x	x	x	 key	x	x	x	x	x	x
	//                                     tail-1    tail
	//                                     head      head+1
	//low											        heigh
	//-------------------------------------------------------------------------------------------------------
	if(tail - 1 > low) {
		quick_sort(a, low, tail - 1);
	}
	if(head + 1 < heigh) {
		quick_sort(a, head + 1, heigh);	
	}
	return 0;

}

int main()
{
	int a[] = {66, 44, 88, 33, 55, 99, 22, 11, 77};

	printf("before sort: ");
	for(int i = 0; i < A_S(a); i++) {
		printf("%d ", a[i]);
	}
	printf("\n");

	quick_sort(a, 0, 8);

	printf("after sort: ");
	for(int i = 0; i < A_S(a); i++) {
		printf("%d ", a[i]);
	}

	return 0;
}

gcc运行结果：

before sort: 66 44 88 33 55 99 22 11 77
##################################################################
index:
[0 1 2 3 4 5 6 7 8]
--------------- key = 66 ---------------------------
<66> <44> <88> <33> <55> <99> <22> <11> <77>
a[8] = 77 >= key, tail--, tail = 7
a[7] = 11 < key, a[0] overwrote by a[7]
a[0] = 11
<11> <44> <88> <33> <55> <99> <22> <11> <77>

a[0] = 11 <= key, head++, head = 1
a[1] = 44 <= key, head++, head = 2
a[2] = 88 > key, a[7] overwrote by a[2]
a[7] = 88
<11> <44> <88> <33> <55> <99> <22> <88> <77>

<11> <44> <88> <33> <55> <99> <22> <88> <77>
a[7] = 88 >= key, tail--, tail = 6
a[6] = 22 < key, a[2] overwrote by a[6]
a[2] = 22
<11> <44> <22> <33> <55> <99> <22> <88> <77>

a[2] = 22 <= key, head++, head = 3
a[3] = 33 <= key, head++, head = 4
a[4] = 55 <= key, head++, head = 5
a[5] = 99 > key, a[6] overwrote by a[5]
a[6] = 99
<11> <44> <22> <33> <55> <99> <99> <88> <77>

<11> <44> <22> <33> <55> <99> <99> <88> <77>
a[6] = 99 >= key, tail--, tail = 5
head == tail, quit
put key: 66 at a[5](postion: head == tial)
one time quick sort accomplished.
Result:
<11> <44> <22> <33> <55> <66> <99> <88> <77>
##################################################################
index:
[0 1 2 3 4 5 6 7 8]
--------------- key = 11 ---------------------------
<11> <44> <22> <33> <55> <66> <99> <88> <77>
a[4] = 55 >= key, tail--, tail = 3
a[3] = 33 >= key, tail--, tail = 2
a[2] = 22 >= key, tail--, tail = 1
a[1] = 44 >= key, tail--, tail = 0
head == tail, quit
put key: 11 at a[0](postion: head == tial)
one time quick sort accomplished.
Result:
<11> <44> <22> <33> <55> <66> <99> <88> <77>
##################################################################
index:
[0 1 2 3 4 5 6 7 8]
--------------- key = 44 ---------------------------
<11> <44> <22> <33> <55> <66> <99> <88> <77>
a[4] = 55 >= key, tail--, tail = 3
a[3] = 33 < key, a[1] overwrote by a[3]
a[1] = 33
<11> <33> <22> <33> <55> <66> <99> <88> <77>

a[1] = 33 <= key, head++, head = 2
a[2] = 22 <= key, head++, head = 3
head == tail, quit
put key: 44 at a[3](postion: head == tial)
one time quick sort accomplished.
Result:
<11> <33> <22> <44> <55> <66> <99> <88> <77>
##################################################################
index:
[0 1 2 3 4 5 6 7 8]
--------------- key = 33 ---------------------------
<11> <33> <22> <44> <55> <66> <99> <88> <77>
a[2] = 22 < key, a[1] overwrote by a[2]
a[1] = 22
<11> <22> <22> <44> <55> <66> <99> <88> <77>

a[1] = 22 <= key, head++, head = 2
head == tail, quit
put key: 33 at a[2](postion: head == tial)
one time quick sort accomplished.
Result:
<11> <22> <33> <44> <55> <66> <99> <88> <77>
##################################################################
index:
[0 1 2 3 4 5 6 7 8]
--------------- key = 99 ---------------------------
<11> <22> <33> <44> <55> <66> <99> <88> <77>
a[8] = 77 < key, a[6] overwrote by a[8]
a[6] = 77
<11> <22> <33> <44> <55> <66> <77> <88> <77>

a[6] = 77 <= key, head++, head = 7
a[7] = 88 <= key, head++, head = 8
head == tail, quit
put key: 99 at a[8](postion: head == tial)
one time quick sort accomplished.
Result:
<11> <22> <33> <44> <55> <66> <77> <88> <99>
##################################################################
index:
[0 1 2 3 4 5 6 7 8]
--------------- key = 77 ---------------------------
<11> <22> <33> <44> <55> <66> <77> <88> <99>
a[7] = 88 >= key, tail--, tail = 6
head == tail, quit
put key: 77 at a[6](postion: head == tial)
one time quick sort accomplished.
Result:
<11> <22> <33> <44> <55> <66> <77> <88> <99>

after sort: 11 22 33 44 55 66 77 88 99
Press ENTER or type command to continue