【思路详解+详细注释】小白都能看懂的力扣算法详解——排序算法（多语言版本代码示例）

一  冒泡排序（Bubble Sort）

        通过重复遍历待排序的数列，每次比较相邻的两个元素，如果它们的顺序错误就交换它们，直到整个序列有序。想象我们在一个游泳池里，水泡会从底部上升到水面。我们把水泡看作是需要排序的元素，通过不断地比较和交换，元素就会像水泡一样"浮"到正确的位置上。

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 - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换两个元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

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

arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("Sorted array is:", arr)

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

arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("Sorted array is:", arr)

package main

import "fmt"

func bubbleSort(arr []int) {
    n := len(arr)
    for i := 0; i < n; 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{64, 34, 25, 12, 22, 11, 90}
    bubbleSort(arr)
    fmt.Println("Sorted array is:", arr)
}

时间复杂度： O(n²)
优点： 实现简单。
缺点： 当数据量较大时，性能较差

二 选择排序（Selection Sort）

        每次从未排序的部分中选择最小（或最大）的元素，放到已排序的部分的末尾。通过多次遍历不断扩大已排序部分。

public class SelectionSort {
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        // 外层循环用于控制已排序部分的边界
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i; // 记录当前未排序部分最小值的索引
            // 在未排序部分中找到最小值
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j; // 更新最小值索引
                }
            }
            // 交换最小值到已排序部分的末尾
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        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 = [64, 25, 12, 22, 11]
selection_sort(arr)
print("Sorted array is:", arr)

#include <stdio.h>

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

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    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;
}

package main

import "fmt"

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

func main() {
    arr := []int{64, 25, 12, 22, 11}
    selectionSort(arr)
    fmt.Println("Sorted array is:", arr)
}

时间复杂度： O(n²)
优点： 简单易实现，不依赖数据是否已部分排序。
缺点： 不稳定，效率不高。 

三 插入排序（Insertion Sort）

        把待排序的序列分为已排序和未排序两部分，每次从未排序部分中取出一个元素，将它插入到已排序部分的正确位置上。

public class InsertionSort {
    public static void insertionSort(int[] arr) {
        int n = arr.length;
        // 从第二个元素开始，逐个将元素插入到前面的有序部分
        for (int i = 1; i < n; 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; // 插入元素
        }
    }
}

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

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

#include <stdio.h>

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

package main

import "fmt"

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

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

时间复杂度： O(n²)
优点： 对于小规模或几乎有序的数据很高效。
缺点： 当数据无序且规模较大时，效率较低。 

四 快速排序（Quick Sort）

        选择一个"基准"元素，将序列分成比基准元素小和大的两部分，然后递归地对这两部分进行排序。比如我们在一个书架上整理书籍，选择一本书作为基准，把所有比这本书名小的书放在它的左边，把所有比它大的书放在右边，然后对左右两边的书继续进行相同的操作。

public class QuickSort {
    public static 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); // 递归排序基准右边部分
        }
    }

    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++;
                // 交换arr[i]和arr[j]
                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; // 返回基准位置
    }
}

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    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)

arr = [10, 7, 8, 9, 1, 5]
arr = quick_sort(arr)
print("Sorted array is:", arr)

#include <stdio.h>

void swap(int* a, int* b) {
    int t = *a;
    *a = *b;
    *b = t;
}

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

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 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]);
    return 0;
}

package main

import "fmt"

func quickSort(arr []int) []int {
    if len(arr) <= 1 {
        return arr
    }

    pivot := arr[len(arr)/2]
    left := []int{}
    right := []int{}
    equal := []int{}

    for _, num := range arr {
        if num < pivot {
            left = append(left, num)
        } else if num > pivot {
            right = append(right, num)
        } else {
            equal = append(equal, num)
        }
    }

    return append(append(quickSort(left), equal...), quickSort(right)...)
}

func main() {
    arr := []int{10, 7, 8, 9, 1, 5}
    sorted := quickSort(arr)
    fmt.Println("Sorted array is:", sorted)
}

时间复杂度： 平均 O(n log n)，最坏 O(n²)
优点： 高效，适用于大规模数据。
缺点： 不稳定，最坏情况下效率较低。 

五 归并排序（Merge Sort）

        将序列分成两半，对这两半分别排序，然后将它们合并成一个有序的序列。

public class MergeSort {
    public static void mergeSort(int[] arr, int l, int r) {
        if (l < r) {
            int m = (l + r) / 2; // 找到中点
            mergeSort(arr, l, m); // 递归排序左半部分
            mergeSort(arr, m + 1, r); // 递归排序右半部分
            merge(arr, l, m, r); // 合并两个有序子序列
        }
    }

    private static void merge(int[] arr, int l, int m, int r) {
        int n1 = m - l + 1;
        int n2 = r - m;
        int[] L = new int[n1]; // 左半部分临时数组
        int[] R = new int[n2]; // 右半部分临时数组

        // 将数据复制到临时数组
        for (int i = 0; i < n1; ++i) {
            L[i] = arr[l + i];
        }
        for (int j = 0; j < n2; ++j) {
            R[j] = arr[m + 1 + j];
        }

        // 合并两个临时数组
        int i = 0, j = 0;
        int k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k++] = L[i++];
            } else {
                arr[k++] = R[j++];
            }
        }

        // 将剩余元素放回原数组
        while (i < n1) {
            arr[k++] = L[i++];
        }
        while (j < n2) {
            arr[k++] = R[j++];
        }
    }
}

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        L = arr[:mid]
        R = arr[mid:]

        merge_sort(L)
        merge_sort(R)

        i = j = k = 0
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1

        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1

        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1

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

#include <stdio.h>

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;

    int L[n1], R[n2];
    for (int i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (int j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];

    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }

    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6, 7};
    int arr_size = sizeof(arr) / sizeof(arr[0]);

    mergeSort(arr, 0, arr_size - 1);

    printf("Sorted array: ");
    for (int i = 0; i < arr_size; i++)
        printf("%d ", arr[i]);
    return 0;
}

package main

import "fmt"

func mergeSort(arr []int) []int {
    if len(arr) <= 1 {
        return arr
    }

    mid := len(arr) / 2
    left := mergeSort(arr[:mid])
    right := mergeSort(arr[mid:])

    return merge(left, right)
}

func merge(left, right []int) []int {
    result := make([]int, 0, len(left)+len(right))
    i, j := 0, 0
    for i < len(left) && j < len(right) {
        if left[i] <= right[j] {
            result = append(result, left[i])
            i++
        } else {
            result = append(result, right[j])
            j++
        }
    }

    result = append(result, left[i:]...)
    result = append(result, right[j:]...)

    return result
}

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

时间复杂度： O(n log n)
优点： 稳定且高效，适用于大数据排序。
缺点： 需要额外的存储空间。 

六 堆排序（Heap Sort）

        将序列构建成一个最大堆（或最小堆），然后逐步将堆顶元素（最大或最小）移到已排序部分，并重新调整堆的结构。

public class HeapSort {
    // 主函数，进行堆排序
    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);
        }
    }

    // 辅助函数：调整堆，使其满足最大堆的性质
    // n 是堆的大小，i 是当前需要调整的节点
    private 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 swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;

            // 递归调整受影响的子树
            heapify(arr, n, largest);
        }
    }
}

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[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)
    return arr

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

package main

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

时间复杂度： O(n log n) 

优点：不需要额外的存储空间（就地排序）；时间复杂度稳定，适合大规模数据排序。

缺点：不稳定，即相同元素的相对顺序可能发生变化。交换操作较多，导致在数据交换时可能会影响性能。

七 希尔排序（Shell Sort）

        通过将序列分成若干个子序列，分别对这些子序列进行插入排序，然后逐步减少子序列的数量，最终实现整个序列的有序。

 ppublic class ShellSort {
    // 主函数，进行希尔排序
    public static void shellSort(int[] arr) {
        int n = arr.length;

        // 选择初始间隔，通常从数组长度的一半开始
        for (int gap = n / 2; gap > 0; gap /= 2) {
            // 对每个间隔为gap的子序列进行插入排序
            for (int i = gap; i < n; i++) {
                int temp = arr[i];  // 当前待插入的元素
                int j;

                // 插入排序的核心逻辑：将当前元素向左移，直到找到合适位置
                for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                    arr[j] = arr[j - gap];  // 将较大的元素向右移
                }

                // 将待插入元素放入合适位置
                arr[j] = temp;
            }
        }
    }
}

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

#include <stdio.h>

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

package main

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

时间复杂度： O(n log n) ~ O(n²) （依赖于间隔序列的选择）

优点：相对于直接插入排序，效率大幅提升，特别是对大规模无序数组。可以快速移动元素到更合适的位置，减少插入排序的比较次数。

缺点：选择合适的间隔序列比较困难。希尔排序是不稳定排序

八 计数排序（Counting Sort）

        通过统计每个元素出现的次数，直接根据统计结果将元素放回原数组中。

public class CountingSort {
    public static void countingSort(int[] arr) {
        int max = findMax(arr); // 找到最大值，确定计数数组的长度
        int[] count = new int[max + 1]; // 创建计数数组

        // 计数每个元素出现的次数
        for (int num : arr) {
            count[num]++;
        }

        // 根据计数信息重写原数组
        int index = 0;
        for (int i = 0; i <= max; i++) {
            while (count[i] > 0) {
                arr[index++] = i; // 将元素填回原数组
                count[i]--;
            }
        }
    }

    // 辅助方法：找到数组中的最大值
    private static int findMax(int[] arr) {
        int max = arr[0];
        for (int num : arr) {
            if (num > max) {
                max = num;
            }
        }
        return max;
    }
}

def counting_sort(arr):
    max_val = max(arr)
    count = [0] * (max_val + 1)
    output = [0] * len(arr)

    for num in arr:
        count[num] += 1

    for i in range(1, len(count)):
        count[i] += count[i - 1]

    for num in arr:
        output[count[num] - 1] = num
        count[num] -= 1

    return output

#include <stdio.h>

void countingSort(int arr[], int n) {
    int max = arr[0];
    for (int i = 1; i < n; i++)
        if (arr[i] > max)
            max = arr[i];

    int count[max + 1];
    int output[n];

    for (int i = 0; i <= max; i++)
        count[i] = 0;

    for (int i = 0; i < n; i++)
        count[arr[i]]++;

    for (int i = 1; i <= max; i++)
        count[i] += count[i - 1];

    for (int i = n - 1; i >= 0; i--) {
        output[count[arr[i]] - 1] = arr[i];
        count[arr[i]]--;
    }

    for (int i = 0; i < n; i++)
        arr[i] = output[i];
}

package main

func countingSort(arr []int) []int {
    maxVal := arr[0]
    for _, val := range arr {
        if val > maxVal {
            maxVal = val
        }
    }

    count := make([]int, maxVal+1)
    output := make([]int, len(arr))

    for _, val := range arr {
        count[val]++
    }

    for i := 1; i < len(count); i++ {
        count[i] += count[i-1]
    }

    for i := len(arr) - 1; i >= 0; i-- {
        output[count[arr[i]]-1] = arr[i]
        count[arr[i]]--
    }

    return output
}

时间复杂度： O(n + k)，k是数组中元素的最大值
优点： 时间复杂度为线性。
缺点： 只适用于整数数组，且需要额外的空间。

---

总结

时间复杂度 O(n log n)的算法：归并排序、快速排序、堆排序、希尔排序（依赖间隔序列）

时间复杂度 O(n²)的算法：冒泡排序、选择排序、插入排序、希尔排序（最差情况）

稳定的排序算法：冒泡排序、插入排序、归并排序、计数排序

不稳定的排序算法：选择排序、快速排序、堆排序、希尔排序