目录
🌟堆
✍1.堆的概念
（1）堆是一棵完全二叉树，主要分两种：最大堆和最小堆。最大堆：堆中的某个节点的值总是不大于其父节点的值，堆顶保存的是最大值；最小堆：堆中的某个节点的值总是不大于其父节点的值，堆顶保存的是最小值。
堆的性质：如果当前节点表示为k,节点从0开始编号：
- 如果父节点存在(k>0)，则父节点的编号为(k-1)/2;
- 如果左子树存在，则左孩子编号为(2k+1); 左子树存在条件：(2k+1<节点个数)
- 如果右子树存在，则右孩子编号为(2k+2)；右子树存在条件：(2k+2<节点个数)
（2）堆的存储方式：由于堆是一棵完全二叉树，所以可以采用层序顺序存储的方式进行。底层一般使用数组实现。
✍2.堆的常用方法
在实现堆的常用方法之前，我们首先需要先创建一个堆。前面说到，堆底层一般用数组实现，这里以最大堆为例，创建一个最大堆。类名为MaxHeap，主要包括数组的定义，堆中的元素个数以及构造方法。
同样的，根据堆的性质，通过给定的节点编号k，我们可以获取父节点，左孩子和右孩子的编号。
简单实现了上述框架，接下来我们就可以实现堆中的重点方法了~
2.1 向最大堆中添加元素
public void add(int val){
//不考虑元素值的大小，直接将新元素尾插到数组的尾部
this.data.add(val);
size++;
//然后调整元素的位置，使其满足最大堆的值之间的关系：元素上浮操作
siftUp(size-1);
}2.1 上浮
只有当当前节点还有父节点并且 当前值>父节点值，交换两者的位置。
public void siftUp(int k) {
while (k>0 && data.get(k) > data.get(parent(k))){
//交换该节点和父节点的位置
swap(k,parent(k));
//继续向上判断
k = parent(k);
}
}
private void swap(int i, int j) {
int temp = data.get(i);
data.set(i,data.get(j));
data.set(j,temp);
}2.2 下沉
元素下沉操作：
①比较当前节点的左右孩子的值，取出最大值索引记录
②最大值与当前节点值进行比较：如果当前节点值大，则不需要交换位置；否则交换两者的位置,更新当前节点的索引值。
代码实现：
public void siftDown(int k){//k是当前节点的索引,j是存储的最大值索引
//①获取最大值索引
// 如果只有左孩子存在，假设最大值为左孩子节点的编号
while (leftChild(k)<size){
int j = leftChild(k);
//如果还有右孩子存在，比较两个节点的值大小,更新最大值的索引
if(j+1 < size && data.get(j+1) > data.get(j)){
j = j+1;
}
//②值比较
if(data.get(k) >= data.get(j)){
break;
}else{
swap(k,j);
k = j;
}
}
}2.3 堆化
堆化：传入一个数组，能够还原成最大堆。
思想：我们可以认为最后的叶子节点每个都满足最大堆的要求(因为左右子树都是null)， 那从不断的从最后一个不是叶子节点的 节点让它满足最大堆，也就是元素下沉，使得每个子树为堆。
代码实现：
public MaxHeap(int[] arr){
data = new ArrayList<>(arr.length);//创建一个和给定数组一样大小的数组
//先将给定的数组放入堆中
for (int i : arr ) {
data.add(i);
size++;
}
//最后一个非叶子节点，也就是最后一个节点的父节点：最后一个节点 size-1
for (int i = parent(size-1); i >=0 ; i--) {
siftDown(i);
}
}2.4 取堆顶值
最大堆此时取得也就是最大值。注意取出堆顶的最大值之后，要将当前堆的最后一个元素顶到根节点，然后要从根节点开始将元素不断的下沉。
public int extractMax(){
if(data.isEmpty()){
throw new NoSuchElementException("heap is empty!cannot extract maxVal!");
}
//堆顶就是最大值
int val = data.get(0);
//将最后一个节点顶在根节点
data.set(0,data.get(size-1));
data.remove(size-1);
size--;
//从根节点开始下沉
siftDown(0);
return val;
}2.5 堆的插入
堆的插入：先将元素插入堆的末尾； 将最后新插入的节点向上调整，直到满足堆的性质。
public void add(int val){
//不考虑元素值的大小，直接将新元素尾插到数组的尾部
this.data.add(val);
size++;
//然后调整元素的位置，使其满足最大堆的值之间的关系：元素上浮操作
siftUp(size-1);
}✍3. 堆排序
public static void heapSort(int[] arr) {
// 1.heapify
for (int i = (arr.length - 1 - 1) / 2; i >= 0; i--) {
siftDown(arr,i,arr.length);
}
// 不断的将当前无序数组的最大值(堆顶) 和 最后一个元素进行交换~
for (int i = arr.length - 1; i >= 0; i--) {
// 将堆顶(最大值) 和 i交换
swap(arr,0,i);
// 进行元素的下沉操作
siftDown(arr,0,i);
}
}
// 在数组arr上进行元素的下沉操作
private static void siftDown(int[] arr, int k, int size) {
int j = 2 * k + 1;
while (j < size) {
if (j + 1 < size && arr[j + 1] > arr[j]) {
j = j + 1;
}
if (arr[k] >= arr[j]) {
// 下沉结束
break;
}else {
swap(arr,k,j);
k = j;
j = 2 * k + 1;
}
}
}
private static void swap(int[] arr,int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}完整代码：MaxHeap类
public class MaxHeap {
//定义吧保存元素的数组
private List<Integer> data;
//堆中有效元素的个数
private int size;
//构造函数:如果没有给出数组容量，默认为10
public MaxHeap(){
this(10);
}
//有参构造：传入参数确定数组的容量
public MaxHeap(int capacity){
this.data = new ArrayList<>(capacity);
}
/**
* 堆化：传入一个数组，能够还原成最大堆
* 思想：我们可以最后的叶子节点每个都满足最大堆的要求(因为左右子树都是null)，
* 那从不断的从最后一个不是叶子节点的 节点让它满足最大堆，也就是元素下沉，使得每个子树为堆
*/
public MaxHeap(int[] arr){
data = new ArrayList<>(arr.length);//创建一个和给定数组一样大小的数组
//先将给定的数组放入堆中
for (int i : arr ) {
data.add(i);
size++;
}
//最后一个非叶子节点，也就是最后一个节点的父节点：最后一个节点 size-1 父节点 (size-1-1)/2
for (int i = parent(size-1); i >=0 ; i--) {
siftDown(i);
}
}
/**
* 取出堆中的最大值
*/
public int extractMax(){
if(data.isEmpty()){
throw new NoSuchElementException("heap is empty!cannot extract maxVal!");
}
//堆顶就是最大值
int val = data.get(0);
//将最后一个节点顶在根节点
data.set(0,data.get(size-1));
data.remove(size-1);
size--;
//从根节点开始下沉
siftDown(0);
return val;
}
/**
* 向最大堆中添加元素
*/
public void add(int val){
//不考虑元素值的大小，直接将新元素尾插到数组的尾部
this.data.add(val);
size++;
//然后调整元素的位置，使其满足最大堆的值之间的关系：元素上浮操作
siftUp(size-1);
}
/**
* 元素上浮操作：只有当还有父节点并且 当前值>父节点值，交换两者的位置
*/
public void siftUp(int k) {
while (k>0 && data.get(k) > data.get(parent(k))){
//交换该节点和父节点的位置
swap(k,parent(k));
//继续向上判断
k = parent(k);
}
}
/**
* 元素下沉操作：
* ①比较当前节点的左右孩子的值，取出最大值索引记录
* ②最大值与当前节点值进行比较：如果当前节点值大，则不需要交换位置；否则交换两者的位置,更新当前节点的索引值
*/
public void siftDown(int k){//k是当前节点的索引,j是存储的最大值索引
//①获取最大值索引
// 如果只有左孩子存在，假设最大值为左孩子节点的索引
while (leftChild(k)<size){
int j = leftChild(k);
//如果还有右孩子存在，比较两个节点的值大小,更新最大值的索引
if(j+1 < size && data.get(j+1) > data.get(j)){
j = j+1;
}
//②值比较
if(data.get(k) >= data.get(j)){
break;
}else{
swap(k,j);
k = j;
}
}
}
/**
* 交换三连
*/
private void swap(int i, int j) {
int temp = data.get(i);
data.set(i,data.get(j));
data.set(j,temp);
}
/**
* 获取父节点
*/
private int parent(int k){
return (k-1)>>1;
}
/**
* 获取左孩子
*/
private int leftChild(int k){
return (k<<1)+1;
}
/**
* 获取右孩子
*/
private int rightChild(int k){
return (k<<1)+2;
}
/**
* 重写toString方法:底层已经重写好了
*/
@Override
public String toString() {
return this.data.toString();
}
}🌟优先级队列
队列是一种先进先出的数据结构。但是在有些情况下，操作的数据可能带有优先级，那么出队列时，就需要优先级高的元素先出队列。那么在这种情况下，数据结构应该提供两个最基本的操作：一个是返回最高优先级对象，另一个是添加新的对象，这种数据结构就是优先级队列(Priority Queue)。而优先级队列的底层使用的是堆。
✍用堆模拟实现优先级队列
public class MyPriorityQueue {
// 演示作用，不考虑扩容部分的代码
private int[] array = new int[100];
private int size = 0;
//入队
public void offer(int e) {
array[size] = e;//尾插
size++;
shiftUp(size - 1);//元素上浮操作
}
// 出队
public int poll() {
int oldValue = array[0];
array[0] = array[size];
size--；
shiftDown(0);
return oldValue;
}
//返回堆顶元素
public int peek() {
return array[0];
}
}
827
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
