中级：排序算法面试题必知必会

最新推荐文章于 2025-04-01 22:24:31 发布

佩奇的技术笔记

最新推荐文章于 2025-04-01 22:24:31 发布

阅读量357

点赞数 3

分类专栏： Java面试小册文章标签：排序算法算法 java

本文链接：https://blog.youkuaiyun.com/weixin_44978801/article/details/146822982

版权

Java面试小册专栏收录该内容

19 篇文章

订阅专栏

一、引言

排序算法是计算机科学中的经典主题，在面试中经常被考察。面试官通过相关问题，评估候选人对算法的理解深度、分析能力以及实际应用技巧。本文系统梳理常用排序算法，深入剖析其原理、特性与应用场景，助力读者高效备战面试。

二、常见排序算法详解

1. 冒泡排序

原理：通过相邻元素比较交换，将最大元素逐步移到序列末尾，如同气泡上升。重复此过程直至序列有序。

示例：数组 [5,3,8,6,2]，第一轮比较后最大元素 8 移至末尾，得到 [5,3,6,2,8]。

复杂度 ：时间复杂度 O(n²)，空间复杂度 O(1)。

稳定性 ：稳定。

面试考察点 ：理解排序基本思想，分析时间复杂度。可能要求手动模拟排序过程，或与其他简单排序算法对比。

Java代码实现 ：

public class BubbleSort {
    public static void sort(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 = {5, 3, 8, 6, 2};
        sort(arr);
        System.out.println("冒泡排序结果：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

2. 选择排序

原理：每轮从未排序部分选最小元素，放到已排序部分末尾。

示例：数组 [5,3,8,6,2]，第一轮选最小值 2 与首元素交换，得到 [2,3,8,6,5]。

复杂度 ：时间复杂度 O(n²)，空间复杂度 O(1)。

稳定性 ：不稳定。

面试考察点 ：掌握算法思想与实现，比较与冒泡排序的差异，分析不稳定性原因。

Java代码实现 ：

public class SelectionSort {
    public static void sort(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[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 2};
        sort(arr);
        System.out.println("选择排序结果：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

3. 插入排序

原理：将一个元素插入到已排序部分的合适位置，使已排序部分保持有序。

示例：数组 [5,3,8,6,2]，第二轮将 3 插入到 5 前，得到 [3,5,8,6,2]。

复杂度 ：时间复杂度 O(n²)，空间复杂度 O(1)。

稳定性 ：稳定。

面试考察点 ：算法实现与优化，如设置哨兵位；比较不同排序算法的性能与适用场景。

Java代码实现 ：

public class InsertionSort {
    public static void sort(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;
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 2};
        sort(arr);
        System.out.println("插入排序结果：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

4. 快速排序

原理：选基准元素，将数组分为小于和大于基准的两部分，递归排序子数组。

示例：数组 [5,3,8,6,2]，选 5 为基准，划分后得到 [3,2,5,8,6]，递归排序左右子数组。

复杂度 ：平均时间复杂度 O(nlogn)，最坏 O(n²)，空间复杂度 O(logn)。

稳定性 ：不稳定。

面试考察点 ：算法思想、实现及优化（如三数取中选基准），分析时间复杂度，与归并排序对比。

Java代码实现 ：

public class QuickSort {
    public static void sort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            sort(arr, low, pivotIndex - 1);
            sort(arr, pivotIndex + 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++;
                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 main(String[] args) {
        int[] arr = {5, 3, 8, 6, 2};
        sort(arr, 0, arr.length - 1);
        System.out.println("快速排序结果：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

5. 归并排序

原理：分治法，将数组分为两半递归排序，再合并两个有序子数组。

示例：数组 [5,3,8,6,2]，递归分解为单元素子数组，合并时按序组合。

复杂度 ：时间复杂度 O(nlogn)，空间复杂度 O(n)。

稳定性 ：稳定。

面试考察点 ：算法思想与实现，空间复杂度分析，稳定性体现，应用场景如外部排序。

Java代码实现 ：

public class MergeSort {
    public static void sort(int[] arr) {
        int[] temp = new int[arr.length];
        mergeSort(arr, temp, 0, arr.length - 1);
    }

    private static void mergeSort(int[] arr, int[] temp, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(arr, temp, left, mid);
            mergeSort(arr, temp, mid + 1, right);
            merge(arr, temp, left, mid, right);
        }
    }

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

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 2};
        sort(arr);
        System.out.println("归并排序结果：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

6. 堆排序

原理：先建大顶堆，将堆顶元素（最大值）与末尾元素交换，减堆后重复此过程。

示例：数组 [5,3,8,6,2]，建大顶堆后为 [8,6,5,3,2]，交换 8 和 2 后得到 [2,6,5,3,8]，减堆后继续排序。

复杂度 ：时间复杂度 O(nlogn)，空间复杂度 O(1)。

稳定性 ：不稳定。

面试考察点 ：算法思想、堆的构建与调整，原地排序的实现，与其他 O(nlogn) 排序算法的对比。

Java代码实现 ：

public class HeapSort {
    public static void sort(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);
        }
    }

    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 temp = arr[i];
            arr[i] = arr[largest];
            arr[largest] = temp;
            heapify(arr, n, largest);
        }
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 6, 2};
        sort(arr);
        System.out.println("堆排序结果：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}