思路
- 数组的下标实际上就代表了二叉树的节点位置
- 建立大顶堆的规则,就是要从最后一个叶子节点的父节点开始,依靠父节点与子节点的下表关系进行大小比较,进行调整。
- 在中间节点的时候,有时候调整好了,但是有可能子节点与子节点的子节点发生了规则违背,此刻依然需要进行调整。也就是进行递归操作。
/**
* 这个程序是将数组所有的元素直接构建堆
* <p>
* 最大堆:根是最大的,左右节点没有大小关系
* <p>
* 在这里最值得需要注意的点就是:buildMaxHeap(int[] arr,int len)中的len,它并不总是等于arr.length。
* 当我们在进行堆排序的时候,在输出堆头之后进行堆的调整,再次构建堆的时候,需要的数组长度就不是arr.length
*
* 用数组保存元素,并按照一定条件进行排序。以求高效率实现删除最大元素和插入元素操作。
*
* 完全二叉树,用数组的存储形式比较好构建二叉树。
*
* 这个堆排序的实现算法本质还是通过数组的下标来进行调整的
*
* 大顶堆规则:父节点比子节点都大,左右节点之间没有大小关系
*/
public class ZZ {
public static void main(String[] args) {
int[] arr = {2, 1, 5, 4, 6, 3, 7};
buildMaxHeap(arr, arr.length);
showArr(arr);//第一次构建大顶堆的输出结果:7 6 5 4 1 3 2
sortHeap(arr);
showArr(arr);//输出结果:1 2 3 4 5 6 7
}
//建立一个最大堆
static void buildMaxHeap(int[] arr, int len) {//len并不总是数组的真实长度,而是你想调整的数组的长度。
int last_node_index = len - 1;
int parent_node_index = (last_node_index - 1) / 2;
for (int i = parent_node_index; i >= 0; i--) {
heapifyOne(arr, len, i);
// heapifyOne(arr, len,i);//len并不总是数组的真实长度,而是你想调整的数组的长度。
}
}
//调整为二叉堆。我自己想出来的。明显我这个花费的时间和步骤会更多。也就是相比于heapifyOne()方法,我这个方法调整为二叉堆时候会移动更多的元素。
static public void heapify(int[] arr, int len, int parent_node_index) {//len并不总是数组的真实长度,而是你想调整的数组的长度。
int left_node_index = parent_node_index * 2 + 1;
int right_node_index = parent_node_index * 2 + 2;
if (left_node_index < len && arr[left_node_index] > arr[parent_node_index]) {
swap(arr, left_node_index, parent_node_index);
heapify(arr, len, left_node_index);
}
if (right_node_index < len && arr[right_node_index] > arr[parent_node_index]) {
swap(arr, right_node_index, parent_node_index);
heapify(arr, len, right_node_index);
}
}
//调整为二叉堆。他人的想法
static public void heapifyOne(int[] arr, int len, int parent_node_index) {//len//len并不总是数组的真实长度,而是你想调整的数组的长度。数组的真实长度,而是你想调整的数组的长度。
int left_node_index = parent_node_index * 2 + 1;
int right_node_index = parent_node_index * 2 + 2;
int max = parent_node_index;
if (left_node_index < len && arr[left_node_index] > arr[max]) {//易错点:这里必须写max而不是写parent_node_index。因为要确认左右子树与根的关系
max = left_node_index;
}
if (right_node_index < len && arr[right_node_index] > arr[max]) {
max = right_node_index;
}
if (max != parent_node_index) {
swap(arr, max, parent_node_index);
heapifyOne(arr, len, max);
}
}
//对堆进行排序。首先将第一个顶点输出,将第一个节点与最后一个节点交换,然后调整堆
static public void sortHeap(int[] arr) {
int len = arr.length;
for (int i = 0; i < len; i++) {
// showArr(arr);//输出每次调整的堆结构
swap(arr, 0, len - 1 - i);//交换的是坐标
// System.out.println("调整之后的最大元素"+arr[len-1-i]);
buildMaxHeap(arr, len - 1 - i);//建立堆:数组以及数组需要调整的长度。因为放在后面的最大元素我是不想再动的
}
}
//通过下标交换数组中的两个元素
public static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
//输出数组的元素
public static void showArr(int[] arr) {
System.out.print("依次输出数组的元素:");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}