快速排序

快速排序是一种高效的排序算法，采用分而治之的策略，其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
快速排序算法步骤：
1、选择基准值：从数列中挑出一个元素，称为"基准"（pivot）。
2、分区操作：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3、递归排序：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

Java代码示例：

public class QuickSort {

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            // 找到分区的下标
            int pivotIndex = partition(arr, low, high);

            // 递归调用，对左子数组进行快速排序
            quickSort(arr, low, pivotIndex - 1);
            // 递归调用，对右子数组进行快速排序
            quickSort(arr, pivotIndex + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        // 选择最后一个元素作为基准
        int pivot = arr[high];
        int i = (low - 1); // i是小于pivot元素的索引

        for (int j = low; j < high; j++) {
            // 如果当前元素小于或等于pivot
            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;
    }

    // 测试快速排序
    public static void main(String[] args) {
        int[] exampleArray = {10, 7, 8, 9, 1, 5};
        int n = exampleArray.length;
        quickSort(exampleArray, 0, n-1);
        System.out.println("Sorted array: ");
        for (int value : exampleArray) {
            System.out.print(value + " ");
        }
    }
}

冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止，这意味着该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
冒泡排序算法步骤：
1、比较相邻元素：从数列的第一个元素开始，对每一对相邻元素做比较。如果第一个比第二个大，就交换它们的位置。
2、遍历数列：对每一对相邻元素做同样的比较，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3、重复步骤：针对所有的元素重复以上的步骤，除了最后一个。
4、结束条件：持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

Java代码示例：

public class BubbleSort {

    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        boolean swapped; // 用于优化，记录一轮遍历中是否发生了交换

        for (int i = 0; i < n - 1; i++) {
            swapped = false;
            // 最后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;
                    swapped = true;
                }
            }
            // 如果在某次遍历中没有发生交换，说明数组已经是有序的了，可以提前结束循环
            if (!swapped) break;
        }
    }

    // 测试冒泡排序
    public static void main(String[] args) {
        int[] exampleArray = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(exampleArray);
        System.out.println("Sorted array:");
        for (int value : exampleArray) {
            System.out.print(value + " ");
        }
    }
}

堆排序

堆排序是一种基于比较的排序算法，它利用了完全二叉树的特性，特别是最大堆（父节点的值总是大于或等于其子节点的值）或最小堆（父节点的值总是小于或等于其子节点的值）来进行排序。堆排序包括两个主要步骤：构建堆和堆调整（排序）。
堆排序算法步骤：
1、构建最大堆：将待排序的序列构造成一个最大堆，此时，整个序列的最大值就是堆顶的根节点。
2、堆排序：将堆顶元素与末尾元素交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

Java代码示例：

public class HeapSort {

    // 用于调整索引为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);
        }
    }

    // 主函数执行堆排序
    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);
        }
    }

    // 测试堆排序
    public static void main(String[] args) {
        int[] exampleArray = {12, 11, 13, 5, 6, 7};
        heapSort(exampleArray);
        System.out.println("Sorted array is:");
        for (int value : exampleArray) {
            System.out.print(value + " ");
        }
    }
}

快排、冒泡、堆排序的对比及总结

快速排序（Quick Sort）
效率与复杂度：平均时间复杂度为O(n log n)，最好情况也是O(n log n)，但在最坏情况下（例如数组已经是有序的）会退化到O(n^2)。空间复杂度主要取决于递归深度，最坏情况下为O(n)，但平均情况下较好。
特点：采用了分治法的思想，通过一个划分操作将要排序的数组分为两个子数组，使得其中一个子数组的所有数据都比另一个子数组的所有数据要小，然后再递归地对这两个子数组进行快速排序。
适用场景：适用于大规模数据集，是实际应用中最常使用的排序算法之一，尤其是在数据随机分布的情况下表现优秀。

冒泡排序（Bubble Sort）
效率与复杂度：时间复杂度为O(n^2)，无论在最好、平均还是最坏情况下都是如此。空间复杂度为O(1)，是原地排序算法。
特点：通过重复遍历要排序的数列，比较每对相邻元素的值，如果顺序错误就交换它们的位置。遍历数列的工作重复进行，直到没有再需要交换的元素为止。
适用场景：由于其简单性，适用于数据量较小或基本有序的情况。不适合大规模数据排序，因为效率低下。

堆排序（Heap Sort）
效率与复杂度：时间复杂度为O(n log n)，不论是最好、最坏还是平均情况。空间复杂度为O(1)，也是原地排序算法。
特点：利用完全二叉树的性质，先将待排序序列构造成一个最大堆（或最小堆），然后将堆顶元素（即最大或最小元素）与末尾元素交换，调整剩余元素为新的堆，重复此过程直到整个序列变为有序。
适用场景：适合于大数据量的排序，特别是在内存受限的环境下，因为它不需要额外的存储空间。虽然在最坏情况下的性能与快速排序相似，但由于其稳定的O(n log n)时间复杂度，对于大数据集合来说更可靠。

总结

速度：快速排序通常最快，尤其在数据随机分布时；冒泡排序最慢；堆排序介于两者之间，但其性能更为稳定。
空间：冒泡排序和堆排序都是原地排序，空间效率高；快速排序在递归调用时会占用栈空间。
稳定性：冒泡排序是稳定的排序算法，而快速排序和堆排序都是不稳定的。
选择：根据数据规模、是否需要稳定性以及内存使用限制来选择合适的排序算法。对于小数据集或需要稳定性的场景，可以考虑冒泡排序；对于大规模数据且追求效率，快速排序通常是首选；在内存敏感且对稳定性无要求时，堆排序是不错的选择。