算法重温：排序 —— 快速排序

Itempor

已于 2022-10-26 17:52:28 修改

阅读量165

点赞数 1

文章标签：算法 java 排序算法 1024程序员节

于 2022-10-15 13:58:01 首次发布

本文链接：https://blog.csdn.net/weixin_50553521/article/details/127334062

版权

1. 基本思想

通过一趟排序将待排序列分割成两部分，其中一部分记录的关键字均比另一部分记录的关键字小。之后分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

2. 排序原理

设定第一个数为基准数，以从小到大排序为例，给定两个下标，一左一右，从右往左遇到小于基准数的，右下标停下；从左往右遇到大于基准数的，左下标停下。左下标需保持小于右下标，然后交换两数，继续重复该过程，直到下标遭遇。遭遇位置即为基准数归位的位置，归位基准数后，将基准数两侧作为两个新的数组执行上述过程，即递归，直至所有数归位，数组有序。

3. 排序过程

以从小到大排列为例，设原数组 [23, 6, 45, 7, 93]
第一次归位基准数：23
从右到左找到小于基准数的，下标停在 7 的位置，下标为【3】
从左到右找到大于基准数的，下标停在 45 的位置，下标为【2】
交换，此时数组为[23, 6, 7, 45, 93]
从右到左找到小于基准数的，此时在下标相遇前没有找到，相遇下标为【2】
将基准数归位，此时数组为[7, 6, 23, 45, 93]
再对[7, 6]与[45, 93]重复上述步骤
先执行[7, 6]
第二次归位基准数：7
从右到左找到小于基准数的，下标停在6的位置，下标为【1】
从左到右找到大于基准数的，此时在下标相遇前没有找到，相遇下标为【1】
将基准数归位，此时左侧拆分数组为[6, 7]
左侧只有一个数值(left = right)，退出，右侧无数值(left > right)，退出
第三次归位基准数：45
从右到左找到小于基准数的，此时在下标相遇前没有找到，相遇下标为【3】
无变化，此时右侧拆分数组为[45, 93]
左侧无数值(left > right)，退出，右侧只有一个数值(left = right)，退出
至此，数组全部有序，为[6, 7, 23, 45, 93]

4.复杂度分析

平均时间复杂度	O(nlogn)
最好情况	O(nlogn)
最坏情况	O(n^2)
空间复杂度	O(logn)
稳定性	不稳定

5.代码实现 (C++、java)

PS：

在交换部分的代码，其实可以再加一句 j - - ，因为已经交换过的当前值必定是大于基准值的，无需再进行比较。为什么不能加 i + +，因为循环是先执行 j 这边的数，循环条件中有个 i < j，动 i 会导致 j 这边少判断一个数，从而出现排序错误。

但就算加了 j - - 也仅仅只少了一次判断，几乎没有优化，故为了代码美观易懂没必要加。

// c++
#include<iostream>
using namespace std;

void quickSort(int left, int right, int* a);
int main() {
	int n;
	cout << "请输入数组长度：";
	cin >> n;
	cout << "\n输入整数数组：";
	int* a = (int*)malloc(sizeof(int) * n);
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	quickSort(0, n - 1, a);
	cout << "\n排序后数组为：";
	for (int i = 0; i < n; i++) {
		cout << a[i] << " ";
	}
}

void quickSort(int left, int right, int* a) {
	if (left >= right) return;
	int i, j, t, temp;	// temp为基准数
	temp = a[left];		// 设置第一个元素为基准数
	i = left;
	j = right;
	while (i < j)
	{
		while (a[j] >= temp && i < j) j--;	// 从右到左找小于基准值的数
		while (a[i] <= temp && i < j) i++;	// 从左到右找大于基准值的数
		if (i < j) {	// 交换
			t = a[i]; a[i] = a[j]; a[j] = t;
		}
	}
	a[left] = a[i];	a[i] = temp;	// 将基准数归位
	quickSort(left, i - 1, a);		// 递归
	quickSort(i + 1, right, a);
	return;
}

// java
import java.util.Scanner;

public class Main {

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.print("请输入数组的长度：");
        int size = in.nextInt();
        int[] a = new int[size];
        System.out.println("请输入数组：");
        for(int i = 0; i < size; i++){
            a[i] = in.nextInt();
        }
        System.out.println("排序后数组：");
        quicksort(0,a.length-1,a);  // "-1"不要忘
        for(int k = 0; k < a.length; k++){
            System.out.print(a[k]+" ");
        }
    }
    // 快速排序
    public static void quicksort(int left,int right,int[] a){
        if(left >= right) return;
        int i,j,t,temp;
        temp = a[left];
        i = left;   j = right;
        while(i < j){
            while (a[j] >= temp && i < j) j--;
            while (a[i] <= temp && i < j) i++;
            if(i<j){
                t = a[i];   a[i] = a[j];    a[j] = t;
            }
        }
        a[left] = a[i];     a[i] = temp;
        quicksort(left,i-1,a);
        quicksort(i+1,right,a);
        return;
    }
}