Java集合与数据结构 优先级队列【堆】

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

Java集合与数据结构 优先级队列【堆】

二叉树的顺序存储

存储方式

使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。这种方式的主要用法就是堆的表示。
在这里插入图片描述

下标关系：
已知双亲(parent)的下标，则：
左孩子(left)下标 = 2 * parent + 1;
右孩子(right)下标 = 2 * parent + 2;
已知孩子（不区分左右）(child)下标，则：
双亲(parent)下标 = (child - 1) / 2;

堆(heap)

概念：

  1. 堆逻辑上是一棵完全二叉树。
  2. 堆物理上是保存在数组中。
  3. 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆。
  4. 反之，则是小堆，或者小根堆，或者最小堆。
  5. 堆的基本作用是：快速找集合中的最值。

操作-向下调整

前提：左右子树必须已经是一个堆，才能调整。

说明：

  1. array 代表存储堆的数组。
  2. size 代表数组中被视为堆数据的个数。
  3. index 代表要调整位置的下标。
  4. left 代表 index 左孩子下标。
  5. right 代表 index 右孩子下标。
  6. max 代表 index 的最大值孩子的下标。

过程（以大堆为例）：

  1. index 如果已经是叶子结点，则整个调整过程结束。
  1. 判断 index 位置有没有孩子。
  2. 因为堆是完全二叉树，没有左孩子就一定没有右孩子，所以判断是否有左孩子
  3. 因为堆的存储结构是数组，所以判断是否有左孩子即判断左孩子下标是否越界，即 left >= size 越界。
  1. 确定 left 或 right，谁是 index 的最大孩子 max。
  1. 如果右孩子不存在，则 max = left。
  2. 否则，比较 array[left] 和 array[right] 值得大小，选择大的为 max。
  1. 比较 array[index] 的值 和 array[max] 的值，如果 array[index] >= array[max]，则满足堆的性质，调整结束。
  2. 否则，交换 array[index] 和 array[max] 的值。
  3. 然后因为 max 位置的堆的性质可能被破坏，所以把 max 视作 index，向下重复以上过程。

在这里插入图片描述
逻辑代码：

public class HeapDemo {
    public int[] elem;
    public int usedSize;

    public HeapDemo() {
        this.elem = new int[10];
    }

	//时间复杂度分析：最坏的情况即图示的情况，从根一路比较到叶子，比较的次数为完全二叉树的高度即时间复杂度为 O(log(n))
    public void adjustDown(int parent, int len) {
        int child = 2 * parent + 1;

        while (child < len) {
            if (child+1 < len && this.elem[child] < this.elem[child+1]) {
                child++;
            }
            if (this.elem[child] > this.elem[parent]) {
                int temp = this.elem[child];
                this.elem[child] = this.elem[parent];
                this.elem[parent] = temp;
                parent = child;
                child = 2*parent+1;
            } else {
                break;
            }
        }
    }

	//时间复杂度分析：时间复杂度为 O(n * log(n))，实际上是 O(n)。
    public void createBigHeap(int[] array) {
        for (int i = 0; i < array.length; i++) {
            this.elem[i] = array[i];
            this.usedSize++;
        }

        for (int i = (this.usedSize - 1 - 1) / 2; i >= 0; i--) {
            adjustDown(i, this.usedSize);
        }
    }

    public void show() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
        System.out.println();
    }

}

测试代码：

public class TestDemo {
    public static void main(String[] args) {
        HeapDemo heapDemo = new HeapDemo();
        int[] array = {27,15,19,18,28,34,65,49,25,37};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        heapDemo.createBigHeap(array);
        heapDemo.show();
    }
}

该代码的执行结果为：
在这里插入图片描述

堆的应用-优先级队列

概念：
在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，比如首先处理优先级最高的对象，然后处理次高的对象。最简单的一个例子就是，在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。
在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue)。

内部原理
优先级队列的实现方式有很多，但最常见的是使用堆来构建。

操作-入队列

过程（以大堆为例）：

  1. 首先按尾插方式放入数组
  2. 比较其和其双亲的值的大小，如果双亲的值大，则满足堆的性质，插入结束
  3. 否则，交换其和双亲位置的值，重新进行 2、3 步骤
  4. 直到根结点

在这里插入图片描述

逻辑代码：

	public void adjustUp(int child) {
        int parent = (child - 1) / 2;
        while (child > 0) {
            if (this.elem[child] > this.elem[parent]) {
                int temp = this.elem[child];
                this.elem[child] = this.elem[parent];
                this.elem[parent] = temp;
                child = parent;
                parent = (child - 1) / 2;
            } else {
                break;
            }
        }
    }

    public void push(int val) {
        if (isFull()) {
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
        }
        this.elem[this.usedSize] = val;
        this.usedSize++;

        adjustUp(this.usedSize - 1);
    }

    public boolean isFull() {
        return this.usedSize == this.elem.length;
    }

操作-出队列

过程（以大堆为例）：

  1. 将第一个元素与最后一个元素进行交换。
  2. 删除最后一个下标
  3. 向下调整（只需要调整0号下标）
    在这里插入图片描述
    逻辑代码：
	public int poll() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空~");
        }
        int ret = this.elem[0];
        int temp = this.elem[0];
        this.elem[0] = this.elem[usedSize-1];
        this.elem[usedSize-1] = temp;
        this.usedSize--;
        adjustDown(0,this.usedSize);
        return ret;

    }

    public boolean isEmpty() {
        return this.usedSize == 0;
    }

	public void adjustDown(int parent, int len) {
        int child = 2 * parent + 1;

        while (child < len) {
            if (child + 1 < len && this.elem[child] < this.elem[child + 1]) {
                child++;
            }
            if (this.elem[child] > this.elem[parent]) {
                int temp = this.elem[child];
                this.elem[child] = this.elem[parent];
                this.elem[parent] = temp;
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }

java 中的优先级队列

PriorityQueue implements Queue
集合框架中的PriorityQueue底层使用堆结构，因此其内部的元素必须要能够比大小，PriorityQueue采用了：Comparble和Comparator两种方式。

  1. Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接口，并覆写compareTo方法。
  2. 用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现Comparator接口并覆写compare方法。

堆的其他应用 TopK 问题

问题描述： 从array[1, n]这n个数中，找出最大的k个数，这就是经典的TopK问题。

前k个最小的元素，建大堆；
前k个最大的元素，建小堆。

例如：从int[] array = { 27,15,19,18,28,34,65,49,25,37 };中找出最大的三个数。
逻辑代码：

public class HeapDemo {
    public int[] elem;
    public int usedSize;

    public HeapDemo() {
        this.elem = new int[10];
    }
    
    /*
    找前k个最大的元素
    创建小堆
     */
    public static void topK(int[] array,int k) {
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(k, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });

        for (int i = 0; i < array.length; i++) {
            if (minHeap.size() < k) {
                minHeap.offer(array[i]);
            } else {
                int top = minHeap.peek();
                if (array[i] > top) {
                    minHeap.poll();
                    minHeap.offer(array[i]);
                }
            }
        }
        for (int i = 0; i < k; i++) {
            System.out.println(minHeap.poll());
        }
    }
}

调试代码：

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {27,15,19,18,28,34,65,49,25,37};
        HeapDemo.topK(array,3);
    }
}

该代码的执行结果为：
在这里插入图片描述
可见，该数组中最大的三个数已找到。

例如：从int[] array = { 27,15,19,18,28,34,65,49,25,37 };中找出最小的三个数。
逻辑代码：

public class HeapDemo {
    public int[] elem;
    public int usedSize;

    public HeapDemo() {
        this.elem = new int[10];
    }
    
    /*
    找前k个最小的元素
    创建大堆
     */
    public static void minTopK(int[] array,int k) {
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });

        for (int i = 0; i < array.length; i++) {
            if (maxHeap.size() < k) {
                maxHeap.offer(array[i]);
            } else {
                Integer top = maxHeap.peek();
                if (top != null) {
                    if (array[i] < top) {
                        maxHeap.poll();
                        maxHeap.offer(array[i]);
                    }
                }
            }
        }
        for (int i = 0; i < k; i++) {
            System.out.println(maxHeap.poll());
        }
    }
}

调试代码：

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {27,15,19,18,28,34,65,49,25,37};
        HeapDemo.minTopK(array,3);
    }
}

该代码的执行结果为：
在这里插入图片描述
可见，该数组中最小的三个数已找到。

堆的其他应用 堆排序

基本原理是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。

注意： 排升序要建大堆；排降序要建小堆。

时间复杂度：不管是最好的情况还是最坏的情况都是O(n * log(n)) 。
空间复杂度：O(1)。

以排升序为例，逻辑代码：

public class HeapDemo {
    public int[] elem;
    public int usedSize;

    public HeapDemo() {
        this.elem = new int[10];
    }


    public void adjustDown(int parent, int len) {
        int child = 2 * parent + 1;

        while (child < len) {
            if (child + 1 < len && this.elem[child] < this.elem[child + 1]) {
                child++;
            }
            if (this.elem[child] > this.elem[parent]) {
                int temp = this.elem[child];
                this.elem[child] = this.elem[parent];
                this.elem[parent] = temp;
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }
	
	public void createBigHeap(int[] array) {
        for (int i = 0; i < array.length; i++) {
            this.elem[i] = array[i];
            this.usedSize++;
        }

        for (int i = (this.usedSize - 1 - 1) / 2; i >= 0; i--) {
            adjustDown(i, this.usedSize);
        }
    }

	public void show() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
        System.out.println();
    }
    
	/*
	堆排序
	*/
	public void heapSort() {
        int end = this.usedSize-1;
        while (end > 0) {
            int temp = this.elem[0];
            this.elem[0] = this.elem[end];
            this.elem[end] = temp;
            adjustDown(0,end);
            end--;
        }
    }
}

测试代码：

public class TestDemo {
    public static void main(String[] args) {
        HeapDemo heapDemo = new HeapDemo();
        int[] array = {27,15,19,18,28,34,65,49,25,37};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        heapDemo.createBigHeap(array);
        heapDemo.show();
        heapDemo.heapSort();
        heapDemo.show();
    }
}

该代码的运行结果为：
在这里插入图片描述
可见，我们实现了堆排序。

头发都哪去了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第十四章第五节：Java集合框架之优先级队列PriorityQueue（堆）
快乐江湖的博客
10-05 627
堆：堆就是一颗完全二叉树它的结点要么大于任意一个孩子结点，要么小于任意一个孩子结点如果其结点大于任意一个孩子结点，就称其为大顶堆，此时其最大的结点是根结点如果其结点小于任意一个孩子结点，就称其为小顶堆，此时其最小的结点是根结点。
Java超详细！Java实现数据结构PPT课件
最新发布
02-24
复杂度 时间复杂度 空间复杂度 线性数据结构动态数组（ArrayList） 链表（LinkedList） 单向链表 双向链表 循环链表 静态链表 栈（Stack） 队列（Queue） 双端队列（Deque） ...优先级队列（PriorityQueue）
Java集合中的堆
I want to know a little more.
07-31 855
什么是堆？ 堆其实就是一种特殊的队列——优先队列。 普通的队列游戏规则很简单：就是先进先出；但这种优先队列搞特殊，不是按照进队列的时间顺序，而是按照每个元素的优先级来比拼，优先级高的在堆顶。 这也很容易理解吧，比如各种软件都有会员制度，某软件用了会员就能加速下载的，不同等级的会员速度还不一样，那就是优先级不同呀。 还有其实每个人回复微信消息也是默默的把消息放进堆里排个序：先回男朋友女朋友的，然后再回其他人的。 这里要区别于操作系统里的那个“堆”，这两个虽然都叫堆，但是没有半毛钱关系，都是借用了 H
Java数据结构之堆(Heap)
qq15035899256的博客
08-04 3003
本文是Java数据结构的学习，认识了堆，学习了堆的上浮、下沉操作原理，以及自己手写一个大根堆。之后的学习内容将持续更新！！！
Java集合与数据结构——优先级队列（堆）
rain67的博客
08-13 3193
1. 二叉树的顺序存储 1.1 堆的存储方式 使用数组保存二叉树结构，方式即将二叉树用层序遍历方式放入数组中。 一般只适合表示完全二叉树，因为非完全二叉树会有空间的浪费。 这种方式的主要用法就是堆的表示。 1.2 下标关系 已知 双亲 (parent) 的下标，则： 左孩子(left)下标 = 2 * parent + 1; 右孩子(right)下标 = 2 * parent + 2; 已知孩子（不区分左右）(child)下标，则： 双亲(parent)下标 = (child - 1) / 2;
堆和堆傻傻分不清？一文告诉你 Java 集合中「堆」的最佳打开方式
tanqingbo的博客
07-15 391
上一篇的 「Java 集合框架」里，还剩下一个大问题没有说的，那就是 PriorityQueue，优先队列，也就是堆，Heap。什么是堆？ 堆其实就是一种特殊的队列——优先队列。普通的队...
集合比较
02-21
因此，平衡树是实现集合的更好的数据结构，但是HeapSort对于优先级队列很有用，因为高优先级元素接近根。 C。 首先，TreeSet和TreeMap中的数据均按排序顺序。 其次，当在TreeSet中实现set接口时，将实现TreeMap的...
Visualization.rar
02-08
数据结构可视化工具: 动态数组 链表 栈 队列 二叉树 二叉搜索树 AVL树 B树 集合 红黑树 映射 哈希表 二叉堆 优先级队列 哈夫曼树 等
itsvenkis-java:我的项目
07-03
我的项目数据结构 Java 集合包具有基于不同类型的二叉树（如红黑树和二叉堆树（集合和优先级队列））的实现，但这些树隐藏在实现中。 每当需求需要二叉树时，最终都会创建自己的类来支持需求。 该项目旨在提供各种...
java集合系列——List集合之Stack介绍（五）
阿飞云漫步
03-02 6727
Stack的简介Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。
JAVA基础随记：java的堆和栈、集合类、java5之后提供的高并发线程安全集合
weixin_33862188的博客
05-31 293
2019独角兽企业重金招聘Python工程师标准>>> ...
java集合框架之堆栈
huacuo2013的专栏
10-04 602
堆栈是一种“后进先出”的数据结构，只在一端进行输入或输出。     java.util包中的Stack泛型类创建一个堆栈对象，调用public E push(E item)实现压栈操作，调用public E pop()实现出栈操作。     其他方法：public e peek()获取栈顶数据，但不删除该数据； public int Search(Object data)获取数据在堆栈中的位置
java集合超详解
热门推荐
feiyan的博客
08-03 44万+
一、集合大纲 1.集合和数组的区别： 2.Collection集合的方法： 3.常用集合的分类： Collection 接口的接口 对象的集合（单列集合） ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全 │—————-├ ArrayList 接口...
java集合、堆和栈
静下心来吧，让自己变强大点！
12-23 222
java集合 ​​​​​​java集合详解和集合面试题目_千年似流水的博客-CSDN博客_java集合类面试题
java详解数据结构-----堆-----Heap
baiyang2001的博客
02-24 1407
声明：关于文章的任何问题，以及知识点相关问题，可以私信博主，博主虽能力一般，但定尽全力为大家解决 文章前言： 上篇文章我们讨论过二叉树，在上篇文章中我们采用的是链式存储一颗二叉树，那么在本篇文章中将介绍一种新的存储方式，使用顺序存储方式去存储一颗二叉树（这里的二叉树一般指的是完全二叉树），这种存储方式我们管它叫堆，下面我们开始堆的学习 文章目录： ...
Java集合
weixin_51808902的博客
05-14 1万+
Java集合 集合框架的概述 1、集合、数组都是对多个数据进行存储操作的结构，简称Java容器 此时的存储主要是指内存层面的存储，不涉及到持久化的存储（.txt,.jpg,数据库中） java集合就像是一种容器，可以动态的把多个对象的引用放入容器中 2、数组在存储多个数据方面的特点： >一旦初始化后，其长度就确定了 >数组一旦定义好，其元素类型就确定了，我们也就只能操作指定类型的数据了 比如String【】 arr；int【】 arr1 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，
深入理解Java集合框架系列-第五章 java中的堆栈
全栈软件工程师-陈征峰的博客
08-04 557
java中的堆栈的简单介绍
java队列数据结构
09-15
Java中的队列是一种基本的数据结构，用于存储和管理元素。Queue接口是Java集合框架中定义的一个接口，它提供了一组方法来操作队列。不同的实现类可以选择不同的方式来实现队列的功能。 在Java中，我们可以使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值