排序-快速排序算法

快速排序算法

第一步：实现分区函数

根据题目中的“快速排序”，我们需要实现一个分区函数，这个功能的实现：

1. 设定基准值 pivot。
2. 使用两个指针 low 和 high，分别从数组的两端向中间移动，进行元素交换。

int part(int A[], int low, int high){
    int pivot = A[low]; // 设定基准值
    while (low < high) { // 循环直到两个指针相遇
        while (low < high && A[high] >= pivot) // 从右边开始向左找第一个小于pivot的数
            --high;
        A[low] = A[high]; // 将找到的数放到左边
        while (low < high && A[low] <= pivot) // 从左边开始向右找第一个大于pivot的数
            ++low;
        A[high] = A[low]; // 将找到的数放到右边
    }
    A[low] = pivot; // 将基准值放到中间
    return low; // 返回基准值的位置
}

第二步：实现快速排序函数

根据题目中的“快速排序”，我们需要递归地对分区后的子数组进行排序。

void Quicksort(int A[], int low, int high){
    if (low < high) { // 如果子数组长度大于1，则继续排序
        int pivotpos = part(A, low, high); // 调用分区函数
        Quicksort(A, low, pivotpos - 1); // 对左子数组排序
        Quicksort(A, pivotpos + 1, high); // 对右子数组排序
    }
}

代码注释

// 分区函数，用于快速排序
int part(int A[], int low, int high) {
    int pivot = A[low]; // 选择最左边的元素作为基准值
    while (low < high) { // 当两个指针没有相遇时继续
        while (low < high && A[high] >= pivot) // 从右向左找第一个小于基准值的元素
            --high;
        A[low] = A[high]; // 将找到的元素放到左边
        while (low < high && A[low] <= pivot) // 从左向右找第一个大于基准值的元素
            ++low;
        A[high] = A[low]; // 将找到的元素放到右边
    }
    A[low] = pivot; // 将基准值放到中间
    return low; // 返回基准值的位置
}

// 快速排序函数
void Quicksort(int A[], int low, int high) {
    if (low < high) { // 如果数组长度大于1，则继续排序
        int pivotpos = part(A, low, high); // 获取基准值的位置
        Quicksort(A, low, pivotpos - 1); // 对左边的子数组进行快速排序
        Quicksort(A, pivotpos + 1, high); // 对右边的子数组进行快速排序
    }
}

求解过程：

1. 选择基准：选择数组中的一个元素作为基准（pivot），通常选择第一个元素或最后一个元素。
2. 分区：将数组分为两部分，一部分包含小于基准的元素，另一部分包含大于或等于基准的元素。

图解求解过程

假设数组为arr[]，数组长度为n，目标是找到第k小的元素。以下是通过分治法求解过程的图解：

初始数组

[49, 38, 65, 97, 76, 13, 27]

交换元素和被交换元素用**表示

第一次递归调用

• start = 0, end = 6, k = 4
• 选择基准为 a[start] = 49
  (start=low ,end=high)

交换过程

1. 选择基准：基准为 49
2. 初始化指针：i = start = 0，j = end = 6
3. 开始循环：
   • 从右向左找到第一个小于基准的元素：j 从 j=6 开始，找到 27（小于 49），把27交换到 a[i]的位置，i=0。

[49,     38, 65, 97, 76, 13,  27,]原来的
[*27*,   38, 65, 97, 76, 13,       ]交换后   49
                                            | (基准)

4. 继续循环：
   • 从左向右找到第一个大于基准的元素：i 从 i=0 开始，找到 65（大于 49），65交换到 a[j],j=6。

[27,   38,    , 97, 76, 13, *65*]      49
                                      | (基准)

5. 继续循环：
   • 从右向左找到第一个小于基准的元素：j 从 j=6 开始，找到 13（小于 49），把13交换到 a[i],i=2。

[27,   38,  *13* , 97, 76,    , 65]      49
                                         | (基准)

6. 继续循环：
   • 从左向右找到第一个大于基准的元素：i 从 i=2 开始，找到 97（大于 49），把97交换到 a[5],j=5。

[27,   38,  13,   , 76, *97* , 65]      49
                                         | (基准)

7. 循环结束：i 和 j 相遇，将基准放回其最终位置。

[27,   38,  13 , 49, 76, 97 , 65]      
                   | (基准)