tech-interview-for-developer：排序算法对比分析-10大排序算法详解

tech-interview-for-developer：排序算法对比分析-10大排序算法详解

【免费下载链接】tech-interview-for-developer 👶🏻 신입 개발자 전공 지식 & 기술 면접 백과사전 📖 项目地址: https://gitcode.com/GitHub_Trending/te/tech-interview-for-developer

引言：为什么排序算法如此重要？

在软件开发和技术面试中，排序算法是最基础也是最重要的考察点之一。无论是处理海量数据、优化系统性能，还是应对技术面试，掌握各种排序算法的原理、特性和适用场景都至关重要。本文将深入分析10大经典排序算法，帮助开发者建立完整的排序算法知识体系。

排序算法分类体系

10大排序算法详细对比

时间复杂度对比表

算法名称	平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
冒泡排序	O(n²)	O(n)	O(n²)	O(1)	稳定
选择排序	O(n²)	O(n²)	O(n²)	O(1)	不稳定
插入排序	O(n²)	O(n)	O(n²)	O(1)	稳定
希尔排序	O(n log n)	O(n log² n)	O(n²)	O(1)	不稳定
快速排序	O(n log n)	O(n log n)	O(n²)	O(log n)	不稳定
归并排序	O(n log n)	O(n log n)	O(n log n)	O(n)	稳定
堆排序	O(n log n)	O(n log n)	O(n log n)	O(1)	不稳定
计数排序	O(n + k)	O(n + k)	O(n + k)	O(k)	稳定
基数排序	O(d(n + k))	O(d(n + k))	O(d(n + k))	O(n + k)	稳定
桶排序	O(n + k)	O(n + k)	O(n²)	O(n + k)	稳定

1. 冒泡排序 (Bubble Sort)

核心思想：重复遍历数组，比较相邻元素并交换，使较大元素逐渐"冒泡"到数组末端。

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

适用场景：小规模数据、教学演示、几乎有序的数据

2. 选择排序 (Selection Sort)

核心思想：每次从未排序部分选择最小（或最大）元素放到已排序部分的末尾。

void selectionSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

3. 插入排序 (Insertion Sort)

核心思想：将每个元素插入到已排序数组中的适当位置。

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

4. 希尔排序 (Shell Sort)

核心思想：改进的插入排序，通过分组插入排序来减少数据移动次数。

void shellSort(int[] arr) {
    int n = arr.length;
    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;
        }
    }
}

5. 快速排序 (Quick Sort)

核心思想：分治策略，选择一个基准元素，将数组分成两部分，递归排序。

public void quickSort(int[] array, int left, int right) {
    if(left >= right) return;
    
    int pi = partition(array, left, right);
    
    quickSort(array, left, pi-1);
    quickSort(array, pi+1, right);
}

public int partition(int[] array, int left, int right) {
    int pivot = array[left];
    int i = left, j = right;
    
    while(i < j) {
        while(pivot < array[j]) j--;
        while(i < j && pivot >= array[i]) i++;
        swap(array, i, j);
    }
    array[left] = array[i];
    array[i] = pivot;
    return i;
}

6. 归并排序 (Merge Sort)

核心思想：分治策略，将数组分成两半，分别排序后合并。

public void mergeSort(int[] array, int left, int right) {
    if(left < right) {
        int mid = (left + right) / 2;
        mergeSort(array, left, mid);
        mergeSort(array, mid+1, right);
        merge(array, left, mid, right);
    }
}

public void merge(int[] array, int left, int mid, int right) {
    int[] L = Arrays.copyOfRange(array, left, mid + 1);
    int[] R = Arrays.copyOfRange(array, mid + 1, right + 1);
    
    int i = 0, j = 0, k = left;
    while(i < L.length && j < R.length) {
        if(L[i] <= R[j]) array[k++] = L[i++];
        else array[k++] = R[j++];
    }
    while(i < L.length) array[k++] = L[i++];
    while(j < R.length) array[k++] = R[j++];
}

7. 堆排序 (Heap Sort)

核心思想：利用堆数据结构进行排序，建立最大堆后不断提取最大元素。

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

public void heapify(int array[], int n, int i) {
    int p = i;
    int l = i*2 + 1;
    int r = i*2 + 2;
    
    if (l < n && array[p] < array[l]) p = l;
    if (r < n && array[p] < array[r]) p = r;
    
    if(i != p) {
        swap(array, p, i);
        heapify(array, n, p);
    }
}

8. 计数排序 (Counting Sort)

核心思想：统计每个元素出现的次数，然后按顺序输出。

void countingSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    int[] count = new int[max + 1];
    int[] output = new int[arr.length];
    
    for (int num : arr) count[num]++;
    for (int i = 1; i <= max; i++) count[i] += count[i - 1];
    for (int i = arr.length - 1; i >= 0; i--) {
        output[count[arr[i]] - 1] = arr[i];
        count[arr[i]]--;
    }
    System.arraycopy(output, 0, arr, 0, arr.length);
}

9. 基数排序 (Radix Sort)

核心思想：按位数进行排序，从最低位到最高位依次排序。

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

void countingSortByDigit(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);
}

10. 桶排序 (Bucket Sort)

核心思想：将数据分到有限数量的桶里，每个桶再分别排序。

void bucketSort(float[] arr) {
    int n = arr.length;
    ArrayList<Float>[] buckets = new ArrayList[n];
    for (int i = 0; i < n; i++) buckets[i] = new ArrayList<>();
    
    for (float num : arr) {
        int bucketIndex = (int) (num * n);
        buckets[bucketIndex].add(num);
    }
    
    for (ArrayList<Float> bucket : buckets) Collections.sort(bucket);
    
    int index = 0;
    for (ArrayList<Float> bucket : buckets) {
        for (float num : bucket) arr[index++] = num;
    }
}

算法选择策略

选择排序算法的决策树

实际应用场景推荐

1. 通用场景：快速排序（平均性能最优）
2. 稳定排序需求：归并排序
3. 内存受限：堆排序（原地排序）
4. 整数排序：计数排序/基数排序
5. 外部排序：多路归并排序
6. 几乎有序数据：插入排序
7. 小规模数据：插入排序/选择排序

性能优化技巧

1. 快速排序优化策略

// 三数取中法选择pivot
int medianOfThree(int[] arr, int left, int right) {
    int mid = left + (right - left) / 2;
    if (arr[left] > arr[mid]) swap(arr, left, mid);
    if (arr[left] > arr[right]) swap(arr, left, right);
    if (arr[mid] > arr[right]) swap(arr, mid, right);
    return mid;
}

// 小数组使用插入排序
if (right - left < 10) {
    insertionSort(arr, left, right);
    return;
}

2. 归并排序空间优化

使用原地归并或减少临时数组创建次数来优化空间复杂度。

面试常见问题

算法特性对比表

特性	快速排序	归并排序	堆排序	插入排序
平均时间复杂度	O(n log n)	O(n log n)	O(n log n)	O(n²)
最坏时间复杂度	O(n²)	O(n log n)	O(n log n)	O(n²)
空间复杂度	O(log n)	O(n)	O(1)	O(1)
稳定性	不稳定	稳定	不稳定	稳定
适用数据结构	数组	数组/链表	数组	数组/链表
缓存友好性	好	一般	差	好

技术面试准备要点

1. 时间复杂度分析：能够推导各种情况下的时间复杂度
2. 空间复杂度分析：理解递归调用栈和额外空间使用
3. 稳定性理解：明确稳定排序的定义和重要性
4. 代码实现：能够手写关键算法的实现
5. 优化策略：了解各种算法的优化方法
6. 适用场景：根据具体需求选择合适的算法

总结

排序算法是计算机科学的基础，掌握各种排序算法的原理和特性对于技术面试和实际开发都至关重要。通过本文的详细分析，你应该能够：

1. 理解10大排序算法的核心思想和实现原理
2. 根据具体场景选择合适的排序算法
3. 分析算法的时间复杂度和空间复杂度
4. 应对技术面试中的排序算法相关问题
5. 在实际项目中优化排序性能

记住，没有最好的排序算法，只有最适合特定场景的排序算法。深入理解每种算法的特性和适用场景，才能在技术面试和实际开发中游刃有余。

点赞/收藏/关注三连，获取更多技术面试干货！下期预告：《深入理解动态规划：从斐波那契到背包问题》

【免费下载链接】tech-interview-for-developer 👶🏻 신입 개발자 전공 지식 & 기술 면접 백과사전 📖 项目地址: https://gitcode.com/GitHub_Trending/te/tech-interview-for-developer