Queue介绍重要复习

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());
    }
}

自定义实现一个基于大根堆的优先级队列，支持泛型