java 优先队列从小到大,优先队列(Java)
优先队列(底层结构为最大堆)
普通的队列是一种先进先出的数据结构,元素在队列尾追加,而从队列头删除。在优先队列中,元素被赋予优先级。当访问元素时,具有最高优先级的元素最先删除。优先队列具有最高级先出 (first in, largest out)的行为特征。通常采用堆数据结构来实现。
优先队列主要是出队操作与普通队列不同,队列中元素会有优先级之分,每次出队的元素是优先级最高的元素。
最大堆(二叉堆)
最大堆是堆的两种形式之一。
根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者,称为大根堆,又称最大堆(大顶堆)。
大根堆要求根节点的关键字既大于或等于左子树的关键字值,又大于或等于右子树的关键字值。
Arr.java(动态数组)
//动态数组
public class Arr {
private E[] data;// 创建一个数组
private int size;// 数组中元素个数
// 自定义构造器初始化数组 capacity数组的长度
public Arr(int capacity) {
// TODO Auto-generated constructor stub
data = (E[]) new Object[capacity];
size = 0;
}
// 默认构造方法 capacity数组的长度=10
public Arr() {
// TODO Auto-generated constructor stub
this(10);
}
// 根据传来的数组生成动态数组
public Arr(E[] arr) {
data = (E[]) new Object[arr.length];
for (int i = 0; i < arr.length; i++) {
data[i] = arr[i];
}
size = arr.length;
}
// 获取数组个数
public int getSize() {
return size;
}
// 获取数组长度
public int getCapacity() {
return data.length;
}
// 判断数组是否为空
public boolean isEmpty() {
return size == 0;
}
// 数组中添加元素 index是插入元素的位置,e是插入的元素,时间复杂度为O(n)
public void add(int index, E e) {
if (index < 0 || index > size) {
try {
throw new Exception("数组排列要求不能有空");
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
// 数组扩容
if (size == data.length) {
try {
resize(2 * data.length); // 这里是扩容为原数组的2倍,Arraylist是扩容1.5倍
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
for (int i = size - 1; i >= index; i--) {
data[i + 1] = data[i];
}
data[index] = e;
size++;
}
// 数组扩容或者缩容,时间复杂度为O(n)
private void resize(int newcapcatity) {
// TODO Auto-generated method stub
E[] newData = (E[]) new Object[newcapcatity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
}
// 在数组末尾添加元素,时间复杂度为O(1)
public void addLast(E e) {
add(size, e);
}
// 在数组首部添加元素,时间复杂度为O(n)
public void addFirst(E e) {
add(0, e);
}
// 重写toString 使用字符串拼接
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append(String.format("Array:size = %d, capacity = %d\n", size, data.length));
res.append('[');
for (int i = 0; i < size; i++) {
res.append(data[i]);
if (i != size - 1) {
res.append(',');
}
}
res.append(']');
return res.toString();
}
public E getLast() {
return get(size - 1);
}
public E getFirst() {
return get(0);
}
// 获取index位置的数组元素,时间复杂度为O(1)
E get(int index) {
if (index < 0 || index >= size) {
try {
throw new Exception("index非法");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return data[index];
}
// 修改数组元素,时间复杂度为O(1)
void set(int index, E e) {
if (index < 0 || index >= size) {
try {
throw new Exception("index非法");
} catch (Exception e3) {
// TODO Auto-generated catch block
e3.printStackTrace();
}
}
data[index] = e;
}
// 查询是否包含数组元素e,时间复杂度为O(n)
public boolean contains(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e))
return true;
}
return false;
}
// 查找数组元素e,时间复杂度为O(n)
public int find(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e))
return i;// 返回元素e的位置
}
return -1;// 找不到元素e,返回-1
}
// 删除指定位置index的数组元素,时间复杂度为O(n)
public E remove(int index) {
if (index < 0 || index >= size) {
try {
throw new Exception("index非法");
} catch (Exception e3) {
// TODO Auto-generated catch block
e3.printStackTrace();
}
}
// 缩容
if (size == data.length / 2) {
resize(data.length / 2);
}
E ret = data[index];
for (int i = index + 1; i < size; i++) {
data[i - 1] = data[i];
}
size--;
data[size] = null;
return ret;// 返回删除的元素
}
// 数组删除首个元素,时间复杂度为O(n)
public E removeFirst() {
return remove(0);
}
// 数组删除最后一个元素,时间复杂度为O(1)
public E removeLast() {
return remove(size - 1);
}
// 数组删除元素e,时间复杂度为O(n)
public void removeElement(E e) {
int index = find(e);
if (index != -1) {
remove(index);
} else {
System.out.println("数组中没有元素e");
}
}
// 元素交换
public void swap(int i, int j) {
if (i < 0 || i >= size || j >= size || j < 0)
try {
throw new Exception("元素越界");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
E t = data[i];
data[i] = data[j];
data[j] = t;
}
}
MaxHeap.java(最大堆)
//最大堆 以动态数组为底层
public class MaxHeap> {
private Arr data;
public MaxHeap(int capacity) {
// TODO Auto-generated constructor stub
data = new Arr<>(capacity);
}
public MaxHeap() {
// TODO Auto-generated constructor stub
data = new Arr<>();
}
// 构造函数 将任意数组整理成最大堆的形状
public MaxHeap(E[] arr) {
data = new Arr<>(arr);// 根据传来的数组生成动态数组
for (int i = parent(arr.length - 1); i >= 0; i--) {
siftDown(i);// 从最后一个非叶子节点进行下沉,一直到根节点
}
}
public int size() {
return data.getSize();
}
public boolean isEmpty() {
return data.isEmpty();
}
// 返回二叉树的数组表示中,一个索引所表示的元素的父亲节点的索引
private int parent(int index) {
if (index == 0) {
try {
throw new Exception("根节点没有父节点");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return (index - 1) / 2;
}
// 获取左孩子节点的索引
private int leftChild(int index) {
return 2 * index + 1;
}
// 获取右孩子节点的索引
private int rightChild(int index) {
return 2 * index + 2;
}
// 向堆中添加元素
public void add(E e) {
data.addLast(e);// 在数组末尾添加元素e
siftUp(data.getSize() - 1);// 元素上浮
}
// 堆中元素上浮
private void siftUp(int k) {
// TODO Auto-generated method stub
while (k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0) {
data.swap(k, parent(k));// 与父节点进行交换
k = parent(k);// k变化到父节点,准备下一轮循环
}
}
// 取出堆中最大元素
public E findMax() {
if (data.getSize() == 0)
try {
throw new Exception("堆为空");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return data.get(0);
}
// 取出堆中最大元素
public E extractMax() {
E ret = findMax();
data.swap(0, data.getSize() - 1);
data.removeLast();
siftDown(0);
return ret;
}
// 元素下沉
private void siftDown(int k) {
// TODO Auto-generated method stub
while (leftChild(k) < data.getSize()) {
int j = leftChild(k);
if (j + 1 < data.getSize() && data.get(j + 1).compareTo(data.get(j)) > 0) {
j = rightChild(k);
// data[j]是左孩子和右孩子中的最大值
if (data.get(k).compareTo(data.get(j)) >= 0)// 左右孩子的最大值与索引为k的元素进行比较
break;// 如果索引为k的元素大于左右孩子的最大值,即符合堆的性质
data.swap(k, j);// 否则进行交换
k = j;// 元素k的索引变为j,准备下次循环
}
}
}
// 取出堆中的最大元素,并且替换成元素e
public E replace(E e) {
E ret = findMax();// 找到最大元素
data.set(0, e);// 将e替换成最大元素的位置
siftDown(0);// 进行下沉
return ret;
}
}
最大堆中常用的方法
replace:取出最大元素后,放入一个新元素
实现1:可以先使用extractMax方法取出最大元素,再使用add方法,两次O(logn)的操作
实现2:可以直接将堆顶元素替换以后Sift Down,一次O(logn)的操作
heapify:将任意数组整理成最大堆的形状
实现1:将n个元素逐个插入一个空的最大堆中,算法复杂度是O(nlogn)
实现2:heapify的过程,算法复杂度为O(n)(上述代码中使用构造函数public MaxHeap(E[] arr)完成heapify的操作)
Queue.java(队列接口)
public interface Queue {
void enqueue(E e);//入队
E dequeue();//出队
E getFront();//获取队首元素
int getSize();//获取队列中元素个数
boolean isEmpty();//判断队列是否为空
}
PriorityQueue.java(优先队列)
//优先队列,底层结构为最大堆 实现队列接口
public class PriorityQueue> implements Queue {
private MaxHeap maxHeap;
public PriorityQueue() {
// TODO Auto-generated constructor stub
maxHeap = new MaxHeap<>();
}
@Override
public void enqueue(E e) {
// TODO Auto-generated method stub
maxHeap.add(e);
}
@Override
public E dequeue() {
// TODO Auto-generated method stub
return maxHeap.extractMax();//去除堆中最大元素
}
@Override
public E getFront() {
// TODO Auto-generated method stub
return maxHeap.findMax();//最大堆的堆顶元素
}
@Override
public int getSize() {
// TODO Auto-generated method stub
return maxHeap.size();
}
@Override
public boolean isEmpty() {
// TODO Auto-generated method stub
return maxHeap.isEmpty();
}
}
悦悦的狗子
发布了27 篇原创文章 · 获赞 6 · 访问量 2493
私信
关注
标签:index,优先,Java,队列,元素,int,data,public,size
来源: https://blog.csdn.net/weixin_44190113/article/details/104137448
java 优先队列从小到大,优先队列(Java)相关推荐
- Java算法_优先队列和PriorityQueue——HDU 1873:看病要排队
目录 优先队列和PriorityQueue HDU 1873:看病要排队 java.util.Comparator 优先队列和PriorityQueue java.util.PriorityQueue ...
- java优先队列二叉_二叉堆与Java中的优先队列
之前在A*算法演示程序的编码过程中,发现javaScript并没有原生的优先队列,于是去Java中找到了PriorityQueue类,研究了一下源码.Java中的优先队列基于最小二叉堆实现.最小二叉堆 ...
- 优先队列 堆实现 java
2019独角兽企业重金招聘Python工程师标准>>> package keepthinker.sort;import java.util.ArrayList; import jav ...
- java add offer_图解Java中的5大队列!(干货收藏)
Java 中的队列有很多,例如:ArrayBlockingQueue.LinkedBlockingQueue.PriorityQueue.DelayQueue.SynchronousQueue等,那它 ...
- java实现智能拼图,JAVA实现拼图游戏
JAVA实现拼图游戏 /** * Title: LoonFramework * Description:拼图图像处理[未优化](优化算法已内置于loonframework-game框架中.) * Co ...
- 【java后端学习】java语言基础(夯实基础)
文章目录 一.基础语法 1 java中的标识符 1.1 变量命名规范 1.2 保留字 2 java中的常量 3 java基本数据类型 4 数组 5 字符及字符串 6 运算符 7 控制语句 for语句 ...
- java常见面试题——java常见笔试题
注:转载自http://www.cnblogs.com/yhason/archive/2012/05/08/2489932.html,版权归其所有! 5.String是最基本的数据类型吗? 基本数据类 ...
- java复习系列[3] - Java虚拟机
文章目录 Java虚拟机 JRE 和 JDK 整体工作原理 类加载 class文件结构 类加载过程 双亲委派机制 运行时内存区域 整体划分 PC (Program Counter) JVM栈 局部变量 ...
- java面试题汇总 java面试题集合 - 网络收集
面试Java实习生时的一些面试题 分享到: 2011-09-26 14:42 作者: 来源:互联网 字号:T|T 摘要:还有一些针对我做过的项目问的一些问题.问了我许多问题中,大概有一半以上是回 ...
最新文章
- [C] 图的广度优先遍历
- SQL Server 2012--Reporting Service报表阅览工具 - Power View【转载】
- CentOS 7.x自定义开机启动设置
- 老板评价下属的普遍性原则
- Mysql 主外键与索引之间的区别和联系
- 使用gparted live分区工具对VMware及ESXI(vsphere)虚拟机进行根目录扩容(可视化界面操作)
- 分析单点登录cas的解决方式
- WKWebView概述
- 计算机网络未来发展5个趋势_Gravel Bike未来发展趋势
- LR实战之Discuz开源论坛——网页细分图结果分析(Web Page Diagnostics)
- Excel 如何让复制的内容保持原文本格式
- MySql安装错误代码1045的解决方案
- CSS3 Media Queries模板
- 窗体点击,空白处隐藏(stopPropagation)
- MathType7新版本数学公式编辑器上线功能特性
- 漫谈如何学习操作系统原理
- 中英文双语切换小程序开发制作
- colorbox加载ajax调用的html页面,ColorBox
- adb 清理内存_adb命令查看手机应用内存使用情况
- 通信设备选cat1还是选nbiot
热门文章
- chrome xp 扫描此文件时,防病毒软件意外失败
- css class选择器用法,CSS类选择器用法简明介绍
- pandas高效读取大文件(csv)方法之-parquet
- python中0xFFFFFFFFFFFFFFFF这种字符串是什么意思呢
- linux打开vivado_ubuntu启动vivado UBUNTU 16.04安装VIVADO成功启动SDK - Linux - 服务器之家...
- shsh验证服务器,SHSH(Signature HaSH blobs)是由Apple验证服务器根据iOS设备ECID和固件版本产生的一个签名证书...
- 【项目管理】ITTO-采购管理
- 必看2019年学员信息系统项目管理师长篇备考经验
- 信息系统项目管理师:第7章:项目成本管理(1)-章节重点
- Error Code: 1052. Column '列名' in where clause is ambiguous