数据结构——快速排序（hoare版、挖坑法、前后指针版、循环实现）

已于 2022-04-09 17:18:45 修改
阅读量2.6k 收藏 27
点赞数 18
分类专栏： 数据结构 文章标签： 数据结构
于 2022-04-09 09:32:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63020222/article/details/124049805
版权
本文详细介绍了快速排序的三种实现方式：Hoare版、挖坑法和前后指针版，分析了算法的缺陷并提出了优化策略，包括三位取中法、设置阈值和循环实现。此外，还提供了快速排序的接口实现，包括递归和非递归版本，并给出了测试用例和性能分析。
摘要由CSDN通过智能技术生成

目录

一、算法思想

1.hoare版

2.挖坑法

3.前后指针版

 二、算法缺陷与优化

1.算法缺陷

1.1基准值取值

1.2递归超限

2.优化方法

2.1三位取中法

2.2设置阈值

2.3循环实现

三、接口实现

1.快速排序

2.hoare版

3.挖坑法

4.前后指针版

5.非递归版

四、接口测试

1.测试用例

2.测试结果

2.1递归方式

 2.2非递归方式

五、性能分析

六、完整代码

1.QuickSort.c

2.Stack.h

一、算法思想

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想是：任意选取待排序序列中的一个元素作为基准值，按照该排序码将待排序集合分割成两个子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后再对左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

注：后续实现均以取序列最右侧元素为基准值为例。

其中，将区间按照基准值划分为左右两部分的常见方式有三种：

1.hoare版

通过两个标志，分别从左往右找比基准值大的元素和从右向左找比基准值小的元素，然后交换两个元素，重复上述过程直到两个标志位相遇，最后再将基准值交换到相遇位置，然后再对左右子序列重复上述过程，直到整个序列完成排序。

图示：

2.挖坑法

挖坑法大体思路与hoare法思路相同，其基本思想是：将基准值保存到标记位中，这样最右侧位置就形成了一个坑位，然后左侧标注位往右遍历找比基准值大的元素，找到后将该元素填入右侧坑位中，该位置就又形成了一个新的坑位，然后从右侧往左遍历找比基准值小的元素，将该元素填入到坑位中，重复上述过程直到左右标志位相遇，最后将基准值放入最后的坑位中，最对左右子序列重复上述过程直到整个序列排序完成。

图示基准值取的为最左侧元素：

3.前后指针版

初始设置cur、prev两个标志指针，cur标志序列第一个元素，prev标志cur前一个位置，cur位置的元素若大于基准值，cur向前前进，若小于基准值，则先对prev进行加一，然后交换cur和prev标记位置的元素，这样就能保证cur与prev之间的元素都大于基准值，prev之前的元素都小于基准值，重复上述过程，直到cur超过序列最右侧位置，最后进行一次判断，若prev标记位置不是序列最后一个位置，则将基准值交换到prev交换位置，即完成左右子序列划分，再对左右子序列重复上述过程，直到整个序列完成排序。

图示：

 二、算法缺陷与优化

1.算法缺陷

1.1基准值取值

若所取基准值为序列中的最大或最小值，那么每趟划分后，基准值的一侧将会出现没有元素的情况，就相当于每趟只完成了一个元素的排序，那么快速排序的时间复杂度此时将达到O(n^{2})，效率较低。

1.2递归超限

算法递归深度会随着元素的增多而加深，若序列元素元素量非常巨大，可能会造成递归超限。

2.优化方法

2.1三位取中法

我们可以通过选取序列中开始、中间、末尾三个位置中元素大小居中的元素作为基准值，此方法可以大大降低基准值取到序列内最大或最小元素的概率。

注：为了不改变代码的逻辑实现，若取得的基准值的位置不是基准值默认位置，可先提前将基准值交换到所取基准值的默认位置处。

2.2设置阈值

我们可以发现，随着划分次数的增加，子序列内的元素个数会不断减少，而且元素数量较少时，各类排序算法的效率差距其实是可以忽略不记的，而比较适合元素个数比较少的排序就是直接插入排序，所以我们可以在递归的过程中设计一个阈值，当子序列中元素个数不超过阈值时，递归不再进行，而是直接对当前子序列进行直接插入排序，然后返回。

当然，这种方法只能进行一定程度的缓解，并不能完全解决递归超限的问题。

所以，我们可以提前估算一下递归的深度N，再在递归深度上设置一个阈值count，若N小于count直接进行快速排序；若N大于count，先通过快速排序递归count次，然后再对每个分组中进行其他排序（比如：堆排序）。

这样即不会对算法效率造成太大影响，也避免了递归超限的问题。

2.3循环实现

使用循环的方式实现快速排序，我们会发现直接转循环并不容易实现，结合递归调用的特性，后调用的先结束退出，先调用的后结束，符合栈后进先出的特点，所有可以利用栈来循环实现快速排序。

每次对序列进行分割后，利用栈依次压入左右子序列的右边界和左边界，这样下一次循环就会依次拿到一个子序列的左右边界，然后再对此序列进行分割，循环进行上述操作，直到栈为空即完成序列排序。（可加上优化方法，为子序列元素个数加上阈值）

三、接口实现

1.快速排序

void QuickSort(int* array, int left, int right) {//快速排序
	if (right - left <= 16) {//阈值设置为16
		InsertSort(array + left, right - left);//达到阈值，进行直接插入排序
	}
	else {
		if (right - left <= 1) {//区间内少于等于1个元素，不需要再排
			return;
		}
		int div = PartSort2(array, left, right);//找一个基准值对区间元素进行划分，分割完成后返回基准值位置
		QuickSort(array, left, div);//对基准值左侧进行快排
		QuickSort(array, div + 1, right);//对基准值右侧进行快排
	}
}

2.hoare版

int PartSort1(int* array, int left, int right) {//快速排序hoare版
	int begin = left;
	int end = right - 1;
	int midPos = GetMiddleIndex(array, left, right);//获取元素大小相对靠中的元素下标
	if (midPos != end) {//将该元素交换到末尾，从而不影响后续代码的逻辑实现
		Swap(&array[midPos], &array[end]);
	}
	int key = array[end];//取最后一个元素为基准值
	while (begin < end) {//begin与end没有相遇
		while (begin < end && array[begin] <= key) {//1.从前往后找比基准值key大的元素
			begin++;
		}
		while (begin < end && array[end] >= key) {//2.从后往前找比基准值key小的元素
			end--;
		}
		if (begin != end) {//3.交换两个元素
			Swap(&array[begin], &array[end]);
		}
	}
	Swap(&array[begin], &array[right - 1]);//4.将基准值交换到区间中间位置
	return begin;//5.返回基准值下标
}

3.挖坑法

int PartSort2(int* array, int left, int right) {//快速排序挖坑法
	int begin = left;
	int end = right - 1;
	int midPos = GetMiddleIndex(array, left, right);//获取元素大小相对靠中的元素下标
	if (midPos != end) {//将该元素交换到末尾，从而不影响后续代码的逻辑实现
		Swap(&array[midPos], &array[end]);
	}
	int key = array[end];//1.取最后一个元素为基准值，并挖坑end
	while (begin < end) {//begin与end没有相遇
		while (begin < end && array[begin] <= key) {//2.从前往后找比基准值key大的元素
			begin++;
		}
		if (begin != end) {
			array[end--] = array[begin];//3.填end坑,挖begin坑,end前移一位
		}
		while (begin < end && array[end] >= key) {//4.从后往前找比基准值key小的元素
			end--;
		}
		if (begin != end) {
			array[begin++] = array[end];//5.填begin坑，挖end坑，begin后移一位
		}
	}
	array[end] = key;//6.基准值放入最后一个坑内
	return end;//7.返回基准值下标
}

4.前后指针版

int PartSort3(int* array, int left, int right) {//快速排序前后指针版
	int cur = left;//标记第一个元素
	int prev = cur - 1;//位于cur之后一个位置
	int midPos = GetMiddleIndex(array, left, right);//获取元素大小相对靠中的元素下标
	if (midPos != right - 1) {//将该元素交换到末尾，从而不影响后续代码的逻辑实现
		Swap(&array[midPos], &array[right - 1]);
	}
	int key = array[right - 1];//取最后一个元素为基准值
	while (cur < right) {
		if (array[cur] < key && ++prev != cur) {//始终保存cur与prev之间的元素都大于基准值key
			Swap(&array[cur], &array[prev]);
		}
		cur++;
	}
	if (++prev != right - 1) {//将基准值交换到prev的下一个位置
		Swap(&array[right - 1], &array[prev]);
	}
	return prev;
}

5.非递归版

void QuickSortNonR(int* array, int size) {//快速排序非递归版
	Stack s;
	StackInit(&s);
	int left = 0;
	int right = size;

	StackPush(&s, right);//依次压入右边界和左边界
	StackPush(&s, left);

	while (!StackEmpty(&s)) {//栈不为空，循环进行
		left = StackTop(&s);//获取栈顶，左边界
		StackPop(&s);//左边界出栈
		right = StackTop(&s);//获取栈顶，右边界
		StackPop(&s);//右边界出栈

		if (right - left <= 16) {//子序列达到阈值
			InsertSort(array + left, right - left);//进行直接插入排序
		}
		else {
			int div = PartSort2(array, left, right);
			//基准值左侧（left，div）；右侧（div+1，right）

			//先压右侧子序列边界（先压右边界，再压左边界）
			StackPush(&s, right);
			StackPush(&s, div + 1);

			//再压左侧子序列边界
			StackPush(&s, div);
			StackPush(&s, left);
		}
	}
}

四、接口测试

1.测试用例

void TestPartSort() {//快速排序测试函数
	int array[] = { 5,4,8,1,9,7,3,2,6,0 };
	int length = sizeof(array) / sizeof(array[0]);

	printf("排序前：");
	PrintArray(array, length);
	QuickSort(array, 0, length);//递归方式
	//QuickSortNonR(array, length);//非递归方式
	printf("\n排序后：");
	PrintArray(array, length);
}

2.测试结果

2.1递归方式

 2.2非递归方式

五、性能分析

1.时间复杂度：O(nlog^{n})

2.空间复杂度：O(log^{n})

3.稳定性：不稳定

六、完整代码

1.QuickSort.c

#include"Stack.h"

void QuickSort(int* array, int left, int right);//快速排序
int  PartSort1(int* array, int left, int right);//快速排序hoare版
int  PartSort2(int* array, int left, int right);//快速排序挖坑法
int  PartSort3(int* array, int left, int right);//快速排序前后指针版

int GetMiddleIndex(int* array, int left, int right);//三位取中法(选取元素大小相对靠中的为基准值)
void QuickSortNonR(int* array, int size);//快速排序非递归版

void InsertSort(int* array, int size);//直接插入排序
void PrintArray(int* array, int size);//数组打印
void Swap(int* num1, int* num2);//整数交换

void TestPartSort();//快速排序测试函数

int main() {
	TestPartSort();
	return 0;
}

void QuickSort(int* array, int left, int right) {//快速排序
	if (right - left <= 16) {//阈值设置为16
		InsertSort(array + left, right - left);//达到阈值，进行直接插入排序
	}
	else {
		if (right - left <= 1) {//区间内少于等于1个元素，不需要再排
			return;
		}
		int div = PartSort2(array, left, right);//找一个基准值对区间元素进行划分，分割完成后返回基准值位置
		QuickSort(array, left, div);//对基准值左侧进行快排
		QuickSort(array, div + 1, right);//对基准值右侧进行快排
	}
}

int PartSort1(int* array, int left, int right) {//快速排序hoare版
	int begin = left;
	int end = right - 1;
	int midPos = GetMiddleIndex(array, left, right);//获取元素大小相对靠中的元素下标
	if (midPos != end) {//将该元素交换到末尾，从而不影响后续代码的逻辑实现
		Swap(&array[midPos], &array[end]);
	}
	int key = array[end];//取最后一个元素为基准值
	while (begin < end) {//begin与end没有相遇
		while (begin < end && array[begin] <= key) {//1.从前往后找比基准值key大的元素
			begin++;
		}
		while (begin < end && array[end] >= key) {//2.从后往前找比基准值key小的元素
			end--;
		}
		if (begin != end) {//3.交换两个元素
			Swap(&array[begin], &array[end]);
		}
	}
	Swap(&array[begin], &array[right - 1]);//4.将基准值交换到区间中间位置
	return begin;//5.返回基准值下标
}

int PartSort2(int* array, int left, int right) {//快速排序挖坑法
	int begin = left;
	int end = right - 1;
	int midPos = GetMiddleIndex(array, left, right);//获取元素大小相对靠中的元素下标
	if (midPos != end) {//将该元素交换到末尾，从而不影响后续代码的逻辑实现
		Swap(&array[midPos], &array[end]);
	}
	int key = array[end];//1.取最后一个元素为基准值，并挖坑end
	while (begin < end) {//begin与end没有相遇
		while (begin < end && array[begin] <= key) {//2.从前往后找比基准值key大的元素
			begin++;
		}
		if (begin != end) {
			array[end--] = array[begin];//3.填end坑,挖begin坑,end前移一位
		}
		while (begin < end && array[end] >= key) {//4.从后往前找比基准值key小的元素
			end--;
		}
		if (begin != end) {
			array[begin++] = array[end];//5.填begin坑，挖end坑，begin后移一位
		}
	}
	array[end] = key;//6.基准值放入最后一个坑内
	return end;//7.返回基准值下标
}

int PartSort3(int* array, int left, int right) {//快速排序前后指针版
	int cur = left;//标记第一个元素
	int prev = cur - 1;//位于cur之后一个位置
	int midPos = GetMiddleIndex(array, left, right);//获取元素大小相对靠中的元素下标
	if (midPos != right - 1) {//将该元素交换到末尾，从而不影响后续代码的逻辑实现
		Swap(&array[midPos], &array[right - 1]);
	}
	int key = array[right - 1];//取最后一个元素为基准值
	while (cur < right) {
		if (array[cur] < key && ++prev != cur) {//始终保存cur与prev之间的元素都大于基准值key
			Swap(&array[cur], &array[prev]);
		}
		cur++;
	}
	if (++prev != right - 1) {//将基准值交换到prev的下一个位置
		Swap(&array[right - 1], &array[prev]);
	}
	return prev;
}

void QuickSortNonR(int* array, int size) {//快速排序非递归版
	Stack s;
	StackInit(&s);
	int left = 0;
	int right = size;

	StackPush(&s, right);//依次压入右边界和左边界
	StackPush(&s, left);

	while (!StackEmpty(&s)) {//栈不为空，循环进行
		left = StackTop(&s);//获取栈顶，左边界
		StackPop(&s);//左边界出栈
		right = StackTop(&s);//获取栈顶，右边界
		StackPop(&s);//右边界出栈

		if (right - left <= 16) {//子序列达到阈值
			InsertSort(array + left, right - left);//进行直接插入排序
		}
		else {
			int div = PartSort2(array, left, right);
			//基准值左侧（left，div）；右侧（div+1，right）

			//先压右侧子序列边界（先压右边界，再压左边界）
			StackPush(&s, right);
			StackPush(&s, div + 1);

			//再压左侧子序列边界
			StackPush(&s, div);
			StackPush(&s, left);
		}
	}
}

int GetMiddleIndex(int* array, int left, int right) {//三位取中法(选取元素大小相对靠中的为基准值)
	int mid = (left + right) / 2;
	//返回基准值的下标
	if (array[left] < array[right - 1]) {
		if (array[mid] < array[left]) {
			return left;
		}
		else if (array[mid] > array[right - 1]) {
			return right - 1;
		}
		else {
			return mid;
		}
	}
	else {//array[left]>=array[right-1]
		if (array[mid] > array[left]) {
			return left;
		}
		else if (array[mid] < array[right - 1]) {
			return right - 1;
		}
		else {
			return mid;
		}
	}
}

void InsertSort(int* array, int size) {//直接插入排序
	for (int i = 1; i < size; i++) {//从1开始循环，默认数组内第一个元素为有序序列
		int end = i - 1;//标记已排序序列最后位置下标
		int key = array[i];//依次拿取数组内元素
		while (end >= 0 && key < array[end]) {//key从前往后比较：小于当前元素，继续往前走
			array[end + 1] = array[end];//将当前元素往后移一个位置
			end--;
		}
		array[end + 1] = key;//key大于等于当前元素，插入到当前位置之后
	}
}

void PrintArray(int* array, int size) {//数组打印
	for (int i = 0; i < size; i++) {
		printf("%d ", array[i]);
	}
}

void Swap(int* num1, int* num2) {//整数交换
	int temp = *num1;
	*num1 = *num2;
	*num2 = temp;
}

void TestPartSort() {//快速排序测试函数
	int array[] = { 5,4,8,1,9,7,3,2,6,0 };
	int length = sizeof(array) / sizeof(array[0]);

	printf("排序前：");
	PrintArray(array, length);
	//QuickSort(array, 0, length);//递归方式
	QuickSortNonR(array, length);//非递归方式
	printf("\n排序后：");
	PrintArray(array, length);
}

2.Stack.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<string.h>
#include<malloc.h>

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* array;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;
/*void StackInit(Stack* ps, int capacity);// 初始化栈 
void StackPush(Stack* ps, STDataType data);// 入栈 
void StackPop(Stack* ps);// 出栈 
STDataType StackTop(Stack* ps);// 获取栈顶元素 
int StackSize(Stack* ps);// 获取栈中有效元素个数 
int StackEmpty(Stack* ps);// 检测栈是否为空，为空返回1，非空返回0 
void StackDestroy(Stack* ps);// 销毁栈 
void Stack_Test();//功能测试函数
*/

// 初始化栈 
void StackInit(Stack* ps) {
	assert(ps);
	ps->array = (STDataType*)malloc(sizeof(STDataType) * 3);
	if (ps->array == NULL) {//申请失败
		assert(0);
		return;
	}
	ps->capacity = 3;
	ps->top = 0;
}

void StackCheckCapacity(Stack* ps) {
	assert(ps);
	if (ps->top == ps->capacity) {//栈满
		int newCapacity = ps->capacity * 2;//每次扩容扩大两倍
		STDataType* temp = (STDataType*)malloc(sizeof(STDataType) * newCapacity);//开辟新空间
		if (temp == NULL) {
			assert(0);
			return;
		}
		memcpy(temp, ps->array, sizeof(STDataType) * ps->capacity);//将元数据拷贝到新空间中
		free(ps->array);//释放旧空间，使用新空间
		ps->array = temp;
		ps->capacity = newCapacity;
	}
}

void StackPush(Stack* ps, STDataType data) {//入栈
	StackCheckCapacity(ps);//判断是否栈满，栈满则扩容
	ps->array[ps->top] = data;
	ps->top++;
}

int StackEmpty(Stack* ps) {//栈判空
	assert(ps);
	return 0 == ps->top;//空返回1，非空返回0
}

void StackPop(Stack* ps) {//出栈
	if (StackEmpty(ps)) {//判空
		return;
	}
	ps->top--;
}

STDataType StackTop(Stack* ps) {//获取栈顶元素
	assert(ps);
	return ps->array[ps->top - 1];
}

int StackSize(Stack* ps) {//获取栈中有效元素个数
	assert(ps);
	return ps->top;
}

void StackDestroy(Stack* ps) {//栈销毁
	assert(ps);
	if (ps->array) {
		free(ps->array);
		ps->capacity = 0;
		ps->top = 1;
	}
}

Hey小孩
关注
专栏目录
快速排序法（详解）
小白的博客
07-01 58万+
假设对以下10个数进行快速排序： 6 1 2 7 9 3 4 5 10 8 我们先模拟快速排序的过程：首先，在这个序列中随便找一个数作为基准数，通常为了方便，以第一个数作为基准数。 6 1 2 7 9 3 4 5 10 8 在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位...
排序--快速排序（前后指针法）
loreal8的博客
05-11 687
快速排序（前后指针法） 时间复杂度：最坏：O(n^2)–>不会出现 最好:O(nlogn) 平均：O(nlogn) 空间复杂度：O(logn) 函数调用栈， 极端情况: O(n)–>不会出现 稳定性：不稳定 数据敏感：敏感 #include<stdio.h> //升序 void Swap(int* array, int i, int j) { int tmp = array[i]; array[i] = array[j]; array[j] = tmp; } //三
史上最细快速排序讲解（hoare，挖坑，双指针， 非递归）
最新发布
Jdxxwu的博客
09-29 1009
史上最细快速排序讲解（hoare，挖坑，双指针， 非递归），一篇博客带你学会所有快排算法思想！（入门必看！）
快速排序之hoare法
mysterious superstar
08-27 814
hoare法 首先我们来看它的基本思路： 第一步：选择待排序数组中的三个值，分别是首尾还有中值，start，end 和mid 第二步：对三个数进行排序，从小到大， 第三步：保护基准值，swap(src + mid, src + end - 1);也就是基准值和倒数第...
5.详解快速排序--前后指针法
感谢观看
06-17 372
前后指针法单趟排序详解
快速排序 (挖坑法)
一个小孩博客
06-22 358
实现方法首先对于，想了解的朋友，可以去看我的另一篇链接:。接下来的就是。
快速排序(Hoare)
flyapy
05-11 555
快速排序的思想： 1，选择枢纽元（pivot）
C语言——快速排序（hoare版本）
duxinyu的博客
05-01 457
快速排序 其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。 具体的区间划分方式我这里总结了三种： hoare版本 挖坑法 前后指针法 图示： 代码实现： //快速排序hoare版本 int PartSort1(int*...
常见排序算法之交换排序——冒泡排序、快速排序
保护小周ღ的博客
07-07 3603
​ 哈喽大家好，我是保护小周ღ，本期为大家带来的是常见排序算法中的交换排序，主要有冒泡排序，快速排序，快排分享了三种算法：挖坑法，左右指针法，前后指针法，以及两种优化方式：解决快排最坏情况的“三数取中”，避免递归次数过多的"小区间优化"，包您一看就会，快来试试吧~ ​......
数据结构之排序算法——快排
weixin_64394633的博客
06-26 870
新手入门必看快排算法 但这种代码会导致死循环，假设左右值均与key相同的话，哪么二者就会不停的交换从而导致死循环，在这里我们做一些小优化： 但是随之而来的就有一个更大的问题，那就是如果定义的可以为最左且右边的数都比key大的话，哪么就会造成越界的问题，一次我们在优化一下： 故完整的单趟过程如下： 在这里顺便说一个问题，为什么要将左边的值作为key，其实这是为了保证第二次的key比第一次的小，这就保证了代码顺利的运行。具体代码如下： 接下来我们就再来介绍...
数据结构与算法——八大排序算法（Java）
m0_52435951的博客
02-14 496
【数据结构】三万字图文讲解带你手撕八大排序(附源码)
StackFrame
12-31 2172
排序概念梳理、八大排序图文讲解 + 代码实现，时空复杂度及稳定性分析，测试框架（附源码）
快速排序（Hoare版）
weixin_65528013的博客
08-22 143
快速排序（Hoare版）
快速排序方法3——前后指针法
weixin_69283129的博客
10-04 1199
C语言版快速排序之前后指针法的讲解与代码实现
快速排序（挖坑法和前后指针法）--排序算法（四）
格子衫爱上Helloworld
02-21 1187
快速排序思想 快速排序(Quick Sort)使用分治法策略。它的基本思想是：选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小。然后，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 快速排序流程如下： 从数列中挑出一个基准值。 将所有比基准值小的摆放在基准前面，所有比基准值大的摆在...
快速排序的循环
weixin_43249817的博客
09-20 420
笔者在学习快速算法时，读了这篇博客 https://blog.csdn.net/MoreWindows/article/details/6684558 在自己实验时，发现如果将其最外层循环从while(i&amp;lt;j)改为while(i!=j)，则程序会陷入一个死循环。 断点调试发现，卡在了i=8,j=7。即两个浮标交叉了。思考了下，发现是递归语句出了问题。 当i浮标和当前的l或者r重合的时候，...
【数据结构】快速(QuickSort)排序之——前后指针法
LX18792732127的博客
05-15 1384
【数据结构】快速(QuickSort)排序之--前后指针法
快速排序及其分析
weixin_30569001的博客
07-27 94
前言 快速排序的平均情况下是O(nlogn)，但是一般都比其他运行时间为O(nlogn)的算法都要快，因为它隐藏的常数因子比较小，但是在最坏情况之下，快速排序的运行时间是O(n2)。 快速排序过程 快速排序采用的思想是分治思想，就像合并排序算法的思想一样，合并排序算法是从数组的中间开始分治，直到分为N个分组，最后分别合并N个分组的解。如下图，有原始数组A = {1, 3, 4, 5, 7, ...
挖坑法快速排序
graceful_tomorrow的博客
02-15 282
该方法的基本思想是： 1．先从数列中取出一个数作为基准数。 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。 3．再对左右区间重复第二步，直到各区间只有一个数。 #include &lt;iostream&gt; using namespace std; void QuickSort(int *array, int left, int right){ ...
数据结构与算法解析——以严蔚敏版教材为中心
《数据结构(C语言版)》由严蔚敏和吴伟民合著，是学习数据结构的经典教材。书中的内容涵盖了各种基本和高级数据结构，如线性表、栈、队列、树、图，以及排序和查找算法。通过C语言的实现，读者可以深入理解这些数据...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hey小孩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值