近期在翻排序的算法,看到堆排序之后对比了菜鸟教程的和力扣大佬的题解之后,发现常用的递归维护堆貌似并不是最方便最容易理解的。下面提供力扣大佬的循环下沉维护堆版本(稍作修改)
力扣大佬版本
- 注释版:
class Solution {
/**
* 排序算法入口
* @param nums 待排序数组
*/
public int[] sortArray(int[] nums) {
int len = nums.length;
heapify(nums);
while (len>0){
swap(nums, 0, len---1);
down(nums, 0, len);
}
return nums;
}
/**
* 第一次最大堆排序
*/
void heapify(int[] nums) {
int len = nums.length;
// 这里为什么是从(len - 1) / 2开始? 因为除二之后是最后一个节点的父节点,而没有孩子的节点不需要下沉
for (int i = (len - 1) / 2; i >= 0; i--) {
down(nums, i, len);
}
}
/**
* 下沉函数,将小的数字全部下沉
* @param parent 父节点
* @param end 子节点
*/
void down(int[] nums, int parent, int end) {
while (parent * 2 + 1 < end) {
// 这里child是parent的左节点
int child = parent * 2 + 1;
// 如果右节点比左节点要大,那么用child++来选择右节点
if (child + 1 < end && nums[child + 1] > nums[child]) {
child++;
}
//对比父节点和子节点,交换
if(nums[parent]<nums[child]) {
swap(nums, parent, child);
}
parent = child;
}
}
void swap(int[] nums, int a, int b) {
int tmp = nums[b];
nums[b] = nums[a];
nums[a] = tmp;
}
}
- 无注释版:
class Solution {
public int[] sortArray(int[] nums) {
int len = nums.length;
heapify(nums);
while (len>0){
swap(nums, 0, len---1);
down(nums, 0, len);
}
return nums;
}
void heapify(int[] nums) {
int len = nums.length;
for (int i = (len - 1) / 2; i >= 0; i--) {
down(nums, i, len);
}
}
void down(int[] nums, int parent, int end) {
while (parent * 2 + 1 < end) {
int child = parent * 2 + 1;
if (child + 1 < end && nums[child + 1] > nums[child]) {
child++;
}
if(nums[parent]<nums[child]) {
swap(nums, parent, child);
}
parent = child;
}
}
void swap(int[] nums, int a, int b) {
int tmp = nums[b];
nums[b] = nums[a];
nums[a] = tmp;
}
}
本文深入解析了堆排序中的循环下沉维护堆版本,对比传统递归方法,提供了一种更直观的实现方式,适合初学者理解和实践。通过实例讲解了堆化过程和下沉操作,有助于提升算法理解能力。

被折叠的 条评论
为什么被折叠?



