深入解析hadyang/interview项目中的排序算法

深入解析hadyang/interview项目中的排序算法

interview 项目地址: https://gitcode.com/gh_mirrors/intervi/interview

排序算法是计算机科学中最基础也是最重要的算法之一。本文将全面解析hadyang/interview项目中涉及的各类排序算法，从基础概念到具体实现，帮助读者深入理解排序算法的核心思想与应用场景。

排序算法概述

排序算法可以分为两大类：稳定排序和不稳定排序。稳定排序指的是在排序过程中，相等元素的相对位置不会改变；而不稳定排序则不能保证这一点。

稳定排序算法

• 冒泡排序：时间复杂度O(n²)
• 插入排序：时间复杂度O(n²)
• 归并排序：时间复杂度O(nlogn)，需要额外空间
• 桶排序：时间复杂度O(n)，需要额外空间
• 基数排序：时间复杂度O(n·k)，需要额外空间

不稳定排序算法

• 选择排序：时间复杂度O(n²)
• 希尔排序：时间复杂度O(nlogn)
• 堆排序：时间复杂度O(nlogn)
• 快速排序：平均时间复杂度O(nlogn)，最坏O(n²)

交换排序详解

冒泡排序

冒泡排序是最简单的排序算法之一，其核心思想是通过相邻元素的比较和交换，将较大的元素逐步"冒泡"到数组的末端。

算法特点：

• 稳定排序
• 时间复杂度始终为O(n²)
• 空间复杂度O(1)

优化思路：

1. 设置标志位，当某一轮没有发生交换时提前结束排序
2. 记录最后交换位置，减少下一轮的比较次数

void bubble_sort(int a[], int n) {
    for (int j = 0; j < n - 1; j++) {
        bool swapped = false;
        for (int i = 0; i < n - 1 - j; i++) {
            if(a[i] > a[i + 1]) {
                swap(a[i], a[i+1]);
                swapped = true;
            }
        }
        if(!swapped) break; // 提前终止
    }
}

快速排序

快速排序采用分治策略，是目前实践中最高效的排序算法之一。

算法步骤：

1. 选取基准值(pivot)
2. 分区操作：将小于基准的元素放在左边，大于基准的放在右边
3. 递归地对左右子序列进行快速排序

性能分析：

• 平均时间复杂度：O(nlogn)
• 最坏时间复杂度：O(n²)（当数组已排序或逆序时）
• 不稳定排序

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

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

优化策略：

1. 三数取中法选择基准值
2. 小数组时切换为插入排序
3. 尾递归优化
4. 三向切分处理大量重复元素

插入排序家族

直接插入排序

插入排序的工作原理类似于整理扑克牌，将每个元素插入到已排序序列的适当位置。

算法特点：

• 稳定排序
• 时间复杂度O(n²)
• 对小规模数据或基本有序数据效率很高

void insert_sort(int* a, int len) {
    for (int i = 1; i < len; ++i) {
        int key = a[i];
        int j = i - 1;
        while (j >= 0 && a[j] > key) {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = key;
    }
}

希尔排序

希尔排序是插入排序的改进版，通过分组插入排序来提升性能。

算法特点：

• 不稳定排序
• 时间复杂度取决于增量序列，最好可达O(nlog²n)
• 空间复杂度O(1)

void shell_sort(int* a, int len) {
    for (int gap = len/2; gap > 0; gap /= 2) {
        for (int i = gap; i < len; ++i) {
            int temp = a[i];
            int j;
            for (j = i; j >= gap && a[j-gap] > temp; j -= gap) {
                a[j] = a[j-gap];
            }
            a[j] = temp;
        }
    }
}

选择排序及其变种

直接选择排序

每次从未排序部分选择最小(大)元素放到已排序部分的末尾。

算法特点：

• 不稳定排序
• 时间复杂度始终为O(n²)
• 交换次数最少为O(n)

void selection_sort(int arr[], int len) {
    for (int i = 0; i < len-1; i++) {
        int min_idx = i;
        for (int j = i+1; j < len; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        swap(arr[i], arr[min_idx]);
    }
}

堆排序

利用堆数据结构设计的排序算法，是一种改进的选择排序。

算法步骤：

1. 构建最大堆
2. 将堆顶元素与末尾元素交换
3. 调整剩余元素为最大堆
4. 重复步骤2-3直到排序完成

算法特点：

• 不稳定排序
• 时间复杂度O(nlogn)
• 空间复杂度O(1)

public void heapSort(int[] nums) {
    // 构建最大堆
    for (int i = nums.length/2-1; i >= 0; i--) {
        heapify(nums, nums.length, i);
    }
    
    // 逐个提取元素
    for (int i = nums.length-1; i > 0; i--) {
        swap(nums, 0, i);
        heapify(nums, i, 0);
    }
}

private 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) {
        swap(arr, i, largest);
        heapify(arr, n, largest);
    }
}

分治策略排序算法

归并排序

典型的分治算法，将数组分成两半分别排序，然后合并结果。

算法特点：

• 稳定排序
• 时间复杂度O(nlogn)
• 空间复杂度O(n)

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

private void merge(int[] arr, int l, int mid, int r, int[] temp) {
    int i = l, j = mid+1, k = 0;
    
    while (i <= mid && j <= r) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    
    while (i <= mid) temp[k++] = arr[i++];
    while (j <= r) temp[k++] = arr[j++];
    
    System.arraycopy(temp, 0, arr, l, k);
}

非比较排序算法

桶排序

将元素分配到有限数量的桶中，每个桶再单独排序。

适用场景：

• 数据均匀分布
• 知道数据范围
• 需要稳定排序

算法特点：

• 时间复杂度O(n+k)，k为桶的数量
• 空间复杂度O(n+k)

基数排序

按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。

算法特点：

• 稳定排序
• 时间复杂度O(nk)，k为数字位数
• 空间复杂度O(n+k)

void radixSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    
    for (int exp = 1; max/exp > 0; exp *= 10) {
        countSort(arr, exp);
    }
}

void countSort(int[] arr, int exp) {
    int[] output = new int[arr.length];
    int[] count = new int[10];
    
    for (int num : arr) {
        count[(num/exp)%10]++;
    }
    
    for (int i = 1; i < 10; i++) {
        count[i] += count[i-1];
    }
    
    for (int i = arr.length-1; i >= 0; i--) {
        output[count[(arr[i]/exp)%10]-1] = arr[i];
        count[(arr[i]/exp)%10]--;
    }
    
    System.arraycopy(output, 0, arr, 0, arr.length);
}

拓扑排序

对有向无环图(DAG)进行排序，使得对于图中的每一条有向边(u,v)，u在排序中总是位于v的前面。

应用场景：

• 任务调度
• 课程安排
• 依赖解析

算法实现（Kahn算法）：

1. 计算所有节点的入度
2. 将入度为0的节点加入队列
3. 取出队列中的节点并输出，将其邻接节点的入度减1
4. 如果邻接节点入度变为0，加入队列
5. 重复步骤3-4直到队列为空

排序算法选择指南

1. 小规模数据：插入排序（稳定，实现简单）
2. 基本有序数据：插入排序或冒泡排序
3. 大规模随机数据：快速排序（平均性能最好）
4. 需要稳定排序：归并排序
5. 数据范围已知且均匀分布：桶排序或计数排序
6. 链表结构：归并排序（适合链表排序）
7. 外部排序：多路归并排序

总结

hadyang/interview项目中涵盖了从基础到高级的各种排序算法实现。理解这些算法的核心思想、时间空间复杂度以及适用场景，对于计算机科学学习和技术面试都至关重要。实际应用中，我们需要根据数据特征和性能要求选择合适的排序算法，有时还需要结合多种算法的优势进行优化。

interview 项目地址: https://gitcode.com/gh_mirrors/intervi/interview