胖虎的工具箱-编程导航 胖虎的工具箱-编程导航

六种编程语言实现六大排序算法详解

未分类 9小时前 程序员胖胖胖虎阿
3 0 0

六种编程语言实现六大排序算法的全面解析

排序算法是计算机科学领域中极为基础且核心的概念之一。无论你是初涉编程的新手，还是经验丰富的开发者，深入理解并熟练掌握排序算法对于提升编程水平而言都有着举足轻重的意义。排序算法不仅是面试环节中常见的考查内容，在实际的开发场景里，像数据库查询、数据分析以及大数据处理等领域都有着广泛的应用。

当面临大规模数据处理时，排序算法的效率直接左右着程序的运行速度与性能表现。随着数据量的不断增大，选用恰当的排序算法会对系统性能的优化起到决定性的作用。所以，熟练掌握多种排序算法，并能够依据具体场景挑选出最优的排序方法，是每一位程序员必须具备的技能。

本文将会深入剖析并展示怎样运用六种不同的编程语言（Go、Python、Java、Rust、C、JavaScript）来实现六大经典排序算法，包括：插入排序、希尔排序、选择排序、冒泡排序、堆排序 和快速排序。通过本篇教程，你不仅可以明晰这些算法的核心思想，还能掌握在多种流行编程语言中对它们的实现方法。

我们会依次介绍每种排序算法的运作原理，提供代码示例，并在每种编程语言中呈现其实现方式。无论你是期望提升自身的编程水平，还是要在项目中优化排序性能，本文都将为你提供实用的技巧与指导。

六种编程语言实现六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序的相关图示

为何要学习这些排序算法？

  1. 提升编程能力：排序算法是计算机科学的基础内容，掌握它们能让你在编程时更加游刃有余。
  2. 优化性能：不同的排序算法具备不同的时间复杂度，在处理大数据时，选择合适的排序算法能够显著提高程序的运行效率。
  3. 面试必备：排序算法是众多技术面试中的经典题目，熟练掌握它们有助于你顺利通过面试。
  4. 灵活运用：排序算法的应用远不止于数据排序，还能应用于问题求解、搜索优化等场景，具备灵活运用能力的开发者更具竞争力。

本文适合哪些人群？

  • 初学者：若你刚刚开启编程学习之旅，本文能助力你了解不同编程语言中排序算法的实现方式，夯实算法基础。
  • 中高级开发者：对于已具备一定编程基础的开发者而言，本文可帮助你深入理解不同排序算法的实现途径，并掌握在多种语言中的灵活运用方法。
  • 求职者：若你正在筹备技术面试，掌握常见的排序算法是面试准备的基础，本文为你提供了丰富的参考与实战代码。

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

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

文章目录

  • 六种编程语言实现六大排序算法：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序
  • 为何要学习这些排序算法？
  • 本文适合哪些人群？
  • 作者简介
  • 作者名片 ✍️
  • 正文
    1. 插入排序（Insertion Sort）
    2. 插入排序的伪代码
    3. Go语言实现插入排序
    4. Python实现插入排序
    5. Java实现插入排序
    6. Rust实现插入排序
    7. C语言实现插入排序
    8. JavaScript实现插入排序
    1. 希尔排序（Shell Sort）
    1. 选择排序（Selection Sort）
    1. 冒泡排序（Bubble Sort）
    2. 冒泡排序的伪代码
    3. Go语言实现冒泡排序
    4. Python实现冒泡排序
    5. Java实现冒泡排序
    6. Rust实现冒泡排序
    7. C语言实现冒泡排序
    8. JavaScript实现冒泡排序
    1. 堆排序（Heap Sort）
    2. 堆排序的伪代码
    3. Go语言实现堆排序
    4. Python实现堆排序
    5. Java实现堆排序
    6. Rust实现堆排序
    7. C语言实现堆排序
    8. JavaScript实现堆排序
    1. 快速排序（Quick Sort）
    2. 快速排序的伪代码
    3. Go语言实现快速排序
    4. Python实现快速排序
    5. Java实现快速排序
    6. Rust实现快速排序
    7. C语言实现快速排序
    8. JavaScript实现快速排序
  • 如何运行代码案例
      1. 如何运行Go代码
    • 运行方式：
      1. 如何运行Python代码
    • 运行方式：
      1. 如何运行Java代码
    • 运行方式：
      1. 如何运行Rust代码
    • 运行方式：
      1. 如何运行C代码
    • 运行方式：
      1. 如何运行JavaScript代码
    • 运行方式：
  • 参考资料
  • QA部分：常见问题解答
      1. 为何部分代码无法直接运行？
    • Go语言
    • Python
    • Java
    • Rust
    • C语言
    • JavaScript
      1. 如何调试代码？
    • 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 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

版权声明：程序员胖胖胖虎阿 发表于 2025年8月16日 上午7:14。
转载请注明：六种编程语言实现六大排序算法详解 | 胖虎的工具箱-编程导航

相关文章

TCP-UDP调试工具推荐：Socket通信测试教程（附详细图解）
程序员胖胖胖虎阿
180
JAVA对excle创建、读取、设置单元格颜色、背景色、跨行跨列
程序员胖胖胖虎阿
350
一个注解搞定 Spring Boot 操作日志
程序员胖胖胖虎阿
440
阿里一面：那我把线程池coreSize配置成0会怎样？
程序员胖胖胖虎阿
97
《Java核心技术 I》容易忽视和重要的知识点汇总
程序员胖胖胖虎阿
149

Java二叉搜索树深度解析：一文尽揽核心要诀
程序员胖胖胖虎阿
43

暂无评论

暂无评论...
致力于称为最好的程序员导航网站

友链申请 免责声明 关于我们

Copyright © 2022  胖虎的工具箱-编程导航   陇ICP备2022001249号