数据结构优先级队列（堆）---学习笔记

一个很酷的女巫_

于 2022-04-09 17:40:40 发布

阅读量1.7k

点赞数

分类专栏： Java基础及ds学习笔记文章标签：数据结构 p2p 算法

本文链接：https://blog.csdn.net/weixin_48271092/article/details/121982203

版权

Java基础及ds学习笔记专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、堆（heap）

1.1 概念

1.堆在结构上是一颗完全二叉树。

2.从节点值看：

根节点的值一定不小于左右子树的节点值——大根堆（最大堆）

根节点的值一定不大于左右子树的节点值——小根堆（最小堆）

3.堆在物理上是保存在数组中

4.堆的实现基本都是基于二叉树——二叉堆。

判断一棵二叉树是不是堆，从两点出发，首先看它的结构是否一棵完全二叉树，然后看根节点的值与左右子树节点值的大小关系，若根节点>=左右子树，则为最大堆，若根节点 <=左右子树，则为最小堆。

相同的数据可以构建成多种类型的堆。

堆是用数组存储，因此编号就表示元素在数组中对应的下标，存储的方式有两种：

1、

数组中索引从1 开始存储堆节点，对于一个索引值为k的节点（k>0),他的parent（k)=k/2,left(child k)=k*2,right(child k)=k*2+1。

2、

数组中索引从0开始存储堆节点，对于对于一个索引值为k的节点（k>0),他的parent（k)=k/2,left(child k)=k*2+1,right(child k)=k*2+2。

1.2 在堆中添加一个元素——元素上浮-siftUp()

1.向数组末尾添加一个元素data[size]=val;

2.调整添加后堆的节点，使其仍然满足堆的性质：siftUp(int k),k就是当前需要上浮的节点索引。

3.在k>0且当前k对应的值大于其父节点值的情况下，循环交换当前的节点值和其父节点的值，直到满足堆的性质结束循环。

import java.awt.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 基于数组实现的最大堆
 * 编号从0开始，编号对应数组的下标index,index>0;
 * 父节点=index-1/2
 * 若有左右孩子，保证2*index+1或2*index+2<data.length
 * 左孩子=2*index+1  右孩子=2*index+2
 */
public class MaxHeap {
    private ArrayList<Integer> data;
    public MaxHeap() {
        data=new ArrayList<>();
    }
    public MaxHeap(int capacity){
        data=new ArrayList<>(capacity);
    }

    //heapify
    //TODO
    public MaxHeap(int[] arr){
        data=new ArrayList<>(arr.length);
    }
    public boolean isEmpty(){
        return data.size()==0;
    }

    //三个私有方法
    //获取父节点的索引
    private int parent(int k){
        return (k-1)/2;
    }
    //获取左孩子的索引
    private int left(int k){
        return  2*k+1;
    }
    //获取右孩子的索引
    private int right(int k){
        return 2*k+2;
    }

    //增删改查
    //增加元素 上浮操作
    public void add(int val){
        data.add(val);
        siftUp(data.size()-1);
    }

 

    /**
     * 元素的上浮操作
     * @param i 当前要上浮的元素下标
     */
    private void siftUp(int i) {
        while (i > 0 && data.get(i) > data.get(parent(i))) {
            swap(i, parent(i));
            //继续向上判断i是否需要交换
            i = parent(i);
        }
    }
    //交换当前数组中i和parent的值
    private void swap(int i, int parent) {
        int tmp=data.get(i);
        int parentVal=data.get(parent);
        data.set(i,parentVal);
        data.set(parent,tmp);
    }

   
    @Override
    public String toString() {
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append("[");
        for (int i = 0; i < data.size(); i++) {
            stringBuilder.append(data.get(i));
            if(i!=data.size()-1){
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}

1.3 在堆中取出元素的最大值——数组下沉-siftDown()

1.直接从堆顶取出元素，就是最大值；

2.删除堆顶元素，然后对剩下的节点进行调整，使其仍然满足堆的性质。

3.在删除完堆顶元素后，将数组最后一个节点移到堆顶，并删除最后一个节点，然后开始元素下沉-siftDown(int k),在满足左节点和右节点都存在的情况下，判断左节点和右节点的大小，大的与下标为k的节点进行交换，一直循环直到满足堆的性质。

import java.awt.*;
import java.util.ArrayList;
import java.util.List;

/**
 * 基于数组实现的最大堆
 * 编号从0开始，编号对应数组的下标index,index>0;
 * 父节点=index-1/2
 * 若有左右孩子，保证2*index+1或2*index+2<data.length
 * 左孩子=2*index+1  右孩子=2*index+2
 */
public class MaxHeap {
    private ArrayList<Integer> data;
    public MaxHeap() {
        data=new ArrayList<>();
    }
    public MaxHeap(int capacity){
        data=new ArrayList<>(capacity);
    }

    //heapify
    //TODO
    public MaxHeap(int[] arr){
        data=new ArrayList<>(arr.length);
    }
    public boolean isEmpty(){
        return data.size()==0;
    }

    //三个私有方法
    //获取父节点的索引
    private int parent(int k){
        return (k-1)/2;
    }
    //获取左孩子的索引
    private int left(int k){
        return  2*k+1;
    }
    //获取右孩子的索引
    private int right(int k){
        return 2*k+2;
    }

    //增删改查
    //增加元素 上浮操作
    public void add(int val){
        data.add(val);
        siftUp(data.size()-1);
    }

    /**
     * 取出当前堆的最大值
     * 继续调整当前堆，使其满足堆的节点性质
     */
    public int  extractMax(){
        if(isEmpty()){
            System.out.println("heap is empty!");
        }
        int max=data.get(0);
        data.set(0,data.get(data.size()-1));
        data.remove(data.size()-1);
        siftDown(0);
        return max;
    }

    /**
     *元素的下沉操作
     * @param i 当前要下沉的元素下标
     */
    private void siftDown(int i) {
        //左子树存在
        while (left(i)<data.size()){
            int j=left(i);
            //右子树也存在
            if(right(i)< data.size()){
                int leftVal=data.get(left(i));
                int rightVal=data.get(right(i));
                if(leftVal<rightVal){
                    j=j+1;
                }
            }
            if(data.get(i)>=data.get(j)){
                //当前节点已经大于左右孩子，下沉结束
                break;
            }else {
                swap(i,j);
                i=j;
            }
        }
    }


    //交换当前数组中i和parent的值
    private void swap(int i, int parent) {
        int tmp=data.get(i);
        int parentVal=data.get(parent);
        data.set(i,parentVal);
        data.set(parent,tmp);
    }


    @Override
    public String toString() {
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append("[");
        for (int i = 0; i < data.size(); i++) {
            stringBuilder.append(data.get(i));
            if(i!=data.size()-1){
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}

这样子操作元素的下沉和上浮，时间复杂度为O(n*logn)。

1.4 堆化（heapify）

给我们一个任意数组，逻辑上可以看成一棵完全二叉树，但不是一个堆，现在我们将它堆化。

堆化：从最后一个非叶子节点开始，进行子树的siftDown操作，直到调整到根节点为止，就可以调整成堆。堆化的操作一次性砍掉了所有的叶子节点，是一个自底向上调整堆的过程。

堆化的时间复杂度为O(n)。

public class MaxHeap {
    private ArrayList<Integer> data;
    public MaxHeap() {
        data=new ArrayList<>();
    }
    public MaxHeap(int capacity){
        data=new ArrayList<>(capacity);
    }

    //heapify
    public MaxHeap(int[] arr){
        data=new ArrayList<>(arr.length);
        for (int i:arr) {
            data.add(i);
        }
        for (int i =parent(data.size()-1) ; i >=0; i--) {
            siftDown(i);
        }
    }
    public boolean isEmpty(){
        return data.size()==0;
    }

    //三个私有方法
    //获取父节点的索引
    private int parent(int k){
        return (k-1)/2;
    }
    //获取左孩子的索引
    private int left(int k){
        return  2*k+1;
    }
    //获取右孩子的索引
    private int right(int k){
        return 2*k+2;
    }

    //增删改查
    //增加元素 上浮操作
    public void add(int val){
        data.add(val);
        siftUp(data.size()-1);
    }

    /**
     * 取出当前堆的最大值 
     * 继续调整当前堆，使其满足堆的节点性质
     */
    public int  extractMax(){
        if(isEmpty()){
            System.out.println("heap is empty!");
        }
        int max=data.get(0);
        data.set(0,data.get(data.size()-1));
        data.remove(data.size()-1);
        siftDown(0);
        return max;
    }



  
    //交换当前数组中i和parent的值
    private void swap(int i, int parent) {
        int tmp=data.get(i);
        int parentVal=data.get(parent);
        data.set(i,parentVal);
        data.set(parent,tmp);
    }

    /**
     *元素的下沉操作
     * @param i 当前要下沉的元素下标
     */
    private void siftDown(int i) {
        //左子树存在
        while (left(i)<data.size()){
            int j=left(i);
            //右子树也存在
            if(right(i)< data.size()){
                int leftVal=data.get(left(i));
                int rightVal=data.get(right(i));
                if(leftVal<rightVal){
                    j=j+1;
                }
            }
            if(data.get(i)>=data.get(j)){
                //当前节点已经大于左右孩子，下沉结束
                break;
            }else {
                swap(i,j);
                i=j;
            }
        }
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append("[");
        for (int i = 0; i < data.size(); i++) {
            stringBuilder.append(data.get(i));
            if(i!=data.size()-1){
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }
}
Test：
public class MaxHeapTest {
    public static void main(String[] args) {
        int[] arr={17,90,68,12,15,14,70,30,20};
        MaxHeap heap=new MaxHeap(arr);

        for (int i = 0; i <arr.length ; i++) {
            arr[i]=heap.extractMax();
        }
        System.out.println(Arrays.toString(arr));
   }
}
//执行结果：
[90, 70, 68, 30, 20, 17, 15, 14, 12]

2.优先级队列

优先级队列是基于堆的实现，优先级队列的入队列与普通的队列一样，但是出队列是按照优先级出队列。因此入队就是堆的添加元素，进行元素上浮的操作，出队就是按照优先级的高低进行出队，然后进行元素的下沉操作。

public class PriorityQueue implements Queue {
    MaxHeap heap=new MaxHeap();
    @Override
    public void offer(int value) {
        heap.add(value);
    }

    @Override
    public int poll() {
        return heap.extractMax();
    }

    @Override
    public int peek() {
        return heap.peekHeap();
    }

    @Override
    public boolean isEmpty() {
        return heap.isEmpty();
    }
}

Test:
public class QueueTest {
    public static void main(String[] args) {
        int[] arr={3,5,2,1,7,6,9,8};
        Queue queue=new PriorityQueue();
        for (int i :arr) {
            queue.offer(i);
        }
        for (int i = 0; i < arr.length; i++) {
            arr[i]=queue.poll();
        }
        System.out.println(Arrays.toString(arr));
    }
}
//执行结果：
[9, 8, 7, 6, 5, 3, 2, 1]

以上是我们自定义的优先级队列，是以最大堆实现的，但是JDK内置的优先级队列是基于最小堆实现的。因此我们在使用JDK内置的优先级队列时，若传入的时自定义类型，如Student类，要么向优先级队列中传入该类的比较器，要么自定义类型实现了comparable接口。但是JDK内置的类，如String、包装类，自动覆写了comparable接口，可以直接比较。

一个很酷的女巫_

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
数据结构优先级队列（堆）---学习笔记

一、堆（heap）1.1 概念1.堆在结构是一颗完全二叉树。2.从节点值看：根节点的值一定不小于左右子树的节点值——大根堆（最大堆）根节点的值一定不大于左右子树的节点值——小根堆（最小堆）3.堆在物理上是保存在数组中4.堆的实现基本都是基于二叉树——二叉堆。判断一棵二叉树是不是堆从两点出发，首先看它的结构是否一棵完全二叉树，然后看根节点的值与左右子树节点值的大小关系，若根节点>=左右子树，则为最大堆，若根节点<=左右子树，则为最小堆。...
复制链接

扫一扫