为什么快速排序第二个while循环内仍然要判断 low 小于 high 以及为什么要从high减减开始.

每次循环结束后输出一下返回的位置信息 pivot
你就发现一趟后返回的位置比实际的要大1
就是因为第二层内的while没有low < high的判断的约束,导致low和high的值错乱

#include<stdio.h>

int count=0;  //全局变量 记录进行了多少趟快速排序 


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

int partition (int a[],int low,int high){
	count++;
	int lengh =  5; 				  //记录排序数组的长度 
	printf("第%d次快速遍历前 \n",count); 
	print(a,lengh);
	int temp = a[low];
	while(low < high){
		while(a[low] <= a[high])  high--;   //high--开始是因为temp保存了a[low]的值,如果从low++开始,a[high]原本的值会被覆盖
		a[low] = a[high];
		while(a[low] <= a[high])  low++;
		a[high] = a[low];
	}
	a[low] = temp;
	printf("第%d次快速遍历后 \n",count); 
	print(a,lengh);
	
	return low;
} 


int sort(int a[],int low,int high){
	if(low < high){
		int pivot = partition(a,low,high);
		printf("pivot=%d \n\n ",pivot);
		sort(a,low,pivot-1);
		sort(a,pivot+1,high);
	}
}

int main(){
	/*
	int a[10]={3,1,2,4,5,6,9,7,10,8};
	print(a,10); 
	sort(a,0,9);
	print(a,10); 
	*/
	int a[5]={3,1,2,5,4};
	sort(a,0,4);
	printf("\n排序结束后\n");
	print(a,5); 
}
1.定义: - **冒泡排序**:通过重复比较相邻元素并交换顺序错误的元素,将最大(或最小)元素逐步“冒泡”到数组末尾的排序算法。 - **二分排序**:通常指基于二分查找思想的插入排序(Binary Insertion Sort),通过二分查找确定插入位置,少比较次数。 - **选择排序**:每次从未排序部分选择最小(或最大)元素,放到已排序部分的末尾的排序算法。 - **快速排序**:通过选择一个“基准”元素,将数组分为两部分(左边小于基准,右边大于基准),递归排序子数组的高效排序算法。 2.基本原理: - **冒泡排序**: - 外层循环控制轮次,内层循环比较相邻元素。 - 每轮结束后,当前未排序部分的最大元素会被放到正确位置。 - 时间复杂度:最坏/平均情况为 \(O(n^2)\),最好情况(已排序)为 \(O(n)\)。 - **二分排序(Binary Insertion Sort)**: - 结合插入排序和二分查找,通过二分查找确定插入位置,少比较次数。 - 移动元素的次数仍为 \(O(n^2)\),但比较次数优化为 \(O(n \log n)\)。 - 时间复杂度:总体为 \(O(n^2)\),但比普通插入排序更高效。 - **选择排序**: - 每次遍历未排序部分,找到最小元素,与未排序部分的第一个元素交换。 - 交换次数较少(最多 \(n-1\) 次),但比较次数为 \(O(n^2)\)。 - 时间复杂度:始终为 \(O(n^2)\),不稳定(可能改变相等元素的相对顺序)。 - **快速排序**: - 选择基准(pivot),将数组分为两部分(左边 ≤ pivot,右边 ≥ pivot)。 - 递归排序左右子数组,直到子数组长度为1或0。 - 时间复杂度:平均 \(O(n \log n)\),最坏 \(O(n^2)\)(如数组已有序且基准选择不当)。 3.在实际工作的应用: - **冒泡排序**: - 适用于小规模数据或教学场景,因实现简单但效率低,实际工程中较少使用。 ```c void bubbleSort(int arr[], int n) { for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++) { if (arr[j] > arr[j+1]) { int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } ``` - **二分排序(Binary Insertion Sort)**: - 适用于数据量较小且比较操作代价较高的场景(如自定义对象排序)。 ```c int binarySearch(int arr[], int item, int low, int high) { while (low <= high) { int mid = low + (high - low) / 2; if (item == arr[mid]) return mid; else if (item > arr[mid]) low = mid + 1; else high = mid - 1; } return low; } void binaryInsertionSort(int arr[], int n) { for (int i = 1; i < n; i++) { int key = arr[i]; int pos = binarySearch(arr, key, 0, i-1); for (int j = i-1; j >= pos; j--) { arr[j+1] = arr[j]; } arr[pos] = key; } } ``` - **选择排序**: - 适用于交换操作代价较高的场景(如结构体数组),因交换次数少。 ```c void selectionSort(int arr[], int n) { for (int i = 0; i < n-1; i++) { int min_idx = i; for (int j = i+1; j < n; j++) { if (arr[j] < arr[min_idx]) min_idx = j; } int temp = arr[min_idx]; arr[min_idx] = arr[i]; arr[i] = temp; } } ``` - **快速排序**: - 适用于大规模数据排序,是通用排序算法中平均效率最高的之一。 ```c int partition(int arr[], int low, int high) { int pivot = arr[high]; int i = low - 1; for (int j = low; j < high; j++) { if (arr[j] <= pivot) { i++; int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } int temp = arr[i+1]; arr[i+1] = arr[high]; arr[high] = temp; return i+1; } void quickSort(int arr[], int low, int high) { if (low < high) { int pi = partition(arr, low, high); quickSort(arr, low, pi-1); quickSort(arr, pi+1, high); } } ``` 4.拓展: - **稳定性**: - 冒泡排序、二分排序、插入排序是稳定的(相等元素顺序不变)。 - 选择排序、快速排序是不稳定的(可能改变相等元素顺序)。 - **优化**: - 快速排序可通过“三数取中”选择基准避免最坏情况。 - 冒泡排序可添加标志位优化(如一轮无交换则提前结束)。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值