如何使用Go、Python、Java、Rust、C、JS等6种编程语言实现六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序

猫头虎

发布于 2025-03-16 20:40:24

7800

代码可运行

文章被收录于专栏：猫头虎博客专区猫头虎博客专区

运行总次数：0

代码可运行

使用Go、Python、Java、Rust、C、JS等6种编程语言实现六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序

排序算法是计算机科学中最基础也是最重要的概念之一。无论你是初学者还是资深开发者，理解并掌握排序算法对编程能力的提升至关重要。排序算法不仅是面试中的常见考题，它们在实际开发中也被广泛应用，例如在数据库查询、数据分析和大数据处理等领域。

在大规模数据处理时，排序算法的效率直接影响程序的运行速度和性能。随着数据量的增大，选择合适的排序算法将对优化系统性能起到决定性作用。因此，掌握多种排序算法，并能够根据具体场景选择最优的排序方法，对于每一位程序员来说都是必备的技能。

本文将深入解析并展示如何使用六种不同的编程语言（Go、Python、Java、Rust、C、JavaScript）实现六大经典排序算法，包括：插入排序、希尔排序、选择排序、冒泡排序、堆排序和快速排序。通过本教程，你将不仅能够理解这些算法的核心思想，还能掌握如何在多个流行的编程语言中实现它们。

我们将分别介绍每种排序算法的工作原理，提供代码示例，并在每种语言中展示如何实现。无论你是想提升自己的编程水平，还是在项目中优化排序性能，这篇文章都将为你提供实用的技巧和指导。

为什么要学习这些排序算法？

提高编程能力：排序算法是计算机科学中的基础算法，掌握这些算法将让你在编程中游刃有余。
优化性能：不同的排序算法具有不同的时间复杂度，在面对大数据时，选择合适的排序算法能显著提高程序的效率。
面试必备：排序算法是许多技术面试中的经典题目，掌握这些算法将帮助你顺利通过面试。
灵活运用：排序算法不仅限于数据排序，还可以应用于问题求解、搜索优化等场景，具备灵活运用能力的开发者更具竞争力。

本文适合哪些人群？

初学者：如果你刚开始学习编程，本文将帮助你了解不同编程语言中的排序算法实现，提升你的算法基础。
中高级开发者：对于已经具备一定编程基础的开发者，本文将帮助你深入了解不同排序算法的实现方式，并掌握如何在多个语言中灵活使用。
求职者：如果你正在准备技术面试，掌握常见的排序算法是面试准备的基础，本文为你提供了丰富的参考和实战代码。

通过本文的学习，你将掌握如何用Go、Python、Java、Rust、C、JavaScript等6种编程语言实现经典排序算法，提升你在数据处理、算法设计等方面的能力。无论你是学习算法、优化程序，还是准备面试，本文都将为你提供必要的帮助与支持。

接下来，我们将依次讲解每一种排序算法，并提供相应的代码实现，帮助你更好地理解和应用这些经典算法。

正文

1. 插入排序（Insertion Sort）

插入排序是一种简单的排序算法，它的基本思想是通过将元素插入到已排序的部分来实现排序。

插入排序的伪代码

for i from 1 to length of array:
    key = array[i]
    j = i - 1
    while j >= 0 and array[j] > key:
        array[j + 1] = array[j]
        j -= 1
    array[j + 1] = key

Go语言实现插入排序

package main

import "fmt"

func insertionSort(arr []int) {
	for i := 1; i < len(arr); i++ {
		key := arr[i]
		j := i - 1
		for j >= 0 && arr[j] > key {
			arr[j+1] = arr[j]
			j--
		}
		arr[j+1] = key
	}
}

func main() {
	arr := []int{12, 11, 13, 5, 6}
	insertionSort(arr)
	fmt.Println("Sorted array:", arr)
}

Python实现插入排序

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

arr = [12, 11, 13, 5, 6]
insertion_sort(arr)
print("Sorted array:", arr)

Java实现插入排序

public class InsertionSort {
    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};
        insertionSort(arr);
        System.out.println("Sorted array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Rust实现插入排序

fn insertion_sort(arr: &mut [i32]) {
    for i in 1..arr.len() {
        let key = arr[i];
        let mut j = i as i32 - 1;
        while j >= 0 && arr[j as usize] > key {
            arr[(j + 1) as usize] = arr[j as usize];
            j -= 1;
        }
        arr[(j + 1) as usize] = key;
    }
}

fn main() {
    let mut arr = [12, 11, 13, 5, 6];
    insertion_sort(&mut arr);
    println!("Sorted array: {:?}", arr);
}

C语言实现插入排序

#include <stdio.h>

void insertionSort(int arr[], int n) {
    int key, j;
    for (int i = 1; i < n; i++) {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    insertionSort(arr, n);
    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

JavaScript实现插入排序

function insertionSort(arr) {
    for (let i = 1; i < arr.length; i++) {
        let key = arr[i];
        let j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

const arr = [12, 11, 13, 5, 6];
insertionSort(arr);
console.log("Sorted array:", arr);

2. 希尔排序（Shell Sort）

希尔排序是插入排序的改进版，通过将数据分成若干个子序列，分别对每个子序列进行插入排序，最终通过逐步缩小子序列的间隔来实现整体的排序。

Go语言实现希尔排序

package main

import "fmt"

func shellSort(arr []int) {
    n := len(arr)
    gap := n / 2
    for gap > 0 {
        for i := gap; i < n; i++ {
            key := arr[i]
            j := i
            for j >= gap && arr[j-gap] > key {
                arr[j] = arr[j-gap]
                j -= gap
            }
            arr[j] = key
        }
        gap /= 2
    }
}

func main() {
    arr := []int{12, 11, 13, 5, 6}
    shellSort(arr)
    fmt.Println("Sorted array:", arr)
}

Python实现希尔排序

def shell_sort(arr):
    n = len(arr)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            key = arr[i]
            j = i
            while j >= gap and arr[j - gap] > key:
                arr[j] = arr[j - gap]
                j -= gap
            arr[j] = key
        gap //= 2

arr = [12, 11, 13, 5, 6]
shell_sort(arr)
print("Sorted array:", arr)

Java实现希尔排序

public class ShellSort {
    public static void shellSort(int[] arr) {
        int n = arr.length;
        int gap = n / 2;
        while (gap > 0) {
            for (int i = gap; i < n; i++) {
                int key = arr[i];
                int j = i;
                while (j >= gap && arr[j - gap] > key) {
                    arr[j] = arr[j - gap];
                    j -= gap;
                }
                arr[j] = key;
            }
            gap /= 2;
        }
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};
        shellSort(arr);
        System.out.println("Sorted array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Rust实现希尔排序

fn shell_sort(arr: &mut [i32]) {
    let n = arr.len();
    let mut gap = n / 2;
    while gap > 0 {
        for i in gap..n {
            let key = arr[i];
            let mut j = i as i32;
            while j >= gap as i32 && arr[(j - gap as i32) as usize] > key {
                arr[j as usize] = arr[(j - gap as i32) as usize];
                j -= gap as i32;
            }
            arr[(j + gap as i32) as usize] = key;
        }
        gap /= 2;
    }
}

fn main() {
    let mut arr = [12, 11, 13, 5, 6];
    shell_sort(&mut arr);
    println!("Sorted array: {:?}", arr);
}

C语言实现希尔排序

#include <stdio.h>

void shellSort(int arr[], int n) {
    int gap = n / 2;
    while (gap > 0) {
        for (int i = gap; i < n; i++) {
            int key = arr[i];
            int j = i;
            while (j >= gap && arr[j - gap] > key) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = key;
        }
        gap /= 2;
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    shellSort(arr, n);
    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

JavaScript实现希尔排序

function shellSort(arr) {
    let n = arr.length;
    let gap = Math.floor(n / 2);
    while (gap > 0) {
        for (let i = gap; i < n; i++) {
            let key = arr[i];
            let j = i;
            while (j >= gap && arr[j - gap] > key) {
                arr[j] = arr[j - gap];
                j -= gap;
            }
            arr[j] = key;
        }
        gap = Math.floor(gap / 2);
    }
}

const arr = [12, 11, 13, 5, 6];
shellSort(arr);
console.log("Sorted array:", arr);

3. 选择排序（Selection Sort）

选择排序是一种简单的排序算法，它的基本思想是每次从未排序部分选择最小（或最大）的元素，与未排序部分的第一个元素交换，直到整个序列有序。

Go语言实现选择排序

package main

import "fmt"

func selectionSort(arr []int) {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        minIdx := i
        for j := i + 1; j < n; j++ {
            if arr[j] < arr[minIdx] {
                minIdx = j
            }
        }
        arr[i], arr[minIdx] = arr[minIdx], arr[i]
    }
}

func main() {
    arr := []int{12, 11, 13, 5, 6}
    selectionSort(arr)
    fmt.Println("Sorted array:", arr)
}

Python实现选择排序

def selection_sort(arr):
    n = len(arr)
    for i in range(n-1):
        min_idx = i
        for j in range(i+1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

arr = [12, 11, 13, 5, 6]
selection_sort(arr)
print("Sorted array:", arr)

Java实现选择排序

public class SelectionSort {
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int minIdx = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIdx]) {
                    minIdx = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minIdx];
            arr[minIdx] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};
        selectionSort(arr);
        System.out.println("Sorted array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Rust实现选择排序

fn selection_sort(arr: &mut [i32]) {
    let n = arr.len();
    for i in 0..n-1 {
        let mut min_idx = i;
        for j in i+1..n {
            if arr[j] < arr[min_idx] {
                min_idx = j;
            }
        }
        arr.swap(i, min_idx);
    }
}

fn main() {
    let mut arr = [12, 11, 13, 5, 6];
    selection_sort(&mut arr);
    println!("Sorted array: {:?}", arr);
}

C语言实现选择排序

#include <stdio.h>

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIdx];
        arr[minIdx] = temp;
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    selectionSort(arr, n);
    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

JavaScript实现选择排序

function selectionSort(arr) {
    let n = arr.length;
    for (let i = 0; i < n - 1; i++) {
        let minIdx = i;
        for (let j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        [arr[i], arr[minIdx]] = [arr[minIdx], arr[i]];
    }
}

const arr = [12, 11, 13, 5, 6];
selectionSort(arr);
console.log("Sorted array:", arr);

4. 冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法，其基本思想是通过多次遍历数组，比较相邻的元素并交换它们，直到没有需要交换的元素为止。它的时间复杂度较高，因此在大规模数据的排序中不常使用，但由于其简单性仍然是学习排序算法时的一个重要入门。

冒泡排序的伪代码

for i from 0 to length of array:
    for j from 0 to length of array - i - 1:
        if array[j] > array[j+1]:
            swap(array[j], array[j+1])

Go语言实现冒泡排序

package main

import "fmt"

func bubbleSort(arr []int) {
    n := len(arr)
    for i := 0; i < n-1; i++ {
        for j := 0; j < n-i-1; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
}

func main() {
    arr := []int{12, 11, 13, 5, 6}
    bubbleSort(arr)
    fmt.Println("Sorted array:", arr)
}

Python实现冒泡排序

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

arr = [12, 11, 13, 5, 6]
bubble_sort(arr)
print("Sorted array:", arr)

Java实现冒泡排序

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};
        bubbleSort(arr);
        System.out.println("Sorted array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Rust实现冒泡排序

fn bubble_sort(arr: &mut [i32]) {
    let n = arr.len();
    for i in 0..n {
        for j in 0..n-i-1 {
            if arr[j] > arr[j+1] {
                arr.swap(j, j+1);
            }
        }
    }
}

fn main() {
    let mut arr = [12, 11, 13, 5, 6];
    bubble_sort(&mut arr);
    println!("Sorted array: {:?}", arr);
}

C语言实现冒泡排序

#include <stdio.h>

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubbleSort(arr, n);
    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

JavaScript实现冒泡排序

function bubbleSort(arr) {
    let n = arr.length;
    for (let i = 0; i < n - 1; i++) {
        for (let j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
            }
        }
    }
}

const arr = [12, 11, 13, 5, 6];
bubbleSort(arr);
console.log("Sorted array:", arr);

5. 堆排序（Heap Sort）

堆排序是一种基于完全二叉树的数据结构——堆（Heap）实现的排序算法。它通过构建大顶堆（或小顶堆），将堆顶元素与数组的最后一个元素交换，然后重新调整堆，重复此过程直到数组有序。

堆排序的伪代码

heapify(arr, n, i):
    largest = i
    left = 2*i + 1
    right = 2*i + 2
    if left < n and arr[left] > arr[largest]:
        largest = left
    if right < n and arr[right] > arr[largest]:
        largest = right
    if largest != i:
        swap(arr[i], arr[largest])
        heapify(arr, n, largest)

heapSort(arr):
    n = len(arr)
    for i = n / 2 - 1 down to 0:
        heapify(arr, n, i)
    for i = n - 1 down to 1:
        swap(arr[0], arr[i])
        heapify(arr, i, 0)

Go语言实现堆排序

package main

import "fmt"

func heapify(arr []int, n, i int) {
    largest := i
    left := 2*i + 1
    right := 2*i + 2
    if left < n && arr[left] > arr[largest] {
        largest = left
    }
    if right < n && arr[right] > arr[largest] {
        largest = right
    }
    if largest != i {
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)
    }
}

func heapSort(arr []int) {
    n := len(arr)
    for i := n / 2 - 1; i >= 0; i-- {
        heapify(arr, n, i)
    }
    for i := n - 1; i > 0; i-- {
        arr[0], arr[i] = arr[i], arr[0]
        heapify(arr, i, 0)
    }
}

func main() {
    arr := []int{12, 11, 13, 5, 6}
    heapSort(arr)
    fmt.Println("Sorted array:", arr)
}

Python实现堆排序

def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2
    if left < n and arr[left] > arr[largest]:
        largest = left
    if right < n and arr[right] > arr[largest]:
        largest = right
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
    for i in range(n - 1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        heapify(arr, i, 0)

arr = [12, 11, 13, 5, 6]
heap_sort(arr)
print("Sorted array:", arr)

Java实现堆排序

public class HeapSort {
    public static void heapify(int[] arr, int n, int i) {
        int largest = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }
        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }
        if (largest != i) {
            int temp = arr[i];
            arr[i] = arr[largest];
            arr[largest] = temp;
            heapify(arr, n, largest);
        }
    }

    public static void heapSort(int[] arr) {
        int n = arr.length;
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }
        for (int i = n - 1; i > 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            heapify(arr, i, 0);
        }
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};
        heapSort(arr);
        System.out.println("Sorted array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Rust实现堆排序

fn heapify(arr: &mut [i32], n: usize, i: usize) {
    let mut largest = i;
    let left = 2 * i + 1;
    let right = 2 * i + 2;

    if left < n && arr[left] > arr[largest] {
        largest = left;
    }
    if right < n && arr[right] > arr[largest] {
        largest = right;
    }
    if largest != i {
        arr.swap(i, largest);
        heapify(arr, n, largest);
    }
}

fn heap_sort(arr: &mut [i32]) {
    let n = arr.len();
    for i in (0..n / 2).rev() {
        heapify(arr, n, i);
    }
    for i in (1..n).rev() {
        arr.swap(0, i);
        heapify(arr, i, 0);
    }
}

fn main() {
    let mut arr = [12, 11, 13, 5, 6];
    heap_sort(&mut arr);
    println!("Sorted array: {:?}", arr);
}

C语言实现堆排序

#include <stdio.h>

void heapify(int arr[], int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }
    if (largest != i) {
        int temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    for (int i = n - 1; i > 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapify(arr, i, 0);
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    heapSort(arr, n);
    printf("Sorted array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

JavaScript实现堆排序

function heapify(arr, n, i) {
    let largest = i;
    let left = 2 * i + 1;
    let right = 2 * i + 2;
    if (left < n && arr[left] > arr[largest]) {
        largest = left;
    }
    if (right < n && arr[right] > arr[largest]) {
        largest = right;
    }
    if (largest !== i) {
        [arr[i], arr[largest]] = [arr[largest], arr[i]];
        heapify(arr, n, largest);
    }
}

function heapSort(arr) {
    let n = arr.length;
    for (let i = Math.floor(n / 2) - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }
    for (let i = n - 1; i > 0; i--) {
        [arr[0], arr[i]] = [arr[i], arr[0]];
        heapify(arr, i, 0);
    }
}

const arr = [12, 11, 13, 5, 6];
heapSort(arr);
console.log("Sorted array:", arr);

6. 快速排序（Quick Sort）

快速排序是分治法的典型应用，它通过选择一个基准元素，将数组分为两部分，一部分比基准元素小，另一部分比基准元素大，然后递归地对这两部分进行排序。

快速排序的伪代码

quickSort(arr, low, high):
    if low < high:
        p = partition(arr, low, high)
        quickSort(arr, low, p - 1)
        quickSort(arr, p + 1, high)

partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j from low to high - 1:
        if arr[j] < pivot:
            i++
            swap(arr[i], arr[j])
    swap(arr[i + 1], arr[high])
    return i + 1

Go语言实现快速排序

package main

import "fmt"

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

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

func main() {
    arr := []int{12, 11, 13, 5, 6}
    quickSort(arr, 0, len(arr)-1)
    fmt.Println("Sorted array:", arr)
}

Python实现快速排序

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] < pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i + 1

def quick_sort(arr, low, high):
    if low < high:
        p = partition(arr, low, high)
        quick_sort(arr, low, p - 1)
        quick_sort(arr, p + 1, high)

arr = [12, 11, 13, 5, 6]
quick_sort(arr, 0, len(arr) - 1)
print("Sorted array:", arr)

Java实现快速排序

public class QuickSort {
    public 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++;
                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;
    }

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int p = partition(arr, low, high);
            quickSort(arr, low, p - 1);
            quickSort(arr, p + 1, high);
        }
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};
        quickSort(arr, 0, arr.length - 1);
        System.out.println("Sorted array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Rust实现快速排序

fn partition(arr: &mut [i32], low: usize, high: usize) -> usize {
    let pivot = arr[high];
    let mut i = low as i32 - 1;
    for j in low..high {
        if arr[j] < pivot {
            i += 1;
            arr.swap(i as usize, j);
        }
    }
    arr.swap((i + 1) as usize, high);
    return (i + 1) as usize;
}

fn quick_sort(arr: &mut [i32], low: usize, high: usize) {
    if low < high {
        let p = partition(arr, low, high);
        quick_sort(arr, low, p - 1);
        quick_sort(arr, p + 1, high);
    }
}

fn main() {
    let mut arr = [12, 11, 13, 5, 6];
    quick_sort(&mut arr, 0, arr.len() - 1);
    println!("Sorted array: {:?}", arr);
}

C语言实现快速排序

#include <stdio.h>

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

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int p = partition(arr, low, high);
        quickSort(arr, low, p - 1);
        quickSort(arr, p + 1, high);
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    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]);
    }
    return 0;
}

JavaScript实现快速排序

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

function quickSort(arr, low, high) {
    if (low < high) {
        let p = partition(arr, low, high);
        quickSort(arr, low, p - 1);
        quickSort(arr, p + 1, high);
    }
}

const arr = [12, 11, 13, 5, 6];
quickSort(arr, 0, arr.length - 1);
console.log("Sorted array:", arr);

如何运行代码案例

在本文中，我们介绍了如何使用6种不同的编程语言实现六大经典排序算法。接下来，我们将为每种语言提供详细的运行方式，帮助你在不同的开发环境中顺利运行这些代码案例。

1. 如何运行Go代码

运行方式：

步骤 1: 安装Go语言

访问Go官网https://golang.org/下载并安装Go。
安装完成后，在终端或命令行输入go version检查是否安装成功。

步骤 2: 创建Go代码文件

将代码保存为main.go文件。

步骤 3: 运行Go代码

在终端中进入代码文件所在的目录，输入以下命令：

go run main.go

或者，先编译再运行：

go build main.go
./main

输出结果将显示排序后的数组。

2. 如何运行Python代码

运行方式：

步骤 1: 安装Python

访问Python官网https://www.python.org/下载并安装最新版本的Python。
安装完成后，在终端或命令行输入python --version或python3 --version检查是否安装成功。

步骤 2: 创建Python代码文件

将代码保存为main.py文件。

步骤 3: 运行Python代码

在终端中进入代码文件所在的目录，输入以下命令：

python main.py

或者：

python3 main.py

输出结果将显示排序后的数组。

3. 如何运行Java代码

运行方式：

步骤 1: 安装Java开发工具包 (JDK)

访问Oracle官网https://www.oracle.com/java/technologies/javase-jdk11-downloads.html下载并安装JDK。
安装完成后，在终端或命令行输入java -version检查是否安装成功。

步骤 2: 创建Java代码文件

将代码保存为QuickSort.java或其他文件名，确保文件名与类名匹配。

步骤 3: 运行Java代码

编译Java代码：

javac QuickSort.java

运行Java程序：

java QuickSort

输出结果将显示排序后的数组。

4. 如何运行Rust代码

运行方式：

步骤 1: 安装Rust

访问Rust官网https://www.rust-lang.org/下载并安装Rust。
安装完成后，在终端或命令行输入rustc --version检查是否安装成功。

步骤 2: 创建Rust代码文件

将代码保存为main.rs文件。

步骤 3: 运行Rust代码

在终端中进入代码文件所在的目录，输入以下命令：

rustc main.rs
./main

输出结果将显示排序后的数组。

5. 如何运行C代码

运行方式：

步骤 1: 安装C编译器

Windows: 安装MinGW或使用Visual Studio。
macOS: 安装Xcode Command Line Tools，或者使用Homebrew安装GCC。
Linux: 使用包管理器安装GCC，例如sudo apt install build-essential。

步骤 2: 创建C代码文件

将代码保存为main.c文件。

步骤 3: 运行C代码

在终端中进入代码文件所在的目录，输入以下命令：

gcc main.c -o main
./main

输出结果将显示排序后的数组。

6. 如何运行JavaScript代码

运行方式：

步骤 1: 安装Node.js

访问Node.js官网https://nodejs.org/下载并安装Node.js。
安装完成后，在终端或命令行输入node -v检查是否安装成功。

步骤 2: 创建JavaScript代码文件

将代码保存为main.js文件。

步骤 3: 运行JavaScript代码

在终端中进入代码文件所在的目录，输入以下命令：

node main.js

输出结果将显示排序后的数组。

参考资料

QA部分：常见问题解答

1. 为什么部分代码不能直接运行？

在不同的编程语言中，可能会遇到一些常见的运行问题。以下是针对每种语言的常见问题及解决方案：

Go语言

问题: 代码中未导入必要的包，或者使用了不支持的Go版本。 解决方案:

确保你已正确安装Go并使用Go 1.x及以上版本。
确保go run命令的路径正确，并且Go代码文件位于Go工作区内。

Python

问题: Python 版本不兼容或没有安装Python。 解决方案:

安装最新版本的Python，可以使用python3命令。
如果你使用的是较老版本的Python（如2.x），建议升级至3.x版本。

Java

问题: 没有编译正确的Java类文件，或者Java版本过旧。 解决方案:

确保你已安装JDK并配置好环境变量。
Java类文件的文件名需要与类名匹配。

Rust

问题: 没有使用cargo工具或Rust版本过低。 解决方案:

如果你正在使用Rust的开发环境，可以通过cargo run命令来执行Rust项目，而不是单独使用rustc编译。
确保Rust版本为最新版本。

C语言

问题: 没有正确安装C编译器，或者编译器设置不当。 解决方案:

在Linux系统上，使用apt install build-essential安装GCC。
确保你已经正确设置了C编译器并能够通过命令行执行。

JavaScript

问题: 没有安装Node.js，或者Node版本过低。 解决方案:

安装并配置Node.js，可以通过node -v检查当前安装的Node版本。
确保使用最新版本的Node.js运行JavaScript代码。

2. 如何调试代码？

调试不同语言的代码时，可能遇到各种问题。以下是一些常见的调试技巧：

Go

使用fmt.Println()打印输出关键变量的值来调试。
使用Go的delve工具进行调试。

Python

使用print()函数输出变量的值，或者使用Python的pdb调试工具。

Java

使用System.out.println()打印调试信息，或者使用IDE的调试功能。

Rust

使用println!()宏打印变量的值，或者使用cargo test进行单元测试。

C语言

使用printf()输出调试信息，或者使用GDB进行调试。

JavaScript

使用console.log()输出调试信息，或者使用Node.js的调试工具。

总结

本文详细介绍了如何使用6种编程语言（Go、Python、Java、Rust、C、JavaScript）实现经典的排序算法，涵盖了插入排序、希尔排序、选择排序、冒泡排序、堆排序和快速排序。通过运行这些代码，你不仅能够加深对排序算法的理解，还能够提高自己的编程能力。

在运行代码时，请确保你已正确设置和安装相关的编程环境。如果遇到运行问题，参考文中的解决方案以及调试技巧，可以帮助你顺利解决问题。

希望本文对你理解排序算法的实现有所帮助，并且能在实际的项目中应用这些算法优化代码性能。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-03-15，如有侵权请联系 cloudcommunity@tencent.com 删除

编程语言

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！