数据结构基础知识【八】：优先级队列

最新推荐文章于 2022-05-19 10:56:52 发布
最新推荐文章于 2022-05-19 10:56:52 发布
阅读量747 收藏
点赞数
分类专栏： 数据结构 文章标签： 队列 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45605223/article/details/105562173
版权

优先级队列

1.概念：队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该中场景下，使用队列显然不合适，在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象，这种数据结构就是优先级队列(Priority Queue)。
Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的。
2.PriorityQueue的特性：
（1）使用时必须导入PriorityQueue所在的包，即：

import java.util.PriorityQueue;

（2）PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出ClassCastException异常
（3） 不能插入null对象，否则会抛出NullPointerException
（4）没有容量限制，可以插入任意多个元素，其内部可以自动扩容
（5）插入和删除元素的时间复杂度为O(log2N) 【log以2为底的N】
（6）PriorityQueue底层使用了堆数据结构
3.PriorityQueue的常用构造方法：

构造器功能介绍
PriorityQueue()创建一个空的优先级队列，默认容量是11
PriorityQueue(int initialCapacity)创建一个初始容量为initialCapacity的优先级队列，注意：initialCapacity不能小于1，否则会抛IllegalArgumentException异常
PriorityQueue(Collection<? extends E>c)用一个集合来创建优先级队列

代码实现：

import java.util.PriorityQueue;
public class TestPriorityQueue {
    public static void TestPriorityQueue() {
        //1.构造一个空的优先级队列   注意：空的优先级队列，但是底层已经有了11个默认空间;
        PriorityQueue<Integer> p1 = new PriorityQueue<>();
        //2.按照指定容量来进行构造
        PriorityQueue<Integer> p2 = new PriorityQueue<>(20);
        //3.可以用一个集合来直接构造优先级队列，将来就会将集合中的元素放到优先级队列中
        List<Integer> L = new ArrayList<>();
        L.add(4);
        L.add(0);
        L.add(3);
        L.add(2);
        L.add(1);
        System.out.println(L);
        PriorityQueue<Integer> p3 = new PriorityQueue<>(L);
        System.out.println(p3.size());
    }
}

4.PriorityQueue的常用方法：

函数名功能介绍
boolean offer(E e)插入元素e，插入成功返回true，如果e对象为空，抛出NullPointerException异常，时间复杂度，注意：空间不够时候会进行扩容
E peek()获取优先级最高的元素，如果优先级队列为空，返回null
E poll()移除优先级最高的元素并返回，如果优先级队列为空，返回null
int size()获取有效元素的个数
void clear()清空
boolean isEmpty()检测优先级队列是否为空，空返回true

代码实现：

import java.util.PriorityQueue;
public class TestPriorityQueue {
    public static void TestPriorityQueue(){
        PriorityQueue<Integer> p =new PriorityQueue<>();
        p.offer(4);
        p.offer(1);
        p.offer(3);
        p.offer(0);
        p.offer(5);
        p.offer(2);
        System.out.println(p);
        //peek();取优先级队列中第一个（最小的）元素
        //poll();删除优先级队列中第一个元素（最小的）元素
        //       剩余元素会自动进行调整---->将剩余元素中最小的元素调整到首元素位置
        System.out.println(p.peek());
        p.poll();
        System.out.println(p.peek());
        p.poll();
        System.out.println(p.peek());
        System.out.println(p.size());
        p.clear();
        if (p.isEmpty()){
            System.out.println("优先级队列已经为空");
        }
        else{
            System.out.println("优先级队列不为空");
        }
    }
    public static void main(String[] args) {
        TestPriorityQueue();
    }
}
//打印结果：
/*
[0, 1, 2, 4, 5, 3]
0
1
2
4
优先级队列已经为空
*/

5.top-k问题：
力扣：最小的K个数
设计一个算法，找出数组中最小的k个数。以任意顺序返回这k个数均可。

class Solution {
    public int[] smallestK(int[] arr, int k) {
        if(arr == null || k <= 0){
            return new int[0];
        }
        PriorityQueue<Integer> p = new PriorityQueue<>(arr.length);
        for(int i = 0; i < arr.length; ++i){
            p.offer(arr[i]);
        }
        int[] ret = new int[k];
        for(int i = 0;i < k; ++i){
            ret[i] = p.peek();
            p.poll();
        }
        return ret;
    }
}

优先级队列的模拟实现

堆

1.概念：
如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为 小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。
2.性质：
（1）堆中某个节点的值总是不大于或不小于其父节点的值；
（2）堆总是一棵完全二叉树。
3.堆的储存：
堆是一棵完全二叉树，因此可以层序的规则采用顺序的方式来高效存储，注意：对于非完全二叉树，则不适合使用顺序方式进行存储，因为为了能够还原二叉树，空间中必须要存储空节点，就会导致空间利用率比较低。
4.小堆的性质：
（1）堆顶元素一定是最小的
（2）每个节点都比其孩子小
（3）每条路径都是升序
（4）堆是一棵完全二叉树，一般将其存储在数组中
5.堆的创建及向下调整：
（小堆）
（1） 让parent标记需要调整的节点，child标记parent的左孩子(注意：parent如果有孩子一定先是有左孩子)
（2） 如果parent的左孩子存在，即:child < size， 进行以下操作，直到parent的左孩子不存在
<1> parent右孩子是否存在，存在找到左右孩子中最小的孩子，让child进行标
<2> 将parent与较小的孩子child比较，如果：parent小于较小的孩子child，调整结束
否则：交换parent与较小的孩子child，交换完成之后，parent中大的元素向下移动，可能导致子树不满足对的性质，因此需要继续向下调整，即parent = child；child = parent*2+1; 然后继续 （2） 。
代码实现：2

public class MyPriorityQueue {
	private int[] array;
    public MyPriorityQueue(){
        array = new int[11];
        size = 0;
    }
	public MyPriorityQueue(int[] arr){
        array = new  int[arr.length];
        for (int i = 0;i < arr.length; ++i ){
            array[i] = arr[i];
        }
        //将array中的元素调整，满足小堆的性质
         //找倒数第一个非叶子节点
        int lastLeaf = (array.length-2)>>1;
        for (int root = lastLeaf; root>=0;root--){
            shifDown(root);
        }
     }
     //parent表示本次需要调整的节点的下标，调整以parent为根的二叉树
    //注意：调整之前，一定要保证parent的左右子数已经满足小堆的性质
     // 如果要检测parent是否满足小堆的性质，只需要使用parent与其孩子进行比较
    //满足小堆性质----》说明以parent为根的二叉树已经是小堆
    //不满足小堆的性质---》说明parent比其孩子大，此时需要将parent与其较小的孩子进行交换
    //交换完以后，parent较大的元素向下移动，可能导致其子树不满足小堆的性质
    //需要继续调整其子树
     private void shifDown(int parent) {
        //使用child标记parent的较小的孩子
         //默认情况下先让其标记左孩子，因为parent可能有左孩子但是没有右孩子
         int child = parent * 2 + 1;
         while (child < size) {
             //找parent中较小的孩子
             //在用左右孩子比较时，必须保证右孩子存在--while循环条件已经保证了左孩子存在
             if (child + 1 < size && array[child + 1] < array[child]) {
                 child += 1;
             }
             //检测较小的孩子是否比双亲小
             if (array[child] < array[parent]) {
                 //说明parent不满足小堆的性质
                 swap(parent, child);
                 //parent较大的元素向下移动，可能导致其子树不满足小堆的性质
                 //继续向下调整
                 parent = child;
                 child = parent * 2 + 1;
             } else {
                 //以parent为根的二叉树已经满足堆的性质
                 return;
             }
         }
     }

     private void swap(int parent, int child){
        int temp = array[parent];
        array[parent] = array[child];
        array[child] = temp;
     }
}

从根一路比较到叶子，比较的次数为完全二叉树的高度，即时间复杂度为在这里插入图片描述

6.堆的插入：
（1） 先将元素放入到底层空间中(注意：空间不够时需要扩容)
（2） 将最后新插入的节点向上调整，直到满足堆的性质。
优先级队列的扩容说明：
（1） 如果容量小于64时，是按照oldCapacity2 + 2的方式扩容的
（2） 如果容量大于等于64，是按照oldCapacity2的方式扩容的
（3） 如果容量超过MAX_ARRAY_SIZE，按照MAX_ARRAY_SIZE来进行扩容
代码实现：

public class MyPriorityQueue {
    private int[] array;
    private int size = 0;
    public MyPriorityQueue(){
        array = new int[11];
        size = 0;
    }
     boolean offer(int x){
        //0.检测是否需要扩容
         if (size>=array.length){
             grow();
         }
        //1.先将元素尾插到数组中
         array[size++] = x;
         //2.检测新元素插入后是否破坏小堆的性质
         shifUp(size-1);//注意：此处一定不能使用size--;
        return true;

     }  
     private void shifUp(int child){
        int parent = (child-1)>>1;
        while (child!=0){
            if (array[child] < array[parent]){
                swap(child,parent);
                child = parent;
                parent = (child-1)>>1;
            }else {
                return;
            }
        }
        //扩容
    //知识模拟标准库中优先级队列扩容的一部分
     private void grow(){
        int oldCapacity = array.length;
        int newCapacity = oldCapacity +( (oldCapacity < 64)?(oldCapacity+2):(oldCapacity>>1));
        array = Arrays.copyOf(array,newCapacity);
     }
     private void swap(int parent, int child){
        int temp = array[parent];
        array[parent] = array[child];
        array[child] = temp;
     }
}

7.堆的删除：
（1） 将堆顶元素对堆中最后一个元素交换
（2） 将堆中有效数据个数减少一个
（3） 对堆顶元素进行向下调整
代码实现：

     //删除：删除堆顶的元素
     int poll(){
        int ret = array[0];
        swap(0,size-1);
        size--;
        shifDown(0);
        return 0;
     }

用堆模拟实现优先级队列

代码实现：

public class MyPriorityQueue {
    private int[] array;
    private int size = 0;
    public MyPriorityQueue(){
        array = new int[11];
        size = 0;
    }
    public MyPriorityQueue(int initCapacity){
        if (initCapacity < 1) {
            initCapacity = 11;
        }
        array = new int[initCapacity];
        size = 0;
    }
    //标准库中没有该接口
     public  MyPriorityQueue(int[] arr){
        array = new  int[arr.length];
        for (int i = 0;i < arr.length; ++i ){
            array[i] = arr[i];
        }
        size = array.length;
        //将array中的元素调整，满足小堆的性质
        //找倒数第一个非叶子节点
        int lastLeaf = (array.length-2)>>1;
        for (int root = lastLeaf; root>=0;root--){
            shifDown(root);
        }
    }
    //获取堆顶元素
     int peek(){
        //标准库中，如果优先级队列是空，无法获取堆顶元素，因此返回的是空null
        return array[0];
     }
     //向优先级队列中插入元素
     boolean offer(int x){
        //0.检测是否需要扩容
         if (size>=array.length){
             grow();
         }
        //1.先将元素尾插到数组中
         array[size++] = x;
         //2.检测新元素插入后是否破坏小堆的性质
         shifUp(size-1);//注意：此处一定不能使用size--;
        return true;

     }
     //删除：删除堆顶的元素
     int poll(){
        int ret = array[0];
        swap(0,size-1);
        size--;
        shifDown(0);
        return 0;
     }
     boolean isEmpty(){
        return 0 == size;
     }
     int size(){
        return size;
     }
     void clear(){
        size = 0;
     }
     private void shifUp(int child){
        int parent = (child-1)>>1;
        while (child!=0){
            if (array[child] < array[parent]){
                swap(child,parent);
                child = parent;
                parent = (child-1)>>1;
            }else {
                return;
            }
        }
     }
     //扩容
    //知识模拟标准库中优先级队列扩容的一部分
     private void grow(){
        int oldCapacity = array.length;
        int newCapacity = oldCapacity +( (oldCapacity < 64)?(oldCapacity+2):(oldCapacity>>1));
        array = Arrays.copyOf(array,newCapacity);
     }
     //parent表示本次需要调整的节点的下标，调整以parent为根的二叉树
    //注意：调整之前，一定要保证parent的左右子数已经满足小堆的性质
     // 如果要检测parent是否满足小堆的性质，只需要使用parent与其孩子进行比较
    //满足小堆性质----》说明以parent为根的二叉树已经是小堆
    //不满足小堆的性质---》说明parent比其孩子大，此时需要将parent与其较小的孩子进行交换
    //交换完以后，parent较大的元素向下移动，可能导致其子树不满足小堆的性质
    //需要继续调整其子树
     private void shifDown(int parent) {
        //使用child标记parent的较小的孩子
         //默认情况下先让其标记左孩子，因为parent可能有左孩子但是没有右孩子
         int child = parent * 2 + 1;
         while (child < size) {
             //找parent中较小的孩子
             //在用左右孩子比较时，必须保证右孩子存在--while循环条件已经保证了左孩子存在
             if (child + 1 < size && array[child + 1] < array[child]) {
                 child += 1;
             }
             //检测较小的孩子是否比双亲小
             if (array[child] < array[parent]) {
                 //说明parent不满足小堆的性质
                 swap(parent, child);
                 //parent较大的元素向下移动，可能导致其子树不满足小堆的性质
                 //继续向下调整
                 parent = child;
                 child = parent * 2 + 1;
             } else {
                 //以parent为根的二叉树已经满足堆的性质
                 return;
             }
         }
     }
     private void swap(int parent, int child){
        int temp = array[parent];
        array[parent] = array[child];
        array[child] = temp;
     }
    public static void main(String[] args) {
        int array[] = {5,3,7,1,4,6,8,0,2};
        MyPriorityQueue mp = new MyPriorityQueue(array);
        mp.offer(9);
        System.out.println(mp.peek());
        System.out.println(mp.size());
        mp.offer(-1);
        System.out.println(mp.peek());
        System.out.println(mp.size());
        mp.poll();
        System.out.println(mp.peek());
        System.out.println(mp.size());
        mp.clear();
        if (mp.isEmpty()){
            System.out.println("空");
        }else {
            System.out.println("非空");
        }
    }
}
//打印结果
/*
10
-1
11
0
10
空
*/

运用比较器的优先级队列的实现

import java.util.Arrays;

/**
 * @ClassName MyPriorityQueue
 * @Description TODO MyPriorityQueue
 * @Author 张洋
 * @Date 2020/3/26 16:03
 * @Version 2018.1.5
 **/
interface Comp{
    public int compare(int left,int right);
}
class Less implements Comp {
    public int compare(int left,int right){
        return left - right;
    }
}
class Greater implements Comp{
    public int compare(int left,int right){
        return right - left;
    }
}
public class MyPriorityQueue {
    private int[] array;
    private int size = 0;
    Comp compare = null;
    public MyPriorityQueue(Comp com){
        array = new int[11];
        compare = com;
    }
    public MyPriorityQueue(int initCapacity,Comp com){
        if (initCapacity < 1) {
            initCapacity = 11;
        }
        array = new int[initCapacity];
        compare = com;
    }


    //标准库中没有该接口
     public  MyPriorityQueue(int[] arr,Comp com){
        array = new  int[arr.length];
        for (int i = 0;i < arr.length; ++i ){
            array[i] = arr[i];
        }
        size = array.length;
         compare = com;
        //将array中的元素调整，满足小堆的性质
        //找倒数第一个非叶子节点
        int lastLeaf = (array.length-2)>>1;
        for (int root = lastLeaf; root>=0;root--){
            shifDown(root);
        }
    }
    //获取堆顶元素
     int peek(){
        //标准库中，如果优先级队列是空，无法获取堆顶元素，因此返回的是空null
        return array[0];
     }
     //向优先级队列中插入元素
     boolean offer(int x){
        //0.检测是否需要扩容
         if (size>=array.length){
             grow();
         }
        //1.先将元素尾插到数组中
         array[size++] = x;
         //2.检测新元素插入后是否破坏小堆的性质
         shifUp(size-1);//注意：此处一定不能使用size--;
        return true;

     }
     //删除：删除堆顶的元素
     int poll(){
        int ret = array[0];
        swap(0,size-1);
        size--;
        shifDown(0);
        return 0;
     }
     boolean isEmpty(){
        return 0 == size;
     }
     int size(){
        return size;
     }
     void clear(){
        size = 0;
     }
     private void shifUp(int child){
        int parent = (child-1)>>1;
        while (child!=0){
            //if (array[child] < array[parent]){
            if (compare.compare(array[child],array[parent]) < 0){
                swap(child,parent);
                child = parent;
                parent = (child-1)>>1;
            }else {
                return;
            }
        }
     }
     //扩容
    //知识模拟标准库中优先级队列扩容的一部分
     private void grow(){
        int oldCapacity = array.length;
        int newCapacity = oldCapacity +( (oldCapacity < 64)?(oldCapacity+2):(oldCapacity>>1));
        array = Arrays.copyOf(array,newCapacity);
     }
     //parent表示本次需要调整的节点的下标，调整以parent为根的二叉树
    //注意：调整之前，一定要保证parent的左右子数已经满足小堆的性质
     // 如果要检测parent是否满足小堆的性质，只需要使用parent与其孩子进行比较
    //满足小堆性质----》说明以parent为根的二叉树已经是小堆
    //不满足小堆的性质---》说明parent比其孩子大，此时需要将parent与其较小的孩子进行交换
    //交换完以后，parent较大的元素向下移动，可能导致其子树不满足小堆的性质
    //需要继续调整其子树
     private void shifDown(int parent) {
        //使用child标记parent的较小的孩子
         //默认情况下先让其标记左孩子，因为parent可能有左孩子但是没有右孩子
         int child = parent * 2 + 1;
         while (child < size) {
             //找parent中较小的孩子
             //在用左右孩子比较时，必须保证右孩子存在--while循环条件已经保证了左孩子存在
             //if (child + 1 < size && array[child + 1] < array[child]) {
             if (child+1 < size && compare.compare(array[child+1],array[child]) < 0){
                 child += 1;
             }
             //检测较小的孩子是否比双亲小
             //if (array[child] < array[parent]) {
             if (compare.compare(array[child],array[parent]) < 0){
                 //说明parent不满足小堆的性质
                 swap(parent, child);
                 //parent较大的元素向下移动，可能导致其子树不满足小堆的性质
                 //继续向下调整
                 parent = child;
                 child = parent * 2 + 1;
             } else {
                 //以parent为根的二叉树已经满足堆的性质
                 return;
             }
         }
     }

     private void swap(int parent, int child){
        int temp = array[parent];
        array[parent] = array[child];
        array[child] = temp;
     }

    public static void main(String[] args) {
        int array[] = {5,3,7,1,4,6,8,0,2};
        MyPriorityQueue mp = new MyPriorityQueue(array,new Less()); //new Less()小堆，new Greater()大堆
        mp.offer(9);
        System.out.println(mp.peek());
        System.out.println(mp.size());
        mp.offer(-1);
        System.out.println(mp.peek());
        System.out.println(mp.size());
        mp.poll();
        System.out.println(mp.peek());
        System.out.println(mp.size());
        mp.clear();
        if (mp.isEmpty()){
            System.out.println("空");
        }else {
            System.out.println("非空");
        }
    }
}
柠萌呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
优先级队列（priority_queue）用法详解
qq_42978418的博客
08-03 573
优先级队列
数据结构之优先级队列 - 超详细的教程，手把手教你认识并运用优先级队列
最新发布
ミカミミミ博客
04-14 2961
数据结构之优先级队列 - 超详细的教程，手把手教你认识并运用优先级队列。
数据结构：优先级队列（堆）
m0_55644719的博客
05-19 188
文章目录一. 一.
【java】最大堆和最小堆的建立
bug的博客
10-06 711
最大堆 public class MaxHeap { private static int size = 0; private void maxHeap(int k, Integer key, Integer[] array){ while (k > 0){ //父节点，即array的中点 int paren...
数据结构之优先队列
u011220648的博客
12-07 1781
java优先队列
5 数据结构第三章知识点.doc
01-14
数据结构是计算机科学中的...总的来说，栈和队列是数据结构的基础，它们在算法设计和程序实现中扮演着关键角色，特别是在处理动态数据和需要特定顺序的操作时。理解和熟练运用这些数据结构是成为一名优秀程序员的基础。
c++优先队列用法知识点总结
12-20
优先队列也是队列这种数据结构的一种。它的操作不仅局限于队列的先进先出,可以按逻辑(按最大值或者最小值等出队列)。 普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。 在优先队列中，元素...
清华大学数据结构计划20071
08-08
这个计划详细规划了38周的教学内容，涵盖了数据结构的基础理论、核心概念以及相关算法。以下是课程中涉及的主要知识点： 1. **数据结构概念**：这是学习数据结构的基础，包括对数据组织方式的理解，如线性结构、树...
“数据结构”课程教学大纲.docx
10-26
本课程以C++语言为工具，结合面向对象编程思想，提升学生的基础知识和编程能力。 课程首先介绍了数据结构的基本概念，包括数据、数据元素、数据结构的逻辑结构和物理结构，以及抽象数据类型和面向对象编程的基本...
数据结构第0章1
08-08
课程的重点在于理解和掌握基本数据结构，如数组、顺序表、多项式、字符串、链表、栈、队列、优先级队列、广义表、树、森林、二叉树、堆、集合、图、搜索结构、索引结构和散列结构。学生需要学习这些数据结构的类定义...
【数据结构】优先级队列（用堆完成）
sofia_m的博客
01-21 957
优先级队列的实现 插入 删除 元素个数
数据结构Java实现07----队列：顺序队列&顺序循环队列、链式队列、顺序优先队列...
weixin_33962923的博客
09-08 172
一、队列的概念： 　　队列（简称作队，Queue）也是一种特殊的线性表，队列的数据元素以及数据元素间的逻辑关系和线性表完全相同，其差别是线性表允许在任意位置插入和删除，而队列只允许在其一端进行插入操作在其另一端进行删除操作。 队列中允许进行插入操作的一端称为队尾，允许进行删除操作的一端称为队头。队列的插入操作通常称作入队列，队列的删除操作通常称作出队列。 下图是一个依次向队列中插入数据元素a...
数据结构——【堆】详解
Lucky_mzc的博客
03-08 6519
一. 堆🌲 1. 堆的概念 堆（heap）：一种有特殊用途的数据结构——用来在一组变化频繁（发生增删查改的频率较高）的数据集中查找最值。 堆在物理层面上，表现为一组连续的数组区间：long[] array ；将整个数组看作是堆。 堆在逻辑结构上，一般被视为是一颗完全二叉树。 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆；反之，则是小堆，或者小根堆，或者最小堆。当一个堆为大堆时，它的每一棵子树都是大堆。 2. 堆的存储方式 从堆的概念可知，堆是一棵完全二叉树，
优先级队列— priority_queue详细解说以及使用
qq_44819750的博客
07-06 692
priority_queue介绍 之前所说的队列，是按照给的顺序逐一入队，而这里要说的优先级队列，底层实现是通过堆来实现的，优先级队列，顾名思义，在入队的时候，就会按照数据大小拍好序来入队，在默认情况下，优先级队列的实现是通过大堆来实现的。具体的概念如下： 1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。 2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元 素)。 3. 优先队列被实现为容器适配器，容器适配器即将特定
优先级队列（堆）的概念和基本操作
char_m的博客
04-30 1730
堆存储方式下标关系操作-向下调整三级目录 1. 堆逻辑上是一棵完全二叉树 2. 堆物理上是保存在数组中 3. 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆 4. 满足任意结点的值都小于其子树中结点的值，叫做小堆，或者小根堆，或者最小堆 5. 堆的基本作用是，快速找集合中的最值 存储方式 二叉树在代码中的表示方式： 孩子兄弟表示法（N叉树） 左右孩子表示法（二叉树） ...
优先级队列
xktxoo的博客
12-07 719
普通队列遵循先入先出原则，优先级队列支持基于队列元素的优先级进行处理，比如，银行中处理业务时需要优先处理大客户的业务等。 Java 1.5中引入了优先级队列（PriorityQueue），这个优先级队列中的元素可以默认自然排序，也可以通过提供比较器在队列实例化时排序。优先级队列中队头是最小元素，当获取队列元素时，返回队头元素，如果多个元素有同样的排序值，则出队列时随机取其中一个。优先级队列不受限制...
【数据结构与算法】详解什么是优先级队列，并用代码手动实现一个优先级队列
热门推荐
零一的博客
07-26 1万+
上一篇文章讲解了队列的相关知识，同时用代码实现了一个队列结构。那么本文将介绍一下另一种特殊的队列结构，叫做 优先级队列。 上一篇文章的跳转链接—— 公众号：Lpyexplore的编程小屋 关注我，每天更新，带你在python爬虫的过程中学习前端，还有更多电子书和面试题等你来拿 数据结构——优先级队列一、什么是优先级队列 一、什么是优先级队列 在了解了什么是队列以后，我们再来了解优先级队列，顾名思义，优先级队列就是在队列的基础上给每个元素加上了先后顺序，我们仍然拿排队买票的例子来讲解。 ...
数据结构----优先级队列
qq_38424588的博客
06-16 377
优先级队列： 基于大根堆和小根堆实现 设初始序列为：（49，38，65，97，76） ①大根堆：父节点的值大于或等于子节点的值（令数值越大优先级越高）     此时堆顶的元素为所有元素的最大值（97） ②小根堆：父节点的值小于或等于子节点的值（令数值越小优先级越高）    此时堆顶的元素为所有元素的最小值（38） 将队列中的所有元素按从大到小的数值输出： ①分析： 因为队列是先...
优先级队列的数据结构发一下
06-09
优先级队列的数据结构可以用堆（Heap）或者平衡树（如红黑树）来实现，这里分别给出两种常见的实现方式。 1. 堆实现优先级队列 堆是一种完全二叉树，可以用数组来实现。在堆中，每个节点的值都大于等于（或小于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值