快速排序算法C++实现
快速排序算法c语言实验报告
快速排序算法c语言实验报告冒泡法和选择法排序C程序实验报告实验六：冒泡法排序物理学416班赵增月F12 2011412194日期：2013年10月31日一·实验目的 1.熟练掌握程序编写步骤；2.学习使用冒泡法和选择法排序；3.熟练掌握数组的定义和输入输出方法。
二·实验器材1.电子计算机；2.VC6.0三·实验内容与流程1.流程图（1）冒泡法(2)选择法 2.输入程序如下：（1）冒泡法#includestdio.h void main() { int a[10]; int i,j,t; printf(请输入10个数字：\n); for(i=0;i10;i++)scanf(%d,&a[i]); printf(\n); for(j=0;j9;j++)for(i=0;i9-j;i++) if(a[i]a[i+1]) { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } printf(排序后如下：\n); for(i=0;i10;i++) printf(%d,a[i]); printf(\n); }（2）选择法#includestdio.h void main() { int a[10]; int i,j,t,k; printf(请输入10个数字：\n); for(i=0;i10;i++)scanf(%d,&a[i]);printf(\n); for(i=0;i9;i++) {k=i;for(j=i+1;j10;j++) if (a[k]a[j])k=j;t=a[i];a[i]=a[k];a[k]=t; }printf(排序后如下：\n); for(i=0;i10;i++)printf(%d,a[i]); printf(\n); }四．输出结果（1冒泡法）请输入10个数字：135****2468排序后如下：12345678910 （2）选择法输出结果请输入10个数字：135****6810排序后如下：12345678910五．实验反思与总结1.冒泡法和选择法是一种数组排序的方法，包含两层循环，写循环时，要注意循环变量的变化范围。
C语言--常见排序算法
49
2 j 49
08
0
25* 3 49 25
16 4
21
5
08
25
25*
16
21
i k 49
j 25* 25
08
25
25*
16
21
算法实例：
1.1.5 选择排序
49 2
08 0
25 1 i
25* 3
16 4 k
21 5 j 21 16
k 指示当前序列中最小者
算法实现：
08 5 temp
16 21 25 25* 49 08 0 1 2 3 4 5
算法实现：
1.1.3 直接插入排序
void InsertSort (int r[ ], int n ) { // 假设关键字为整型，放在向量r[]中 int i, j, temp; for (i = 1;i< n;i++ ) { temp = r[i]; for(j = i;j>0;j- -) {//从后向前顺序比较，并依次后移 if ( temp < r[j-1] ) r[j] = r[j-1]; else break; } r[j] = temp; } }
输入n 个数给a[1] 到 a[n]
for j=1 to n-1
for i=1 to n-j
真 a[i]>a[i+1]
a[i]a[i+1]
输出a[1] 到 a[n]
main() { int a[11],i,j,t; printf("Input 10 numbers:\n"); for(i=1;i<11;i++) scanf("%d",&a[i]); printf("\n"); 假 for(j=1;j<=9;j++) for(i=1;i<=10-j;i++) if(a[i]>a[i+1]) {t=a[i]; a[i]=a[i+1]; a[i+1]=t;} printf("The sorted numbers:\n"); for(i=1;i<11;i++) printf("%d ",a[i]); }
c语言sort函数
c语言sort函数c语言中的sort函数是一种用于对数组进行排序的函数。
它使用的是一种称为“快速排序”的算法，这种算法是一种基于比较的排序算法，具有较高的效率和性能。
sort函数的声明如下：```c```参数解释：- base: 指向要排序的数组的指针。
- nitems: 数组中的元素个数。
- size: 每个元素的字节数。
sort函数使用递归的方式进行排序，其基本思想是选择一个基准元素，将数组分为左右两部分，左边的元素小于等于基准元素，右边的元素大于等于基准元素，然后对左右两部分递归调用sort函数，直到每个部分只有一个元素为止。
在这个排序算法中，我们需要传入一个比较函数，该函数用于比较两个元素的大小。
比较函数应该返回一个整数值，当第一个元素小于第二个元素时返回负数，当两个元素相等时返回0，当第一个元素大于第二个元素时返回正数。
根据比较结果，sort函数将适当地调整元素的位置，以实现排序的目的。
下面是一个使用sort函数对一个整型数组进行升序排序的示例：```c#include <stdio.h>#include <stdlib.h>return (*(int*)a - *(int*)b);int maiint arr[] = {5, 2, 8, 6, 3, 1, 7, 9, 4};int n = sizeof(arr) / sizeof(arr[0]);printf("升序排序后的数组：");for (int i = 0; i < n; i++)printf("%d ", arr[i]);}return 0;```输出结果为：123456789，表示数组已经按照升序排列完成。
```creturn strcmp(*(char**)a, *(char**)b);```sort函数是标准库函数，很多C语言开发环境都提供了该函数的实现。
快排算法代码
快排算法代码快速排序算法是一种用于排序元素的高效算法。
它的核心思想是选择一个基准元素，将其放入一个合适的位置，然后将序列分成两个部分，其中左半部分的所有元素都小于基准元素，右半部分的所有元素都大于基准元素。
在分得两个部分后，分别对左半部分和右半部分递归地应用快速排序算法，最终将序列排好序。
快速排序算法的优点在于其执行时间短，对内存的消耗较小，同时在处理大数据量时显示出其稳定的性能表现。
快速排序算法的实现需要通过编写代码来实现，以下是一个典型的快速排序算法的代码示例：``` void quicksort(int arr[], int left, intright) { int i = left, j = right, tmp; intpivot = arr[(left + right) / 2]; /* partition*/ while (i <= j) { while (arr[i] <pivot) i++; while (arr[j] >pivot) j--; if (i <= j){ tmp = arr[i]; arr[i] =arr[j]; arr[j] = tmp; i++; j--; } }; /* recursion */if (left < j) quicksort(arr, left, j); if (i < right) quicksort(arr, i, right); } ```上述代码是一个递归实现的快速排序算法，可以将一个整型数组按升序排列。
这段代码接受三个参数，分别是整型数组 `arr`、左端点 `left` 和右端点 `right`。
该代码的处理流程如下：1. 获取一个基准元素 `pivot`，从当前序列的中间位置开始选择。
2. 将该序列分成两个部分，其中左半部分的所有元素都小于等于基准元素，右半部分的所有元素都大于等于基准元素。
各种排序算法代码（C语言版）
各种排序算法代码（C语⾔版）选择排序#include <stdio.h>/** 选择排序* 稳定性：不稳定* 时间复杂度：O(N^2)**/void select_sort(int a[], int l, int r){for (int m_v, m_idx, t, i = l; i < r; ++i) {m_v = a[i]; m_idx = i;for (int j = i + 1; j < r; ++j) {if (m_v > a[j]) {m_v = a[j];m_idx = j;}}t = a[i]; a[i] = a[m_idx]; a[m_idx] = t;}}int main(void){int a[100];int n; scanf("%d", &n);for (int i = 0; i < n; ++i) scanf("%d", &a[i]);select_sort(a, 0, n);for (int i = 0; i < n; ++i) printf("%d ", a[i]);return0;}冒泡排序#include <stdio.h>/** 冒泡排序* 稳定性：稳定void bubble_sort(int a[], int l, int r){for (int i = l; i < r; ++i) {for (int j = l; j < r - i - 1; ++j) {if (a[j] > a[j + 1]) {int tmp = a[j];a[j] = a[j + 1];a[j + 1] = tmp;}}}}int main(void){int a[100];int n; scanf("%d", &n);for (int i = 0; i < n; ++i) scanf("%d", &a[i]); bubble_sort(a, 0, n);for (int i = 0; i < n; ++i) printf("%d ", a[i]);return0;}插⼊排序#include <stdio.h>/** 插⼊排序* 稳定性：稳定* 时间复杂度： O(N^2)**/void insert_sort(int a[], int l, int r){for (int tmp, j, i = l + 1; i < r; ++i) {tmp = a[i], j = i - 1;while (j >= l && tmp < a[j]) a[j+1] = a[j--]; a[j+1] = tmp;}}int main(void){for (int i = 0; i < n; ++i) scanf("%d", &a[i]); insert_sort(a, 0, n);for (int i = 0; i < n; ++i) printf("%d ", a[i]);return0;}希尔排序#include <stdio.h>/** 希尔排序* 稳定性：不稳定* 时间复杂度：O(N*logN)**/void shell_insert_sort(int a[], int l, int r, int d) {for (int tmp, j, i = l + d; i < r; ++i) {tmp = a[i], j = i - d;while (j >= l && tmp < a[j]) {a[j + d] = a[j];j -= d;}a[j + d] = tmp;}}void shell_sort(int a[], int l, int r){int d = (r - l) / 2;while (d >= 1) {shell_insert_sort(a, l, r, d);d /= 2;}}int main(void){int a[100];int n; scanf("%d", &n);for (int i = 0; i < n; ++i) scanf("%d", &a[i]); shell_sort(a, 0, n);for (int i = 0; i < n; ++i) printf("%d ", a[i]);归并排序/** 归并排序* 稳定性：稳定* 时间复杂度：O(N*logN)**/void merge(int a[], int n, int b[], int m, int t[]) {int i, j, k;i = j = k = 0;while (i < n && j < m) {if (a[i] < b[j]) t[k++] = a[i++];else t[k++] = b[j++];}while (i < n) t[k++] = a[i++];while (j < m) t[k++] = b[j++];}void my_merge_sort(int a[], int l, int r, int t[]) {int mid = (l + r) >> 1;int n = r - l;int i;if (l + 1 < r) {my_merge_sort(a, l, mid, t);my_merge_sort(a, mid, r, t);merge(a+l, mid-l, a+mid, r-mid, t);for (i = 0; i < n; ++i) a[i + l] = t[i];}}void merge_sort(int a[], int l, int r){int *t = (int *)malloc((r-l) * sizeof (int));my_merge_sort(a, l, r, t);free(t);}堆排序* 堆排序* 稳定性：不稳定* 时间复杂度：O(N*logN)**/// big top pilevoid heap_adjust(int a[], int fa, int n){int cd = fa * 2 + 1;while (cd < n) {if (cd + 1 < n && a[cd] < a[cd + 1]) cd++;if (a[fa] >= a[cd]) break;int tmp = a[fa];a[fa] = a[cd];fa = cd;cd = fa * 2 + 1;a[fa] = tmp;}}void build_heap(int a[], int n){// ignore leap nodefor (int i = (n - 1) / 2; i >= 0; --i) {heap_adjust(a, i, n);}}void heap_sort(int a[], int l, int r){build_heap(a + l, r - l);for (int tmp, i = r - 1; i > l; --i) {tmp = a[i]; a[i] = a[0]; a[0] = tmp;heap_adjust(a + l, 0, i);}}int main(void){int a[100];int n; scanf("%d", &n);for (int i = 0; i < n; ++i) scanf("%d", &a[i]); heap_sort(a, 0, n);return0;}快速排序/** 快速排序* 稳定性：不稳定* 时间复杂度：O(N*logN)**/void quick_sort(int a[], int l, int r){if (l + 1 >= r) return ;int low = l, high = r;int key = a[l];while (low < high) {while (low < high && a[--high] >= key); a[low] = a[high];while (low < high && a[++low] < key); a[high] = a[low];}a[low] = key;quick_sort(a, l, low);quick_sort(a, low+1, r);}基数排序/** 基数排序* 稳定性：稳定* 时间复杂度：O(d(n+radix)) [d个关键码，关键码的取值范围为radix] **/int tmp[100000000];void radix_sort(int arr[], int beg, int ed){static int a[9] = {1, 10, 100, 1000, 10000, 100000, 1000000};int cnt[10]; // 0~9⼗个数字int digit = 0; // 最⼤位数for (int i = beg; i < ed; ++i)while (arr[i] / a[digit + 1] > 0) digit++;for (int idx = 0; idx <= digit; ++idx) {for (int i = 0; i < 10; ++i) cnt[i] = 0; // 桶计数清零for (int i = beg; i < ed; ++i) cnt[ arr[i]/a[idx]%10 ]++; // 统计每个数字出现的次数// 前缀和统计每个数字前⾯的数字个数这样就可以知道每个数字应该排在第⼏位了for (int i = 1; i < 10; ++i) cnt[i] += cnt[i - 1];for (int i = ed - 1; i >= beg; --i) tmp[ --cnt[arr[i]/a[idx]%10] ] = arr[i];for (int i = beg, j = 0; i < ed; ++i, ++j) arr[i] = tmp[j];}}测试性能int a[100000000];double test(void(*fun)(int*, int, int), int range){for (int i = 0; i < range; ++i) a[i] = rand();clock_t start = clock();fun(a, 0, range);clock_t finish = clock();//for (int i = 0; i < range; ++i) printf("%d\n", a[i]);return ((double)finish - start) / CLOCKS_PER_SEC;}int main(){srand((unsigned)time(NULL));printf(" 数据范围堆排序归并排序希尔排序快速排序插⼊排序冒泡排序选择排序基数排序\n");for (int range = 100; range <= 100000; range *= 10) {printf("%9d %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f\n", range, test(heap_sort, range), test(merge_sort, range), test(shell_sort, range), test(quick_sort, range), test(insert_sort, range), test(bubble_sort, range), test(select_sort, range), test(radix_sort, range));}for (int range = 1000000; range <= 10000000; range *= 10) {printf("%9d %8.3f %8.3f %8.3f %8.3f %8.3f\n", range, test(heap_sort, range), test(merge_sort, range), test(shell_sort, range),test(quick_sort, range), test(radix_sort, range));}return0;。
c语言面试中常问的算法题目
c语言面试中常问的算法题目
在 C 语言面试中，常常会涉及一些算法题目，以下是一些常见
的算法题目及其解答：
1. 反转字符串：
题目，给定一个字符串，将其反转。
解答，可以使用两个指针，一个指向字符串的起始位置，另
一个指向字符串的末尾位置，然后交换两个指针所指向的字符，然
后两个指针向中间移动，重复这个过程直到两个指针相遇。
2. 判断字符串是否为回文串：
题目，给定一个字符串，判断它是否是回文串（正读和反读
都相同）。
解答，可以使用两个指针，一个指向字符串的起始位置，另
一个指向字符串的末尾位置，然后逐个比较两个指针所指向的字符，如果不相等则不是回文串。
3. 查找数组中的最大值和最小值：
题目，给定一个整数数组，找出数组中的最大值和最小值。
解答，可以使用两个变量分别保存当前的最大值和最小值，然后遍历数组，逐个比较并更新最大值和最小值。
4. 实现快速排序算法：
题目，给定一个整数数组，使用快速排序算法对数组进行排序。
解答，快速排序算法的基本思想是选择一个基准元素，将数组分为两部分，一部分小于基准元素，一部分大于基准元素，然后递归地对两部分进行排序。
5. 判断一个数是否为素数：
题目，给定一个整数，判断它是否为素数（只能被 1 和自身整除）。
解答，可以使用循环遍历从 2 到该数的平方根，逐个判断是否能整除该数，如果能整除则不是素数。
以上是一些常见的在 C 语言面试中经常被问到的算法题目及其解答。
当然，还有很多其他的算法题目，希望这些题目能帮助您更好地准备面试。
无序中位数 c语言
无序中位数 c语言无序中位数是指在一个无序数组中，位于中间位置的元素。
对于一个含有奇数个元素的无序数组，中位数就是数组中间位置的元素；对于一个含有偶数个元素的无序数组，中位数是位于中间位置两个元素的平均值。
要找到无序中位数，首先需要对数组进行排序。
常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等。
下面以快速排序为例，介绍如何找到无序中位数。
快速排序的基本思想是通过一趟排序将待排序的数组分割成独立的两部分，其中一部分的所有元素都比另一部分的所有元素小。
然后再按此方法对这两部分分别进行快速排序，最终整个序列就有序了。
具体步骤如下：1. 选取一个基准元素，可以选择数组的第一个元素作为基准。
2. 将数组分成两部分，使得左边的元素都小于等于基准元素，右边的元素都大于等于基准元素。
3. 对左右两部分递归地进行快速排序。
4. 当左右两部分都有序时，整个数组就有序了。
在快速排序的过程中，可以通过比较基准元素的位置和数组长度的关系来确定中位数的位置。
若基准元素的位置恰好是数组长度的一半，则该基准元素就是中位数；若基准元素的位置小于数组长度的一半，则中位数位于右半部分；若基准元素的位置大于数组长度的一半，则中位数位于左半部分。
下面是使用C语言实现的快速排序算法代码：```c#include <stdio.h>// 交换数组中的两个元素void swap(int* a, int* b) {int temp = *a;*a = *b;*b = temp;}// 快速排序void quickSort(int arr[], int low, int high) {if (low < high) {int pivot = arr[low]; // 选取第一个元素作为基准int i = low, j = high;while (i < j) {while (i < j && arr[j] >= pivot) {j--;}while (i < j && arr[i] <= pivot) {i++;}if (i < j) {swap(&arr[i], &arr[j]);}}swap(&arr[low], &arr[i]); // 将基准元素放到正确的位置 quickSort(arr, low, i - 1); // 递归处理左半部分quickSort(arr, i + 1, high); // 递归处理右半部分}}// 打印数组void printArray(int arr[], int size) {for (int i = 0; i < size; i++) {printf("%d ", arr[i]);}printf("\n");}int main() {int arr[] = {9, 2, 7, 6, 3, 1, 5, 4, 8};int size = sizeof(arr) / sizeof(arr[0]);printf("原数组：");printArray(arr, size);quickSort(arr, 0, size - 1);printf("排序后的数组：");printArray(arr, size);int median;if (size % 2 == 0) {median = (arr[size / 2 - 1] + arr[size / 2]) / 2; // 偶数个元素取中间两个元素的平均值} else {median = arr[size / 2]; // 奇数个元素取中间元素}printf("中位数：%d\n", median);return 0;}```以上代码实现了快速排序算法，并找到了无序数组的中位数。
CC++实现快速排序算法的思路及原理解析
CC++实现快速排序算法的思路及原理解析⽬录快速排序2. 实现原理3. 动态演⽰4. 完整代码5. 结果展⽰6. 算法分析快速排序1. 算法思想快速排序的基本思想：通过⼀趟排序将待排记录分隔成独⽴的两部分，其中⼀部分记录的关键字均⽐另⼀部分的关键字⼩，则可分别对这两部分记录继续进⾏排序，以达到整个序列有序。
2. 实现原理2.1、设置两个变量 low、high，排序开始时：low=0，high=size-1。
2.2、整个数组找基准正确位置，所有元素⽐基准值⼩的摆放在基准前⾯，所有元素⽐基准值⼤的摆在基准的后⾯默认数组的第⼀个数为基准数据，赋值给key，即key=array[low]。
因为默认数组的第⼀个数为基准，所以从后⾯开始向前搜索（high–），找到第⼀个⼩于key的array[high]，就将 array[high] 赋给 array[low]，即 array[low] = array[high]。
（循环条件是 array[high] >= key；结束时 array[high] < key）此时从前⾯开始向后搜索（low++），找到第⼀个⼤于key的array[low]，就将 array[low] 赋给 array[high]，即 array[high] = array[low]。
（循环条件是 array[low] <= key；结束时 array[low] > key）循环 2-3 步骤，直到 low=high，该位置就是基准位置。
把基准数据赋给当前位置。
2.3、第⼀趟找到的基准位置，作为下⼀趟的分界点。
2.4、递归调⽤（recursive）分界点前和分界点后的⼦数组排序，重复2.2、2.3、2.4的步骤。
2.5、最终就会得到排序好的数组。
3. 动态演⽰4. 完整代码三个函数基准插⼊函数：int getStandard(int array[],int low,int high)（返回基准位置下标）递归排序函数：void quickSort(int array[],int low,int high)主函数：int main()#include <stdio.h>#include <stdlib.h>void display(int* array, int size) {for (int i = 0; i < size; i++) {printf("%d ", array[i]);}printf("\n");}int getStandard(int array[], int i, int j) {// 基准数据int key = array[i];while (i < j) {// 因为默认基准是从左边开始，所以从右边开始⽐较// 当队尾的元素⼤于等于基准数据时,就⼀直向前挪动 j 指针while (i < j && array[j] >= key) {j--;}// 当找到⽐ array[i] ⼩的时，就把后⾯的值 array[j] 赋给它if (i < j) {array[i] = array[j];}// 当队⾸元素⼩于等于基准数据时,就⼀直向后挪动 i 指针while (i < j && array[i] <= key) {i++;}// 当找到⽐ array[j] ⼤的时，就把前⾯的值 array[i] 赋给它if (i < j) {array[j] = array[i];}}// 跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置// 把基准数据赋给正确位置array[i] = key;return i;}void QuickSort(int array[], int low, int high) {// 开始默认基准为 lowif (low < high) {// 分段位置下标int standard = getStandard(array, low, high);// 递归调⽤排序// 左边排序QuickSort(array, low, standard - 1);// 右边排序QuickSort(array, standard + 1, high);}}// 合并到⼀起快速排序// void QuickSort(int array[], int low, int high) {// if (low < high) {// int i = low;// int j = high;// int key = array[i];// while (i < j) {// while (i < j && array[j] >= key) {// j--;// }// if (i < j) {// array[i] = array[j];// }// while (i < j && array[i] <= key) {// i++;// }// if (i < j) {// array[j] = array[i];// }// }// array[i] = key;// QuickSort(array, low, i - 1);// QuickSort(array, i + 1, high);// }// }int main() {int array[] = {49, 38, 65, 97, 76, 13, 27, 49, 10};int size = sizeof(array) / sizeof(int);// 打印数据printf("%d \n", size);QuickSort(array, 0, size - 1);display(array, size);// int size = 20;// int array[20] = {0}; // 数组初始化// for (int i = 0; i < 10; i++) { // 数组个数// for (int j = 0; j < size; j++) { // 数组⼤⼩// array[j] = rand() % 1000; // 随机⽣成数⼤⼩ 0~999// }// printf("原来的数组：");// display(array, size);// QuickSort(array, 0, size - 1);// printf("排序后数组：");// display(array, size);// printf("\n");// }return 0;}5. 结果展⽰（递归调⽤，不好展⽰每次排序结果）6. 算法分析时间复杂度：最好： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)最坏： O ( n 2 ) O(n^2) O(n2)平均： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)空间复杂度： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)稳定性：不稳定到此这篇关于C/C++实现快速排序算法的思路及原理解析的⽂章就介绍到这了,更多相关C++实现快速排序算法内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
快速排序算法C++实现[评注版]
经常看到有人在网上发快速排序的算法，通常情况下这些人是在准备找工作，或者看<算法导论>这本书，而在他们发布的代码通常是差不多的版本，估计也是网上copy一下，自己改改，跑过了就算了，但是通常这样玩根本没有太大作用，如果到一家公司，给你一台不能上网的笔记本，20分钟，你是根本写不出来快速排序的算法的，当然
除了那些死记硬背的兄弟。
说说我写这篇文章的目的吧，记得有一天我想重新看看<算法导论>，看到快速排序我觉得很简单，于是按奈不住，想动手写写，可是写完了，在测试有些数据的时候总也过不去，于是我就想在网上找找按照<算法导论>的提示逻辑写成的快速排序，但是很是失望，网上差不多都是同一个版本，而且不是我想要的，于是有了本文。
为了让本文自成体系，先看看什么是快速排序，快速排序是一种排序算法。
在平均状况下，排序n 个项目要Ο(n log n)次比较。
在最坏状况下则需要Ο(n2)次比较，但这种况并不常见。
事实上，快速排序通常明显比其他Ο(n log n)演算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实作出来，且在大部分真实世界的资料，可以决定设计的选择，减少所需时间的二次方项之可能性。
首先让我们来看看<算法导论>上面的算法逻辑
QUICKSORT(A, p, r)//快速排序算法
if (p < r )
{
q = PARTITION(A, p, r)//分成左右两半，一半不大于
A[r], 一半不小于A[r]
QUICKSORT(A, p, q-1)//递归左半
QUICKSORT(A, q+1, r) //递归右半
}
PARTITION(A, p, r)
x = A[r]//选择最后一个元素作为比较元素
i = p – 1//这个慢速移动下标必须设定为比最小下表p小1，否则两个元素的序列比如2，1无法交换
for j = p to r-1//遍历每个元素
{
if (A[j] <=x)//比较
{
i = i + 1//移动慢速下标
Exchange A[i] with A[j ]//交换
}
}
Exchange A[i+1] with A[r]//交换
return i + 1//返回分割点
一次完整的比较过程如下图：
算法导论快速排序逻辑C++实现
//Data swop function
void Swap(int &p,int &q)
{
int temp = p;
p=q;
q=temp;
}
//Partition function
int Partition(int ArrayInput[],int nLow,int nHigh) {
int nTemp=ArrayInput[nHigh];
int i = nLow, j=nLow-1;
for(; i<nHigh; i++)
{
if( ArrayInput[i]<=nTemp )
{
j++;
if(i !=j )
{
Swap(ArrayInput[i], ArrayInput[j]);
}
}
}
Swap(ArrayInput[j+1],ArrayInput[nHigh]);
return (j+1);
}
//Quick sort
void Quick_sort(int ArrayInput[],int nLow,int nHigh) {
if(nLow < nHigh)
{
int nIndex=Partition(ArrayInput , nLow,
nHigh);
Quick_sort(ArrayInput , nLow,
nIndex-1);
Quick_sort(ArrayInput , nIndex+1,
nHigh);
}
}
总结
本文对<算法导论>的快速排序算法实现的关键点进行了详细的阐述，另外，本文给出了严格按照，<算法导论>快速排序算法逻辑实现的C++快速排序算法，希望对大家有所帮助。