Queue介绍
队列
先进先出
Queue接口除了实现Collection接口下提供的方法,还提供有特殊方法,
常用API
public class ProrityQueue222 {
public static void main(String[] args) {
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(10, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
priorityQueue.add(12);
priorityQueue.add(11);
priorityQueue.add(99);
priorityQueue.add(5);
priorityQueue.add(14);
priorityQueue.add(2);
System.out.println(priorityQueue.poll());//5
Iterator<Integer> iterator = priorityQueue.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next()+" ");
}
System.out.println();
System.out.println(priorityQueue.poll());//11
Iterator<Integer> iterator1 = priorityQueue.iterator();
while (iterator1.hasNext()){
System.out.print(iterator1.next()+" ");
}
System.out.println();
}
}
大根堆结果:
不用比较器或者默认都是小根堆
优先级队列特点:
1.集合数据按照一定的优先级进行排序(集合内部是不能进行排序的,只能保证队列头部是最小的或者最大的)
2.不能存储null值
3.数据是可以重复的
优先级队列底层实现的数据结构是堆
插入元素过程:
插入元素在最后的位置,插入之前堆是满足小根堆的特点,插入数据之后是不一定满足小根堆特点,
1.插入的元素的位置和父节点比较
2,插入数据 < 父节点 ,交换,指针指向父节点继续比较
结束条件:1.根节点结束或 插入数据 > 节点,满足条件,退出****
删除元素:
删除元素:
1,删除栈顶元素(0号索引位置)
2.将最后一个元素放到栈顶元素的位置,并把最后一个元素置为null
3.从上往下进行调整
if 栈顶元素 < 左右孩子中最小的 (即栈顶元素就是三个数中的最小值) 满足条件,退出
else 和 较小的孩子进行交换,指针指向较小的孩子,继续上面的比较
结束条件:指针指向叶子节点或者 满足条件
自定义实现优先级队列##
- List item
public class ProrityQueue222 {
//数据存储
private Integer data[];
//存储数据的个数
private int size;
private Integer capacity;
public ProrityQueue222(Integer initCapacity){
data =new Integer[initCapacity];
size=0;
capacity=initCapacity;
}
public ProrityQueue222(){
this(16);
}
//判满
public void isCapacity(){
int newLength=data.length+(data.length>>1);
data=Arrays.copyOf(data,newLength);
}
//插入数据
public void add(Integer V){
//判满
if(size>=capacity){
isCapacity();
}
if(size==0){
data[0]=V;
}else{
data[size]=V;
//向上调整
siftUp(size);
}
size++;
}
//向上调整
public void siftUp(int k){
while(k>0) {
int parentIndex = (k - 1) / 2;
if (data[k] < data[parentIndex]) {
//当前节点小于父节点
int temp = data[k];
data[k] = data[parentIndex];
data[parentIndex] = temp;
k = parentIndex;
} else {
break;
}
}
}
//向下调整
public void siftDown(int k){
int half=size/2;//找到所有的非叶子节点
while(k<half) {
int leftChild = 2 * k + 1;
int rightChild = 2 * k + 2;
if (rightChild < size && data[rightChild] <data[ leftChild]) {
leftChild = rightChild;//保证左孩子是最小的
}
if (data[k] > data[leftChild]) {
int temp = data[k];
data[k] = data[leftChild];
data[leftChild] = temp;
k = leftChild;
} else {
break;
}
}
}
//删除数据
public Integer remove(){
if(size==0){
return null;
}
int oldValue=data[0];
data[0] = data[size- 1];
siftDown(0);
data[size - 1] = null;
size--;
return oldValue;
}
//获取栈顶元素
public Integer peek(){
return data[0];
}
public static void main(String[] args) {
ProrityQueue222 prorityQueue222 = new ProrityQueue222();
prorityQueue222.add(12);
prorityQueue222.add(11);
prorityQueue222.add(99);
prorityQueue222.add(5);
prorityQueue222.add(14);
prorityQueue222.add(2);
System.out.println(prorityQueue222.remove());
}
}
自定义实现一个基于大根堆的优先级队列,支持泛型