排序算法（七）：随机快速排序

        随机快速排序（Randomized Quick Sort）是快速排序算法的一种变种，它的基本思想是通过随机选择基准数（pivot）来避免最坏情况的出现，从而提高算法的性能。

随机快速排序的步骤如下：

1. 选择一个随机元素作为基准数。
2. 将数组中小于等于基准数的元素放在基准数的左边，大于基准数的元素放在基准数的右边。
3. 对基准数左右两边的子数组分别进行递归快速排序。
4. 重复步骤 1-3，直到整个数组排序完成。

动画演示

下面为各编程语言实现随机快速排序的方法 

C语言

#include <stdio.h>
#include <stdlib.h>

/* 交换函数 */
int Swap(int* i, int* j){
	int temp = *i;
	*i = *j;
	*j = temp;
	return *i, *j;
}

/* 分区函数 */
int Partition(int a[], int l, int r){
    int i = l,j = r+1;
    int pivot = a[l];
    int swap;
	
    // 将小于基准数的元素放在左边，大于基准数的放在右边
    while(1){
        while(a[++i] < pivot && i < r);
        while(a[--j] > pivot);
        if(i >= j)
            break;
        Swap(&a[i], &a[j]);
    }
    a[l] = a[j];
    a[j] = pivot;
    return j;
}

/* 生成随机基准数 */
int GenerateRandomPivot(int a[], int l, int r){
    int pivot = rand() % (r-l+1)+l;
    int swap;
    Swap(&a[pivot], &a[l]);
    return Partition(a, l, r);
}

/* 随机快速排序函数 */
void RandomQuickSort(int a[], int l, int r){
    if(l < r){
        int p = GenerateRandomPivot(a, l, r); // 随机选择基准数
        RandomQuickSort(a, l, p-1); // 排序左半部分
        RandomQuickSort(a, p+1, r); // 排序右半部分
    }
}

/* 打印数组函数 */
void PrintArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ",arr[i]);
    }
    putchar(10);
}

int main(){
    int arr[]={8, 45, 0, 30, 49, 16, 20, 20};
	int n = sizeof(arr) / sizeof(arr[0]); // 求数组长度
    int i;
	
    printf("排序前的数组：");
    PrintArray(arr, n);
	
    RandomQuickSort(arr, 0, n-1);
	
    printf("排序后的数组：");
    PrintArray(arr, n);
	
	return 0;
}

C++

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

/* 交换函数 */
void Swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

/* 生成随机基准数 */
int GenerateRandomPivot(int low, int high) {
    random_device rd;
    mt19937 gen(rd());
    uniform_int_distribution<> dis(low, high);
    return dis(gen);
}

/* 分区函数 */
int Partition(vector<int>& arr, int low, int high) {
    int pivotIndex = GenerateRandomPivot(low, high);
    int pivot = arr[pivotIndex];

    Swap(&arr[pivotIndex], &arr[high]);

    int i = low;

    // 小于基准数的放在左边，大于基准数的放在右边
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] <= pivot) {
            Swap(&arr[i], &arr[j]);
            i++;
        }
    }

    Swap(&arr[i], &arr[high]);
    return i;
}

/* 随机快速排序函数 */
void RandomQuickSort(vector<int>& arr, int low, int high) {
    if (low < high) {
        int p = Partition(arr, low, high);
        RandomQuickSort(arr, low, p - 1); // 排序左半部分
        RandomQuickSort(arr, p + 1, high); // 排序右半部分
    }
}

int main() {
    vector<int> arr = {8, 45, 0, 30, 49, 16, 20, 20};
    int n = arr.size(); // 求数组长度

    cout << "排序前的数组：";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";

    RandomQuickSort(arr, 0, n - 1);

    cout << endl << "排序后的数组：";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";

    return 0;
}

Python

import random

''' 随机快速排序函数 '''
def RandomQuickSort(arr):

    # 如果数组长度小于或等于 1，则直接输出
    if len(arr) <= 1:
        return arr

    else:
        pivot = random.choice(arr) # 随机选择数组中的一个元素作为基准数
        left = [x for x in arr if x < pivot] # 创建存储小于基准数的元素的空数组
        middle = [x for x in arr if x == pivot] # 创建存储等于基准数的元素的空数组
        right = [x for x in arr if x > pivot] # 创建存储大于基准数的元素的空数组

        # 递归地对小于基准数和大于基准数的数组进行排序，并将排序后的数组与基准数组合起来
        return RandomQuickSort(left) + middle + RandomQuickSort(right)

arr = [8, 45, 0, 30, 49, 16, 20, 20]
print("排序前的数组：", ' '.join(map(str, arr)))
print("排序后的数组：", ' '.join(map(str, RandomQuickSort(arr))))

Java

        尝试拿快排的代码改，攻关了三天，还是失败了，先把半成品代码放这里，如果有解决方法欢迎私信。

import java.util.Random;
 
public class Random_Quick_Sort {
 
    /* 随机快速排序函数 */
    public static void RandomQuickSort(int[] arr, int left, int right) {
        
        // 如果队首元素小于队尾元素
        if (left < right) {
            
            // 随机选取基准数，记录队列的始末。
            int pivot = arr[left + new Random().nextInt(right - left + 1)];
            int begin = left;
            int end = right;
 
            while (right > left) {
 
                // 当队尾元素小于基准数就将队尾插到队首
                if (arr[right] < pivot) {
                    arr[left] = arr[right];
                    left++; // 队首索引后移
                } 
 
                // 当队尾元素大于基准数就将队尾索引前移，继续从队尾比较
                else {
                    right--;
                    continue;
                }
 
                while (right > left) {
                    
                    // 当队首元素大于基准数就将队首插到队尾
                    if (arr[left] > pivot) {
                        arr[right] = arr[left];
                        right--;// 队尾索引前移
                        break;
                    }
 
                    // 当队首元素小于基准数就将队首索引后移，继续从队首比较
                    else {
                        left++;
                    }
                }
            }
            
            // 队首和队尾索引重合，就将基准数插入此位置
            arr[left] = pivot;
 
            RandomQuickSort(arr, begin, left - 1);
            RandomQuickSort(arr, left + 1, end);
        }
    }
    
    public static void main(String[] args) {
        int[] arr = {8, 45, 0, 30, 49, 16, 20, 20};
        
        // 定义队首、队尾位置的索引
        int left = 0;
        int right = arr.length - 1;
        
        System.out.print("排序前的数组：");
        for (int i : arr)
            System.out.print(i+" ");
        System.out.println();
        
        RandomQuickSort(arr, left, right);
        
        System.out.print("排序后的数组：");
        for (int i : arr)
            System.out.print(i+" ");
    }
}