排序算法（六）：快速排序

        快速排序（Quick Sort）是一种分治的排序算法。它的思想是选择数组中的一个元素作为基准数（pivot），然后将数组中所有其他元素与基准数进行比较，并根据比较结果将其放在基准数的左边或右边，最后对左右两个子数组分别进行递归排序。

快速排序的步骤如下：

1. 选择一个元素作为基准数（pivot）。
2. 重新排序数组，将所有小于基准数的元素放在基准数的左边，所有大于基准数的元素放在基准数的右边。
3. 对基准数左边和右边的子数组分别进行递归排序。
4. 重复步骤 2 和 3，直到子数组的长度为 1 或者为空。

动画演示

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

C语言

#include <stdio.h>

/* 快速排序函数 */
int QuickSort(int *a, int low, int high){
	
	// 定义基准数，记录队列的始末。（i第一位，j最后一位）
	int i = low;
	int j = high;
	int pivot = a[i];
 
	while (i < j){	
		
		// 从右向左找第一个小于等于基准数的数
		while(i < j && a[j] >= pivot)
			j--;
		a[i] = a[j];
 
		// 从左向右找第一个大于基准数的数
		while(i < j && a[i] < pivot)
			i++;
		a[j] = a[i];
	}

	// 将基准数赋值给 a[i]
	a[i] = pivot;

	// 排序左半部分
	if (i-1 > low)
		QuickSort(a, low, i-1);
	
	// 排序右半部分
	if (i+1 < high)
		QuickSort(a, i+1, high);

	return 0;
} 

int main(int argc, const char *argv[]){

    int a[] = {8, 45, 0, 30, 49, 16, 20, 20}; 
	int n = sizeof(a) / sizeof(a[0]); // 求数组长度
	int i;

	printf("排序前的数组：");
	for(i = 0; i < n; i++)
		printf("%d ", a[i]);
    putchar(10);
 
	QuickSort(a, 0, n-1);
	
	printf("排序后的数组：");
	for(i = 0; i < n; i++)
		printf("%d ", a[i]);
	
	return 0;
}

C++

        可以将C语言的头文件和主函数输出部分直接改成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) {

	// 选择最后一个元素作为基准数，i指向小于等于基准数的最后一个元素
    int pivot = arr[high];
    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(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);
    }
}

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

int main() {
    vector<int> arr = {8, 45, 0, 30, 49, 16, 20, 20};
    int n = arr.size();

    cout << "排序前的数组：";
    PrintArray(arr, n);

    QuickSort(arr, 0, n - 1);

    cout << "排序后的数组：";
    PrintArray(arr, n);

    return 0;
}

 Python

''' 快速排序函数 '''
def QuickSort(arr):

    # 如果数组长度小于或等于1，则直接输出
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[len(arr) // 2] # 选择数组的中间元素作为基准数
        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 quick_sort(left) + middle + quick_sort(right)

arr = [8, 45, 0, 30, 49, 16, 20, 20]

print("排序前的数组：", ' '.join(map(str, arr)))
arr = QuickSort(arr)
print("排序后的数组：", ' '.join(map(str, arr)))

Java

public class Quick_Sort {

	/* 快速排序函数 */
    public static void QuickSort(int[] arr, int left, int right) {
		
		// 如果队首元素小于队尾元素
        if (left < right) {
			
			// 定义基准数，记录队列的始末
            int pivot = arr[left];
            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;
 
            QuickSort(arr, begin, left - 1);
            QuickSort(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();
			
        QuickSort(arr, left, right);
		
		System.out.print("排序后的数组：");
        for (int i : arr)
            System.out.print(i+" ");
    }
}