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

技术文档

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

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

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

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

我们将分别介绍每种排序算法的工作原理，提供代码示例，并在每种语言中展示如何实现。无论你是想提升自己的编程水平，还是在项目中优化排序性能，这篇文章都将为你提供实用的技巧和指导。
如何使用Go、Python、Java、Rust、C、JS等6种编程语言实现六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序

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

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

本文适合哪些人群？

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

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

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

文章目录

使用Go、Python、Java、Rust、C、JS等6种编程语言实现六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
- - 为什么要学习这些排序算法？
  - 本文适合哪些人群？
作者简介
- 作者名片 ✍️
正文
- 1. 插入排序（Insertion Sort）
- - 插入排序的伪代码
  - Go语言实现插入排序
  - Python实现插入排序
  - Java实现插入排序
  - Rust实现插入排序
  - C语言实现插入排序
  - JavaScript实现插入排序
- 2. 希尔排序（Shell Sort）
- - Go语言实现希尔排序
  - Python实现希尔排序
  - Java实现希尔排序
  - Rust实现希尔排序
  - C语言实现希尔排序
  - JavaScript实现希尔排序
- 3. 选择排序（Selection Sort）
- - Go语言实现选择排序
  - Python实现选择排序
  - Java实现选择排序
  - Rust实现选择排序
  - C语言实现选择排序
  - JavaScript实现选择排序
- 4. 冒泡排序（Bubble Sort）
- - 冒泡排序的伪代码
  - Go语言实现冒泡排序
  - Python实现冒泡排序
  - Java实现冒泡排序
  - Rust实现冒泡排序
  - C语言实现冒泡排序
  - JavaScript实现冒泡排序
- 5. 堆排序（Heap Sort）
- - 堆排序的伪代码
  - Go语言实现堆排序
  - Python实现堆排序
  - Java实现堆排序
  - Rust实现堆排序
  - C语言实现堆排序
  - JavaScript实现堆排序
- 6. 快速排序（Quick Sort）
- - 快速排序的伪代码
  - Go语言实现快速排序
  - Python实现快速排序
  - Java实现快速排序
  - Rust实现快速排序
  - C语言实现快速排序
  - JavaScript实现快速排序
- 如何运行代码案例
- - 1. 如何运行Go代码
  - - 运行方式：
  - 2. 如何运行Python代码
  - - 运行方式：
  - 3. 如何运行Java代码
  - - 运行方式：
  - 4. 如何运行Rust代码
  - - 运行方式：
  - 5. 如何运行C代码
  - - 运行方式：
  - 6. 如何运行JavaScript代码
  - - 运行方式：
- 参考资料
- QA部分：常见问题解答
- - 1. 为什么部分代码不能直接运行？
  - - Go语言
    - Python
    - Java
    - Rust
    - C语言
    - JavaScript
  - 2. 如何调试代码？
  - - Go
    - Python
    - Java
    - Rust
    - C语言
    - JavaScript
- 总结
粉丝福利
- - 联系我与版权声明 📩

作者简介

作者名片 ✍️

博主：猫头虎

全网搜索关键词：猫头虎

作者微信号：Libin9iOak

作者公众号：猫头虎技术团队

更新日期：2025年03月15日

🌟 欢迎来到猫头虎的博客 — 探索技术的无限可能！

正文

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 mainimport \"fmt\"func insertionSort(arr []int) {for i := 1; i < len(arr); i++ {key := arr[i]j := i - 1for 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] = keyarr = [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 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 mainimport \"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 //= 2arr = [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 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 mainimport \"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 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 mainimport \"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 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  arr[largest]: largest = left if 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 mainimport \"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 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 mainimport \"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 + 1def 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 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
```
- 输出结果将显示排序后的数组。

参考资料

Go Documentation
Python Documentation
Java Documentation
Rust Documentation
C Programming
Node.js Documentation

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）实现经典的排序算法，涵盖了插入排序、希尔排序、选择排序、冒泡排序、堆排序和快速排序。通过运行这些代码，你不仅能够加深对排序算法的理解，还能够提高自己的编程能力。

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

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

粉丝福利

👉 更多信息：有任何疑问或者需要进一步探讨的内容，欢迎点击文末名片获取更多信息。我是猫头虎博主，期待与您的交流！ 🦉💬

联系我与版权声明 📩

联系方式：
- 微信: Libin9iOak
- 公众号: 猫头虎技术团队
版权声明：
本文为原创文章，版权归作者所有。未经许可，禁止转载。更多内容请访问猫头虎的博客首页。

点击✨⬇️下方名片⬇️✨，加入猫头虎AI共创社群矩阵。一起探索科技的未来，共同成长。🚀

🔗 猫头虎抱团AI共创社群 | 🔗 Go语言VIP专栏 | 🔗 GitHub 代码仓库 | 🔗 Go生态洞察专栏 ✨ 猫头虎精品博文