数据结构与算法——Java实现 29.优先级队列

于 2024-10-05 11:19:04 发布
阅读量547 收藏 5
点赞数 5
分类专栏： 数据结构与算法 —— Java实现 Java习题算法 手撕力扣题 文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73983707/article/details/142703688
版权

事缓则圆，人缓则安

                        —— 24.10.5

一、优先级队列

优先级队列                一端进，另一端出                按优先级出队

普通队列                    一端进，另一端出                先进先出FIFO

二、无序数组实现

Type parameters：<E>：队列中元素的类型，必须实现Priority接口

思路

设置对象优先级Entry，每个存入数组的元素都有它的优先级，无序数组实现时，加入元素直接在数组尾部进行添加，删除元素时遍历一遍数组，寻找优先级最大的元素，将优先级最大的元素进行删除

对象优先级接口

public interface Priority {
    // 返回对象的优先级，约定数字越大，优先级越高
    // Returns：优先级
    int priority();
}

优先级接口实现

public class Entry implements Priority{
    String value;
    int priority;

    public Entry(String value, int priority) {
        this.value = value;
        this.priority = priority;
    }

    @Override
    public int priority() {
        return priority;
    }

    @Override
    public String toString() {
        return "Entry{" +
                "value='" + value + '\'' +
                ", priority=" + priority +
                '}';
    }
}

队列接口

public interface Queue<E> {
    /*
        向队列尾部插入值
        Params：value-待插入值
        Returns：插入成功返回true，插入失败返回false
     */
    boolean offer(E e);

    /*
        从队列头获取值，并移除
        Returns：如果队列非空返回头部值，否则返回null
     */
    E poll();

    /*
        从队列头获取值，不移除
        Returns：如果队列非空返回队头值，否则返回null
     */
    E peek();

    /*
        检查队列是否为空
        Return：空返回true，否则返回false
     */
    boolean isEmpty();

    /*
        检查队列是否为满
        Return：满返回true，否则返回false
     */
    boolean isFull();
}

无序数组实现队列接口

import Day10Queue.Queue;

import java.util.Arrays;

public class PriorityQueue1<E extends Priority> implements Queue<E> {
    // 数据类型E要实现Priority接口，所以数组类型直接定义成Priority
    Priority[] array;
    int size;

    public PriorityQueue1(int capacity) {
        array = new Priority[capacity];
    }

    // 添加元素
    @Override
    public boolean offer(E e) {
        if (isFull()) {
            return false;
        }
        array[size] = e;
        size++;
        return true;
    }

    // 寻找优先级最高的索引值
    private int selectMax(){
        int max = 0;
        for (int i = 0; i < size - 1; i++) {
            // 寻找优先级最高的元素
            if (array[i].priority() > array[max].priority()){
                max = i;
            }
        }
        return max;
    }
    
    // 删除元素
    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        int max = selectMax();
        E e = (E) array[max];
        remove(max);
        return e;
    }

    // 删除元素
    private void remove(int index) {
        if (index == size - 1) {
            array[size] = null;
        } else if (index < size-1) {
            // 原数组 原数组起始位置 目的数组 目的数组起始位置 移动的元素个数
            System.arraycopy(array,index+1,array,index,size-index-1);
        }
        size--;
        array[size] = null;
    }

    // 获取元素
    @Override
    public E peek() {
        if (isEmpty()){
            return null;
        }
        int max = selectMax();
        return (E) array[max];
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public boolean isFull() {
        return size==array.length;
    }

    @Override
    public String toString() {
        return "PriorityQueue1{" +
                "array=" + Arrays.toString(array) +
                ", size=" + size +
                '}';
    }
}

测试类

import org.junit.Test;

import static org.junit.jupiter.api.Assertions.*;

public class TestPriorityQueue1 {

    @Test
    public void poll(){
        PriorityQueue1<Entry> queue1 = new PriorityQueue1<>(5);
        queue1.offer(new Entry("task1",4));
        queue1.offer(new Entry("task2",3));
        queue1.offer(new Entry("task3",2));
        queue1.offer(new Entry("task4",5));
        queue1.offer(new Entry("task5",1));
        assertFalse(queue1.offer(new Entry("task6",7)));

        assertEquals(5, queue1.poll().priority());
        assertEquals(4, queue1.poll().priority());
        assertEquals(3, queue1.poll().priority());
        assertEquals(2, queue1.poll().priority());
        assertEquals(1, queue1.poll().priority());
        System.out.println(queue1.toString());
    }
}

三、有序数组实现

Type parameters：<E>：队列中元素的类型，必须实现Priority接口

思路

将元素按照优先级进行排序存储在基于有序数组实现的队列中，删除元素时只需要在数组最尾端进行出队操作，添加元素时需要遍历一遍队列内的元素，寻找新元素优先级存储的位置，将新元素存储在其优先级按序排列的数组中的位置

 对象优先级接口

public interface Priority {
    // 返回对象的优先级，约定数字越大，优先级越高
    // Returns：优先级
    int priority();
}

优先级接口实现

public class Entry implements Priority{
    String value;
    int priority;

    public Entry(String value, int priority) {
        this.value = value;
        this.priority = priority;
    }

    @Override
    public int priority() {
        return priority;
    }

    @Override
    public String toString() {
        return "Entry{" +
                "value='" + value + '\'' +
                ", priority=" + priority +
                '}';
    }
}

队列接口

public interface Queue<E> {
    /*
        向队列尾部插入值
        Params：value-待插入值
        Returns：插入成功返回true，插入失败返回false
     */
    boolean offer(E e);

    /*
        从队列头获取值，并移除
        Returns：如果队列非空返回头部值，否则返回null
     */
    E poll();

    /*
        从队列头获取值，不移除
        Returns：如果队列非空返回队头值，否则返回null
     */
    E peek();

    /*
        检查队列是否为空
        Return：空返回true，否则返回false
     */
    boolean isEmpty();

    /*
        检查队列是否为满
        Return：满返回true，否则返回false
     */
    boolean isFull();
}

有序数组实现队列接口

import Day10Queue.Queue;

public class PriorityQueue2<E extends Priority> implements Queue<E> {
    Priority[] array;
    int size;

    public PriorityQueue2(int capacity) {
        array = new Priority[capacity];
    }

    @Override
    public boolean offer(E e) {
        if (isFull()){
            return false;
        }
        insert(e);
        size++;
        return false;
    }

    private void insert(E e) {
        int i = size-1;
        while (i >= 0 && array[i].priority() > e.priority()){
            array[i+1] = array[i];
            i--;
        }
        array[i+1] = e;
    }

    @Override
    public E poll() {
        if (isEmpty()){
            return null;
        }
        E e = (E) array[size-1];
        array[size-1] = null;
        size--;
        return e;
    }

    @Override
    public E peek() {
        if (isEmpty()){
            return null;
        }
        return (E) array[array.length - 1];
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean isFull() {
        return size == array.length;
    }
}

测试类

import org.junit.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;

public class TestPriorityQueue2 {
    @Test
    public void poll(){
        PriorityQueue2<Entry> queue1 = new PriorityQueue2<>(5);
        queue1.offer(new Entry("task1",4));
        queue1.offer(new Entry("task2",3));
        queue1.offer(new Entry("task3",2));
        queue1.offer(new Entry("task4",5));
        queue1.offer(new Entry("task5",1));
        assertFalse(queue1.offer(new Entry("task6",7)));

        assertEquals(5, queue1.poll().priority());
        assertEquals(4, queue1.poll().priority());
        assertEquals(3, queue1.poll().priority());
        assertEquals(2, queue1.poll().priority());
        assertEquals(1, queue1.poll().priority());
        System.out.println(queue1.toString());
    }
}

四、堆实现

数据结构——堆

定义

计算机科学中，堆是一种基于树的数据结构，通常用完全二叉树实现。堆的特性如下：

        大顶堆，任意节点C与它的父节点P符合：P.value >= C.value

        小顶堆，任意节点C与它的父节点P符合：P.value <= C.value

        最顶层的节点(没有父亲)，称之为root根节点

完全二叉树：除叶子节点那一层（最后一层）外，其余层都被填满（最后一层可填满可不填满）

特性：完全二叉树添加元素必须从左到右依次填满

特征

如果从索引0开始存储节点数据

        节点 i 的父节点为 floor((i-1)/2)，当i>0时

        节点 i 的左子节点为 2i+ 1，右子节点为 2i + 2，当然它们需要 < size

如果从索引1开始存储节点数据

        节点 i 的父节点为 floor(i/2)，当i>1时

        节点 i 的左子节点为 2i，右子节点为 2i + 1 ，同样需要 < size

大顶堆实现优先级队列

思路

根据大顶堆特性，root根节点就是优先级最高的元素，索引0位置就是要出队的元素，直接在队头出队进行删除

入堆新元素，加入到数组末尾（索引位置child）

不断比较新加入元素与它父亲节点（parrent）的优先级

        如果父节点优先级低，则向下移动，并找到下一个parrent

        直至父节点优先级更高或 child == 0 为止

交换堆顶和尾部元素，让尾部元素出队

(下潜)

        从堆顶开始，将父元素与两个孩子较大者交换

        直到父元素大于两个孩子，或没有孩子为止

元素优先级接口

public interface Priority {
    // 返回对象的优先级，约定数字越大，优先级越高
    // Returns：优先级
    int priority();
}

队列接口

import Day13PriorityQueue.Priority;

public interface Queue<E> {
    /*
        向队列尾部插入值
        Params：value-待插入值
        Returns：插入成功返回true，插入失败返回false
     */
    boolean offer(E e);

    /*
            从队列头获取值，并移除
            Returns：如果队列非空返回头部值，否则返回null
         */
    E poll();

    /*
        从队列头获取值，不移除
        Returns：如果队列非空返回队头值，否则返回null
     */
    E peek();

    /*
        检查队列是否为空
        Return：空返回true，否则返回false
     */
    boolean isEmpty();

    /*
        检查队列是否为满
        Return：满返回true，否则返回false
     */
    boolean isFull();
}

优先级队列的实现

import Day10Queue.Queue;

@SuppressWarnings("all")
public class PriorityQueue3<E extends Priority> implements Queue<E> {
    Priority[] array;
    int size;

    public PriorityQueue3(int capacity) {
        array = (Priority[]) new Priority[capacity];
    }

    @Override
    public boolean offer(E e) {
        /*
            入堆新元素，加入到数组末尾（索引位置child）
            不断比较新加入元素与它父亲节点（parrent）的优先级
            如果父节点优先级低，则向下移动，并找到下一个parrent
            直至父节点优先级更高或 child == 0 为止
         */
        if (isFull()){
            return false;
        }
        int child = size;
        size++;
        int parent = (child - 1) / 2;
        while (child >0 && e.priority() > array[parent].priority()) {
            array[child] = array[parent];
            child = parent;
            parent = (child - 1) / 2;
        }
        array[child] = e;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()) {
            return null;
        }
        swap(0,size-1);
        size--;
        Priority e = array[size];
        array[size] = null;

        // 下潜
        down(0);
        return (E) e;
    }

    private void down(int parent) {
        int left = 2 * parent+1;
        int right = left + 1;
        // 假设父元素优先级最高
        int max = parent;
        if (left < size && array[left].priority() > array[max].priority()) {
            max = left;
        }
        if (right < size && array[right].priority() > array[max].priority()) {
            max = right;
        }
        // 有孩子优先级大于父节点
        if (max != parent) {
            swap(max,parent);
            down(max);
        }
    }

    private void swap(int i, int j) {
        Priority temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        return (E) array[0];
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean isFull() {
        return size == array.length;
    }
}

 测试类

import org.junit.Test;
import static org.junit.jupiter.api.Assertions.*;

public class TestPriorityQueue3 {
    @Test
    public void test() {
        PriorityQueue3<Entry> queue = new PriorityQueue3<>(5);
        queue.offer(new Entry("task1",4));
        queue.offer(new Entry("task2",3));
        queue.offer(new Entry("task3",2));
        queue.offer(new Entry("task4",1));
        queue.offer(new Entry("task5",5));
        assertFalse(queue.offer(new Entry("task6",6)));

        assertEquals(5,queue.poll().priority());
        assertEquals(4,queue.poll().priority());
        assertEquals(3,queue.poll().priority());
        assertEquals(2,queue.poll().priority());
        assertEquals(1,queue.poll().priority());
    }
}

L_cl
关注
专栏目录
java怎么遍历优先级队列_Java数据结构与算法笔记——优先级队列
weixin_34246474的博客
02-24 1411
文章目录优先级队列介绍普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。在插入元素时，要按照优先级找到正确的位置并插入。实现一个简单的优先级队列数值的大小作为优先级，数值越大优先级越高。插入：根据元素的大小插入。取出：取出队头元素。在这里插入代码片package queue;public class QueueTest3 {public stat...
Java数据结构与算法02——队列
12-21
Java中的数据结构与算法是编程领域中至关重要的概念，它们为高效地处理和组织数据提供了...对于初学者来说，从简单的数组模拟开始，逐步深入到链表、环形队列以及更高级的队列实现，是学习数据结构与算法的有效路径。
Java数据结构：优先级队列——对象的比较
2301_78493961的博客
06-24 370
本篇文章主要讲述三种实现对象的比较的方法以及优先级队列内部使用的比较的方法。
Java数据结构（七）——优先级队列与PriorityQueue
xiaokuer_的博客
08-31 979
文章基于Java集合框架中的PriorityQueue类，先介绍了堆的相关知识，而后介绍了PriorityQueue的使用。
Java数据结构与算法第七课——优先级队列（堆）
baijaiyu的博客
07-25 666
主要介绍优先级队列（堆）！
数据结构（java实现）——优先级队列，堆
2301_77993957的博客
08-07 819
前面介绍过队列，队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列，该种场景下，使用队列显然不合适，比如：在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话；把前k个元素创建为大根堆，遍历剩下的N-K个元素，和栈顶元素比较，如果比栈顶元素小，则删除栈顶元素，将此元素入堆。如果要创建小根堆，我们只能保证堆顶元素为最小值，但是不能保证，左边的元素比右边的元素大，这不是小根堆的特性。
【数据结构初阶】——第八节.优先级队列（小根堆的模拟实现）
未央的博客哟
05-15 5517
今天我们将进入到有关堆的有关内容的学习，以及有关优先级队列的相关使用，要对堆的概念，性质，操作有很熟悉的认识和了解，接下来就让我们进入到今天的学习当中吧！！！！！！
Java数据结构与算法解析(十三)——优先级队列
热门推荐
一个码农的博客
10-21 1万+
在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，比如首先处理优先级最高的对象，然后处理次高的对象。最简单的一个例子就是，在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue) 。定义优先级队列和通常的栈和队列一样，只
Java数据结构——优先级队列（堆）
2302_76435884的博客
05-29 659
Java数据结构——优先级队列（堆）
Java数据结构与算法解析——优先级队列
道的博客
10-31 305
在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，比如首先处理优先级最高的对象，然后处理次高的对象。最简单的一个例子就是，在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。 在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue) 。 定义 优先级队列和通常的栈
数据结构与算法分析Java3rd英文_数据结构与算法分析_
10-03
数据结构与算法分析是计算机...通过阅读《数据结构与算法分析Java3rd英文》这本书，你可以深入理解这些概念，并学习如何在Java中有效地应用它们。这本书会涵盖各种示例和练习，帮助读者巩固理论知识并提高实践技能。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 416
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 524
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1224
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 791
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 320
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1107
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 418
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值