【保姆级教学】快速排序代码及细节解析（多语言版本）

原创已于 2025-11-17 13:38:33 修改 · 256 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法 #算法 #数据结构 #java #后端 #c++ #python

于 2025-11-17 13:37:44 首次发布

「C++ 40 周年」主题征文大赛（有机会与C++之父现场交流！） 10w+人浏览 457人参与

什么是快速排序？

快速排序（Quick Sort）是一种高效的排序算法，由英国计算机科学家 Tony Hoare 在 1960 年提出。它采用了分治策略，平均时间复杂度为 O(n log n)，在实际应用中表现优异，同时也是各大互联网企业考核面试者代码能力是否扎实的高频考点。

快速排序的核心思想

快速排序的基本思想可以概括为三个步骤：

选择基准：从数组中选择一个元素作为"基准"（pivot）
分区操作：重新排列数组，使得所有比基准小的元素都在基准前面，所有比基准大的元素都在基准后面
递归排序：递归地对基准前后的子数组进行排序

完整代码实现

C语言代码

#include <stdio.h>

// 交换两个元素的值
void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 分区函数 - 快速排序的核心
int partition(int arr[], int low, int high) {
    // 选择最右边的元素作为基准
    int pivot = arr[high];
    
    // i 指向小于基准的区域的边界
    int i = (low - 1);
    
    for (int j = low; j <= high - 1; j++) {
        // 如果当前元素小于或等于基准
        if (arr[j] <= pivot) {
            i++; // 扩展小于基准的区域
            swap(&arr[i], &arr[j]); // 将当前元素放到正确区域
        }
    }
    
    // 将基准放到正确位置
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

// 快速排序主函数
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        // pi 是分区索引，arr[pi] 现在在正确位置
        int pi = partition(arr, low, high);
        
        // 递归排序分区前后的子数组
        quickSort(arr, low, pi - 1);  // 排序左半部分
        quickSort(arr, pi + 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[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    printf("原始数组: ");
    printArray(arr, n);
    
    quickSort(arr, 0, n - 1);
    
    printf("排序后数组: ");
    printArray(arr, n);
    
    return 0;
}

代码细节解析

1. 分区函数 `partition` 详解

分区函数是快速排序的核心，让我们通过一个具体例子来理解：

假设数组为：[10, 7, 8, 9, 1, 5]，选择最后一个元素 5 作为基准。

执行过程：

初始: [10, 7, 8, 9, 1, 5], i = -1, pivot = 5

j=0: 10 > 5, 不交换 → [10, 7, 8, 9, 1, 5], i = -1
j=1: 7 > 5, 不交换 → [10, 7, 8, 9, 1, 5], i = -1  
j=2: 8 > 5, 不交换 → [10, 7, 8, 9, 1, 5], i = -1
j=3: 9 > 5, 不交换 → [10, 7, 8, 9, 1, 5], i = -1
j=4: 1 <= 5, i=0, 交换arr[0]和arr[4] → [1, 7, 8, 9, 10, 5]

循环结束，交换arr[i+1]和arr[high] → [1, 5, 8, 9, 10, 7]

关键点理解：

i 总是指向最后一个小于等于基准的元素
当找到比基准小的元素时，先移动 i，然后交换
最后将基准放到正确位置 i+1

2. 递归过程解析

对于数组 [1, 5, 8, 9, 10, 7]，第一次分区后基准 5 在位置 1：

左子数组：[1]（已排序）
右子数组：[8, 9, 10, 7]

然后对右子数组递归排序：

[8, 9, 10, 7] 选择 7 作为基准
分区后： [7, 9, 10, 8]
继续递归...

3. 边界条件处理

if (low < high) {
    // 只有数组至少有两个元素时才排序
}

这个条件确保了递归能够正确终止。当子数组只有一个元素时（low == high），不需要继续排序。

优化技巧

1. 三数取中法选择基准

// 优化版的选择基准方法
int choosePivot(int arr[], int low, int high) {
    int mid = low + (high - low) / 2;
    
    // 对左、中、右三个元素排序，取中间值
    if (arr[low] > arr[mid])
        swap(&arr[low], &arr[mid]);
    if (arr[low] > arr[high])
        swap(&arr[low], &arr[high]);
    if (arr[mid] > arr[high])
        swap(&arr[mid], &arr[high]);
    
    // 将中间值放到倒数第二个位置
    swap(&arr[mid], &arr[high - 1]);
    return arr[high - 1];
}

2. 小数组使用插入排序

void quickSortOptimized(int arr[], int low, int high) {
    // 对于小数组，使用插入排序效率更高
    if (high - low + 1 <= 10) {
        insertionSort(arr, low, high);
        return;
    }
    
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSortOptimized(arr, low, pi - 1);
        quickSortOptimized(arr, pi + 1, high);
    }
}

复杂度分析

最好情况：O(n log n) - 每次分区都很平衡
平均情况：O(n log n)
最坏情况：O(n²) - 每次分区都极不平衡
空间复杂度：O(log n) - 递归调用栈

其他语言版本

C++实现

#include <iostream>
#include <vector>
using namespace std;

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int partition(vector<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++;
            swap(arr[i], arr[j]);
        }
    }
    
    swap(arr[i + 1], arr[high]);
    return i + 1;
}

void quickSort(vector<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);
    }
}

Java实现

public class QuickSort {
    public static 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);
        }
    }
    
    private static 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++;
                swap(arr, i, j);
            }
        }
        
        swap(arr, i + 1, high);
        return i + 1;
    }
    
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

Python实现

def quick_sort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)
        quick_sort(arr, low, pi - 1)
        quick_sort(arr, pi + 1, high)

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    
    for j in range(low, high):
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    
    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 1

Go 实现

func quickSort(arr []int, low int, high int) {
    if low < high {
        pi := partition(arr, low, high)
        quickSort(arr, low, pi-1)
        quickSort(arr, pi+1, high)
    }
}

func partition(arr []int, low int, high int) int {
    pivot := arr[high]
    i := low - 1
    
    for j := low; j < high; j++ {
        if arr[j] <= pivot {
            i++
            arr[i], arr[j] = arr[j], arr[i]
        }
    }
    
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i + 1
}

JavaScript 实现

function quickSort(arr, low, high) {
    if (low < high) {
        let pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

function partition(arr, low, high) {
    let pivot = arr[high];
    let i = low - 1;
    
    for (let j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            [arr[i], arr[j]] = [arr[j], arr[i]];
        }
    }
    
    [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
    return i + 1;
}