C++快速排序

目录

一、快速排序主函数

代码如下：

二、分区函数

1.选取支点

2.定义左右指针，移动指针

3.返回分割点的位置

代码如下：

三、swap函数——元素互换

代码如下：

四、printArr函数——打印输出

代码如下：

完整代码如下：

测试方法如下：

运行效果截图：

---

一、快速排序主函数

quickSort函数是快速排序算法的核心函数，用于对传入的整型数组arr进行排序。该函数使用递归的方式实现快速排序。

其中，strat和end参数表示当前需要排序的数组部分的起始和终止下标，而mid则表示当前数组的中间下标，即分区中心下标，由partition函数返回。在排序的过程中，如果当前子数组只有一个或没有元素，则不进行划分，排序直接结束。

如果需要划分数组，则调用partition函数进行分区，将数组分为左右两部分，将各自递归进行排序，直到排序完整个数组。具体实现中，先取数组第一个元素作为分区元素，然后使用while循环，寻找需要交换的元素，将其移动到正确位置，直到左右指针相遇，并将分区元素与左指针交换后返回中心点的位置。

整个排序过程中，每次递归调用快速排序函数时，都传入需要排序的子数组部分，并一次次划分成更小的子数组，最终得到排序好的有序数组。

代码如下：

1. // 定义快速排序函数，递归实现

2. void quickSort(int(&arr)[10], int strat, int end) {

3. // 前提条件

4. if (strat >= end)

5. return;

7. // 分区,返回分区下标

8. int mid = partition(arr, strat, end);

10. // 递归调用

11. quickSort(arr, strat, mid - 1);

12. quickSort(arr, mid + 1, end);

14. }

二、分区函数

1.选取支点

        函数中的第一步是将数组第一个元素作为支点（pivot）。

  int pivot = arr[strat];

2.定义左右指针，移动指针

        函数定义了两个指针 left 和 right，分别初始化为 strat 和 end。接下来，左右指针开始分别从左侧和右侧遍历数组arr，找到需要交换的元素并将其交换位置。

1. while (left < right) {

2. while (arr[left] <= pivot && left < right)

3. left++;

4. while (arr[right] >= pivot && left < right)

5. right--;

6. swap(arr, left, right);

7. }

• 第一个while循环，left指针一直往右移动，直到找到大于pivot与arr[right]应该交换的元素。
• 第二个while循环，right指针一直往左移动，直到找到小于pivot与arr[left]应该交换的元素。
• 交换操作放在循环外面，因为left和right相遇时，交换操作还会执行一次，但此时已经没有必要进行交换了。

3.返回分割点的位置

        通过left指针的位置来判断分割点的位置，left指针左侧的元素都小于pivot，右侧的元素都大于pivot。因此，判断left所指元素与pivot的大小关系，交换分割元素和left位置上的元素，更新分割点位置并返回。

1. if (arr[left] < pivot) {

2. // 将分割元素放到left指针指向的元素左边

3. swap(arr, strat, left);

4. return left;

5. } else if (arr[left] > pivot) {

6. // 将分割元素放到left指针指向的元素左边的前一个位置

7. swap(arr, strat, left - 1);

8. return left - 1;

9. }

• 在上面的代码中，如果left指向的元素小于支点pivot，则把pivot放在left之前，即交换arr[strat]和arr[left]的值。
• 如果left指向的元素大于支点，则把pivot放在left之前的位置，即交换arr[strat]和arr[left-1]的值。

代码如下：

1. // 数组分区

2. int partition(int(&arr)[10], int strat, int end) {

3. // 选取一个分区的-支点

4. int pivot = arr[strat];

6. // 左右指针指向

7. int left = strat, right = end;

9. while (left < right)

10. {

11. // 分别从左右两边遍历数组

12. while (arr[left] <= pivot && left < right)

13. left++;

14. while (arr[right] >= pivot && left < right)

15. right--;

17. // 交换左右指针的值

18. swap(arr, left, right);

19. }

21. if (arr[left] < pivot)

22. {

23. swap(arr, strat, left);

24. return left;

25. }

26. else if (arr[left] > pivot)

27. {

28. swap(arr, strat, left - 1);

29. return left - 1;

30. }

31. }

三、swap函数——元素互换

        函数是对一个整型数组中的两个元素进行交换的函数，作用是将输入的整型数组arr中下标为i和j的元素交换位置。函数接收一个整型数组arr，和两个整型参数i和j，表示需要交换的元素在数组中的下标。函数先用一个中间变量temp记录第i个元素的值，然后将第i和j个元素的值进行交换。

代码如下：

1. // 元素互换

2. void swap(int(&arr)[10],int i,int j) {

3. int temp = arr[i];

4. arr[i] = arr[j];

5. arr[j] = temp;

6. }

四、printArr函数——打印输出

        函数使用了 范围for 循环来遍历整型数组 arr，输出数组中每个元素的值。语句cout << num << '\t';会输出该元素后面跟着一个水平制表符\t，使得数组中每个元素的输出结果之间都会隔开一段距离，便于观察。函数输出一个换行符 cout << endl; ，使得下一次调用该函数输出内容不会和上一次输出结果粘在一起，以便输出更加整洁。

代码如下：

1. // 打印数组

2. void printArr(int(&arr)[10]) {

3. for (int num : arr)

4. cout << num << '\t';

5. cout << endl;

6. }

完整代码如下：

1. /*

2. * 快速排序

3. * @QuickSort()

4. */

6. // 定义快速排序函数，递归实现

7. void quickSort(int(&arr)[10], int strat, int end) {

8. // 前提条件

9. if (strat >= end)

10. return;

12. // 分区,返回分区下标

13. int mid = partition(arr, strat, end);

15. // 递归调用

16. quickSort(arr, strat, mid - 1);

17. quickSort(arr, mid + 1, end);

19. }

21. // 数组分区

22. int partition(int(&arr)[10], int strat, int end) {

23. // 选取一个分区的-支点

24. int pivot = arr[strat];

26. // 左右指针指向

27. int left = strat, right = end;

29. while (left < right)

30. {

31. // 分别从左右两边遍历数组

32. while (arr[left] <= pivot && left < right)

33. left++;

34. while (arr[right] >= pivot && left < right)

35. right--;

37. // 交换左右指针的值

38. swap(arr, left, right);

39. }

41. if (arr[left] < pivot)

42. {

43. swap(arr, strat, left);

44. return left;

45. }

46. else if (arr[left] > pivot)

47. {

48. swap(arr, strat, left - 1);

49. return left - 1;

50. }

51. }

53. // 元素互换

54. void swap(int(&arr)[10],int i,int j) {

55. int temp = arr[i];

56. arr[i] = arr[j];

57. arr[j] = temp;

58. }

60. // 打印数组

61. void printArr(int(&arr)[10]) {

62. for (int num : arr)

63. cout << num << '\t';

64. cout << endl;

65. }

测试方法如下：

1. #include<iostream>

2. using namespace std;

4. void quickSort(int(&arr)[10], int strat, int end);

5. int partition(int(&arr)[10], int strat, int end);

6. void swap(int(&arr)[10], int i, int j);

7. void printArr(int(&arr)[10]);

9. // 快速排序测试方法

10. void Test() {

11. int arr[10] = { 23, 45, 18, 6, 11, 19, 22, 18, 12, 9 };

12. printArr(arr);

13. int size = sizeof(arr) / sizeof(arr[0]);

14. quickSort(arr, 0, size - 1);

15. printArr(arr);

16. }