多语言快速排序算法

快速排序是一种高效的排序算法，使用分治法策略。它的基本思想是：选择一个元素作为“基准”（pivot），重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的摆在基准的后面。在这个分区退出之后，该基准就处于数列的中间位置。这个过程称为分区（partition）操作。然后，递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
快速排序的时间复杂度：

• 平均情况（Average Case）：$O(n\log n)$

Java版快速排序

public class QuickSort {

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            quickSort(arr, low, pivotIndex - 1);  // 对基准左边的数组进行递归排序
            quickSort(arr, pivotIndex + 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;
    }

    public static void main(String args[]) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        int n = arr.length;
        quickSort(arr, 0, n - 1);
        System.out.println("Sorted array: ");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

Kotlin版快速排序

fun quickSort(arr: IntArray, low: Int, high: Int) {
    if (low < high) {
        val pi = partition(arr, low, high)
        quickSort(arr, low, pi - 1)
        quickSort(arr, pi + 1, high)
    }
}

fun partition(arr: IntArray, low: Int, high: Int): Int {
    val pivot = arr[high]
    var i = low - 1
    for (j in low until high) {
        if (arr[j] < pivot) {
            i++
            arr[i] = arr[j].also { arr[j] = arr[i] }
        }
    }
    arr[i + 1] = arr[high].also { arr[high] = arr[i + 1] }
    return i + 1
}

fun main() {
    val arr = intArrayOf(10, 7, 8, 9, 1, 5)
    val n = arr.size
    quickSort(arr, 0, n - 1)
    println("Sorted array: ${arr.joinToString(" ")}")
}

C版快速排序

#include <stdio.h>

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);
    }
}

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++;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1;
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quickSort(arr, 0, n - 1);
    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

C++版快速排序

#include <iostream>

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);
    }
}

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

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quickSort(arr, 0, n - 1);
    std::cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}

Dart版快速排序

void quickSort(List<int> arr, int low, int high) {
  if (low < high) {
    int pivotIndex = partition(arr, low, high);
    quickSort(arr, low, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, high);
  }
}

int partition(List<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;
}

void swap(List<int> arr, int i, int j) {
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

void main() {
  List<int> arr = [10, 7, 8, 9, 1, 5];
  quickSort(arr, 0, arr.length - 1);
  print("Sorted array: $arr");
}

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

function swap(arr, i, j) {
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

// 使用示例
let arr = [10, 7, 8, 9, 1, 5];
quickSort(arr, 0, arr.length - 1);
console.log("Sorted array:", arr);

汇编语言（Assembly Language asm）快速排序

以下是一个基本的 ARM 汇编语言快速排序算法示例，适用于运行 ARM 架构处理器的 Linux 系统。请注意，这个例子是针对 ARMv7 架构编写的，可能需要根据你的具体 ARM 架构版本做出调整。

.global quicksort

.data
array: .word 10, -1, 8, 3, 2, -5, 4
length: .word 7

.text
quicksort:
    push {r4-r11, lr}
    mov r1, #0
    ldr r2, =length
    ldr r2, [r2]
    subs r2, r2, #1
    bl partition
    pop {r4-r11, pc}

partition:
    push {r4-r11, lr}
    mov r11, r1
    mov r10, r0
    ldr r4, [r0, r2, lsl #2]
partition_loop:
    ldr r3, [r10, r11, lsl #2]
    cmp r3, r4
    addge r11, r11, #1
    blt swap
    cmp r11, r2
    blt partition_loop
    bl swap
    pop {r4-r11, pc}

swap:
    push {r4-r11, lr}
    ldr r3, [r10, r1, lsl #2]
    ldr r12, [r10, r11, lsl #2]
    str r12, [r10, r1, lsl #2]
    str r3, [r10, r11, lsl #2]
    pop {r4-r11, pc}

在这个示例中，quicksort 函数是快速排序算法的入口点，partition 是用于分区的函数，而 swap 函数用于交换数组中的两个元素。这些函数使用 ARM 寄存器和指令来处理数组中的元素，并执行排序算法的步骤。

要运行这个程序，你需要在支持 ARM 架构的 Linux 系统上使用适当的汇编器和链接器。在不同的 ARM 架构版本（如 ARMv6、ARMv8）上，可能需要进行语法或指令集的调整。

请注意，这只是一个基本的示例，可能需要进一步的优化和调整以适应特定的需求和环境。