快速排序算法

快速排序（Quicksort）是一种分治算法，通过不断交换数组中的元素使得数组变得有序。它的基本思想是选择一个基准元素，将数组分为两个部分，使得左边的部分的所有元素都小于等于基准元素，右边的部分的所有元素都大于等于基准元素，然后递归地排序两个子数组。快速排序是通常被认为是最快的内部排序算法之一。

C实现：

#include 

// 交换两个整数
void swap(int *a, int *b) {
  int temp = *a;
  *a = *b;
  *b = temp;
}

// 分区操作
int partition(int array[], int low, int high) {
  int pivot = array[high];  // 设置最后一个元素为基准元素
  int i = low - 1;  // i 用来记录小于基准元素的元素的最后一个位置
  for (int j = low; j <= high - 1; j++) {
    // 如果当前元素小于等于基准元素
    if (array[j] <= pivot) {
      i++;  // i 加 1
      swap(&array[i], &array[j]);  // 交换两个元素的位置
    }
  }
  swap(&array[i + 1], &array[high]);  // 最后把基准元素放到它的正确位置
  return (i + 1);
}

// 快速排序函数
void quickSort(int array[], int low, int high) {
  if (low < high) {  // 当 low >= high 时递归结束
    int pi = partition(array, low, high);  // 获取分区点
    quickSort(array, low, pi - 1);  // 递归处理左半边
    quickSort(array, pi + 1, high);  // 递归处理右半边
  }
}

// 打印数组
void printArray(int array[], int size) {
  for (int i = 0; i < size; i++) {
    printf("%d ", array[i]);
  }
  printf("\n");
}

int main() {
  int array[] = {10, 7, 8, 9, 1, 5};
  int n = sizeof(array) / sizeof(array[0]);
  quickSort(array, 0, n - 1);  // 快速排序
  printf("Sorted array: \n");
  printArray(array, n);  // 打印排序后的数组
  return 0;
}

python实现：

def quick_sort(arr):
    # 如果数组长度不大于 1，直接返回数组
    if len(arr) <= 1:
        return arr
    
    # 定义 pivot 为数组的中间元素
    pivot = arr[len(arr) // 2]
    
    # 将数组分为三部分：小于 pivot 的元素，等于 pivot 的元素，大于 pivot 的元素
    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)

go实现

package main

import "fmt"

func main() {
    arr := []int{9, 8, 7, 6, 5, 4, 3, 2, 1}
    quickSort(arr, 0, len(arr) - 1)
    fmt.Println(arr)
}

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

func partition(arr []int, low, high int) int {
    pivot := arr[high]
    i := low - 1
    for j := low; j <= high - 1; 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
}