当前位置：首页 > news >正文

【java实现+4种变体完整例子】排序算法中【堆排序】的详细解析，包含基础实现、常见变体的完整代码示例，以及各变体的对比表格

news 来源：原创 2025/4/20 5:11:14

以下是堆排序的详细解析，包含基础实现、常见变体的完整代码示例，以及各变体的对比表格：
在这里插入图片描述

一、堆排序基础实现

原理

基于二叉堆结构（最大堆），通过以下步骤实现排序：

构建最大堆：将数组调整为一个最大堆，根节点为最大值。
提取最大值：将堆顶元素（最大值）与末尾元素交换，缩小堆范围，重新调整堆。
重复步骤2：直到堆为空。

代码示例

public class HeapSort {void sort(int[] arr) {int n = arr.length;// Build max heapfor (int i = n / 2 - 1; i >= 0; i--) {heapify(arr, n, i);}// Extract elements one by onefor (int i = n - 1; i >= 0; i--) {// Move current root to endint temp = arr[0];arr[0] = arr[i];arr[i] = temp;// Heapify the reduced heapheapify(arr, i, 0);}}// Recursive heapify to build a max heapprivate void heapify(int[] arr, int n, int i) {int largest = i; // Initialize largest as rootint left = 2 * i + 1;int right = 2 * i + 2;// If left child is larger than rootif (left < n && arr[left] > arr[largest]) {largest = left;}// If right child is larger than largest so farif (right < n && arr[right] > arr[largest]) {largest = right;}// If largest is not rootif (largest != i) {int swap = arr[i];arr[i] = arr[largest];arr[largest] = swap;// Recursively heapify the affected sub-treeheapify(arr, n, largest);}}
}

复杂度分析

时间复杂度：O(n log n)（所有情况）。
空间复杂度：O(log n)（递归调用栈空间）。
稳定性：不稳定（相同值的元素可能因交换顺序改变相对位置）。

二、常见变体及代码示例

1. 迭代实现（非递归）

改进点：用循环替代递归，减少栈空间开销。
适用场景：避免递归深度限制或优化性能。

public class IterativeHeapSort {void sort(int[] arr) {int n = arr.length;// Build max heapfor (int i = n / 2 - 1; i >= 0; i--) {iterativeHeapify(arr, n, i);}// Extract elements one by onefor (int i = n - 1; i >= 0; i--) {int temp = arr[0];arr[0] = arr[i];arr[i] = temp;iterativeHeapify(arr, i, 0);}}// Iterative heapify to build a max heapprivate void iterativeHeapify(int[] arr, int n, int i) {int largest = i;int left = 2 * i + 1;int right = 2 * i + 2;while (true) {if (left < n && arr[left] > arr[largest]) {largest = left;}if (right < n && arr[right] > arr[largest]) {largest = right;}if (largest == i) break;// Swap and continueint swap = arr[i];arr[i] = arr[largest];arr[largest] = swap;i = largest;left = 2 * i + 1;right = 2 * i + 2;}}
}

2. 最小堆实现

改进点：使用最小堆实现排序，需反转结果。
适用场景：需用最小堆结构的场景（如优先队列）。

public class MinHeapSort {void sort(int[] arr) {int n = arr.length;// Build min heapfor (int i = n / 2 - 1; i >= 0; i--) {heapify(arr, n, i);}// Extract elements one by one (ascending order requires reversal)for (int i = n - 1; i >= 0; i--) {int temp = arr[0];arr[0] = arr[i];arr[i] = temp;heapify(arr, i, 0);}reverse(arr); // Reverse to get ascending order}// Heapify for min heapprivate void heapify(int[] arr, int n, int i) {int smallest = i;int left = 2 * i + 1;int right = 2 * i + 2;if (left < n && arr[left] < arr[smallest]) {smallest = left;}if (right < n && arr[right] < arr[smallest]) {smallest = right;}if (smallest != i) {swap(arr, i, smallest);heapify(arr, n, smallest);}}private void reverse(int[] arr) {int left = 0, right = arr.length - 1;while (left < right) {swap(arr, left, right);left++;right--;}}private void swap(int[] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
}

3. 原地堆排序优化

改进点：减少比较次数，优化堆调整过程。
适用场景：追求极致性能的场景。

public class OptimizedHeapSort {void sort(int[] arr) {int n = arr.length;// Build max heap with reduced comparisonsfor (int i = n / 2 - 1; i >= 0; i--) {heapify(arr, n, i);}// Extract elements one by onefor (int i = n - 1; i >= 0; i--) {swap(arr, 0, i);heapify(arr, i, 0);}}// Optimized heapify to reduce comparisonsprivate void heapify(int[] arr, int n, int i) {while (true) {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) break;swap(arr, i, largest);i = largest;}}private void swap(int[] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
}

三、变体对比表格

变体名称	时间复杂度	空间复杂度	稳定性	主要特点	适用场景
基础堆排序（递归）	`O(n log n)`	`O(log n)`	不稳定	递归实现，简单直观	通用排序，需避免栈溢出时需迭代版
迭代堆排序	`O(n log n)`	`O(1)`	不稳定	无递归，减少栈空间开销	需避免递归深度限制的场景
最小堆实现	`O(n log n)`	`O(1)`	不稳定	使用最小堆并反转结果，适合特定需求	需最小堆结构或特殊排序需求
原地优化堆排序	`O(n log n)`	`O(1)`	不稳定	减少比较次数，提升性能	高性能要求场景