基于Java大厂面试的排序算法真题（含源码）

在面试中，排序算法是评估候选人编程能力和算法理解的常见话题。以下是三道常见的排序算法面试题，它们不仅测试你对排序算法的理解，还涉及到算法优化和应用场景的考量。

题目1：实现快速排序

题目描述：
实现快速排序算法。快速排序是一种高效的排序算法，采用分治策略，将一个数组分为两个子数组，将两部分独立地排序。快速排序的平均时间复杂度为O(n log n)，但最坏情况下的时间复杂度为O(n^2)。

要求：

• 尽可能优化算法，以避免最坏情况的发生。
• 提供一个Java实现。
• 分析算法的时间复杂度和空间复杂度。

题目2：归并排序与数组逆序对

题目描述：
使用归并排序算法来计算一个数组中的逆序对数量。逆序对是数组中一对元素满足i < j且A[i] > A[j]。例如，在数组[2, 4, 1, 3, 5]中，逆序对有(2, 1), (4, 1), (4, 3)。

要求：

• 实现一个归并排序的变种，不仅能够排序，同时能够计算并返回数组中逆序对的数量。
• 提供一个Java实现。
• 分析你的算法的时间复杂度。

题目3：排序算法的稳定性分析

题目描述：
讨论常见排序算法（例如冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序）的稳定性，并给出每种算法稳定或不稳定的原因。

要求：

• 对于每种排序算法，说明其是否稳定，并简要解释原因。
• 对于不稳定的排序算法，如果可能，提出改进措施使其变为稳定。
• 提供相关分析或示例代码片段（可选）。

这些题目覆盖了排序算法的实现、应用和理论分析，是准备算法面试的好材料。在准备解答时，务必理解每个算法的工作原理、优缺点和适用场景，这不仅有助于回答面试题，也能够在实际开发中选择合适的算法。
基于上述题目描述，我将提供每个题目的Java实现源码。

快速排序实现

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

                // swap arr[i] and arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        // swap arr[i+1] and arr[high] (or pivot)
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;

        return i + 1;
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        int n = arr.length;

        quickSort(arr, 0, n-1);

        System.out.println("Sorted array: ");
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

归并排序与计算数组逆序对

public class MergeSortAndCount {
    private static int mergeAndCount(int[] arr, int l, int m, int r) {
        int[] left = Arrays.copyOfRange(arr, l, m + 1);
        int[] right = Arrays.copyOfRange(arr, m + 1, r + 1);

        int i = 0, j = 0, k = l, swaps = 0;

        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                arr[k++] = left[i++];
            } else {
                arr[k++] = right[j++];
                swaps += (m + 1) - (l + i);
            }
        }

        while (i < left.length) {
            arr[k++] = left[i++];
        }

        while (j < right.length) {
            arr[k++] = right[j++];
        }

        return swaps;
    }

    private static int mergeSortAndCount(int[] arr, int l, int r) {
        int count = 0;
        if (l < r) {
            int m = (l + r) / 2;

            count += mergeSortAndCount(arr, l, m);
            count += mergeSortAndCount(arr, m + 1, r);
            count += mergeAndCount(arr, l, m, r);
        }
        return count;
    }

    public static void main(String[] args) {
        int[] arr = {2, 4, 1, 3, 5};
        int n = arr.length;

        System.out.println("Number of inversions: " + mergeSortAndCount(arr, 0, n - 1));
    }
}

排序算法的稳定性分析

这个问题涉及的内容较为理论化，不适合直接提供源码。相反，我将给出简短的理论性描述：

• 冒泡排序：稳定。因为相等元素的相对位置在排序过程中不会改变。
• 选择排序：不稳定。选择排序每次将最小（或最大）元素放到排序序列的起始位置，这会改变相等元素的原始相对位置。
• 插入排序：稳定。对于相等的元素，插入排序不会将它们的相对顺序打乱。
• 归并排序：稳定。归并排序在合并两个有序数组时，如果遇到相等的元素，会先拷贝来自左边数组的元素，保持了其稳定性。
• 快速排序：不稳定。快速排序在分区过程中可能会改变相等元素的相对顺序。
• 堆排序：不稳定。在建堆和调整堆的过程中，相等元素的相对位置可能会被改变。

对于不稳定的排序算法，要使其变稳定，一种方法是增加一个额外的条件来判断相等元素的先后顺序，但这通常会增加算法的复杂度。例如，可以在元素比较时加入索引比较，但这需要额外的存储空间和逻辑。

快速排序

• 基本思想：快速排序使用分治策略来把一个序列分为两个子序列。具体步骤包括选择一个元素作为"基准"（pivot），重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。然后，递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
• 时间复杂度：平均O(n log n)，最坏O(n^2)。
• 空间复杂度：平均O(log n)，这是因为递归栈的空间。
• 稳定性：不稳定。

归并排序与计算数组逆序对

• 基本思想：归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。它将数组分成两半，对每部分递归地应用归并排序，然后将两个排序好的子列表合并成一个最终的排序列表。
• 逆序对：在归并排序中，逆序对的计算可以在合并两个已排序数组的过程中完成。当我们合并时，如果从右侧数组取出的元素先于左侧数组中的元素被添加到合并后的数组中，那么左侧数组中的当前元素以及所有未合并的元素都将形成逆序对。
• 时间复杂度：O(n log n)。
• 空间复杂度：O(n)，需要额外的数组来合并两个子数组。
• 稳定性：稳定。

排序算法的稳定性

• 定义：如果a原本在b前面，而a=b，排序之后a仍然在b的前面，则排序算法稳定。反之，如果排序算法不能保证这一点，则该排序算法不稳定。
• 稳定性的重要性：稳定性在某些场合下是非常重要的。比如，在对一列记录按照关键字排序时，希望相对次序不被改变，以保持数据的一致性。

通过理解这些排序算法的基本原理、时间和空间复杂度以及它们的稳定性，可以帮助你更好地准备面试和在实际开发中选择合适的排序方法。掌握这些算法的细节和差异，对于提高编程能力和算法理解都是极其重要的。