补充基础：栈与队列模型

10、补充基础：栈与队列模型

(1)Queue

PriorityQueue

PriorityQueue是Queue队列实现类，PriorityQueue保存队列元素的顺序不是按照加入队列的顺序，而是按照队列元素的大小进行重新排序。当调用peek()或者poll()方法获取队列元素时，获取的是队列最小元素，而不是先入队列的元素。有点反先入先出规则。

public class DemoApplication {

    public static void main(String[] args) {

        PriorityQueue priorityQueue = new PriorityQueue();
        priorityQueue.offer(5);
        priorityQueue.offer(-1);
        priorityQueue.offer(3);
        priorityQueue.offer(7);

        //查看入队顺序
        System.out.println("队列输出：" + priorityQueue);

        //peek方法获取队头元素但是不删除元素
        System.out.println("peek()方法获取队头：" + priorityQueue.peek());

        //查看第一个元素即为最小元素
        System.out.println("第一个队列元素出队：" + priorityQueue.poll());
        System.out.println("第二个队列元素出队：" + priorityQueue.poll());
        System.out.println("第三个队列元素出队：" + priorityQueue.poll());
        System.out.println("第四个队列元素出队：" + priorityQueue.poll());
        System.out.println("null队列：" + priorityQueue.poll());
        
    }

}

输出：

队列输出：[-1, 5, 3, 7]
peek()方法获取队头：-1
第一个队列元素出队：-1
第二个队列元素出队：3
第三个队列元素出队：5
第四个队列元素出队：7
null队列：null

(2)Deque

其中，offerFisrt内部是调用了addFirst

ArrayDeque

ArrayDeque概述

ArrayDeque底层实现类似于ArrayList，都是通过动态、可分配的Object[]数组来实现元素存储，当集合元素超过数组容量，会重新分配一个新的数组来存储集合元素。

public class DemoApplication {
    public static void main(String[] args) {
        //可以作为栈来使用，先进后出
        ArrayDeque<String> arrayDeque = new ArrayDeque<>();
        arrayDeque.push("book01");
        arrayDeque.push("book03");
        arrayDeque.push("book02");
        arrayDeque.push("book04");

        System.out.println("原栈：" + arrayDeque);

        System.out.println("获取头部元素，但不删除该元素，peek(): " + arrayDeque.peek());
        System.out.println("获取头部元素，且删除该元素，pop(): " +arrayDeque.pop());
        System.out.println("获取第一个元素，但不删除：" + arrayDeque.getFirst());
        System.out.println("获取最后一个元素，但不删除：" + arrayDeque.getLast());

        System.out.println("在双端队列头部插入元素：" + arrayDeque.offerFirst("booknew01"));
        System.out.println("在双端队列尾部插入元素：" + arrayDeque.offerLast("booknew02"));
        System.out.println("新栈：" + arrayDeque);

    }

}

输出：

原栈：[book04, book02, book03, book01]
获取头部元素，但不删除该元素: book04
获取头部元素，且删除该元素: book04
获取第一个元素，但不删除：book02
获取最后一个元素，但不删除：book01
true
true
新栈：[booknew01, book02, book03, book01, booknew02]

LinkedList

LinkedList概述

LinkedList实现List，同时也实现了Deque，可以当做双端队列来使用，可以当做“栈”或“队列”使用。
  LinkedList与ArrayList、ArrayDeque不同之处在于底层实现，LinkedList底层是通过链表的形式存储元素，随机访问性能比较差，但是在插入、删除的时候性能比较好（只需要改变指针所指的地址就行）

LinkedList实现Deque的方法

void addFirst(Object e);     //将指定元素插入该双向队列的开头。
void addLast(Object e);　　//将指定元素插入该双向队列的末尾。
Iterator descendingIterator();  //返回以该双向队列对应的迭代器，该迭代器将以逆向顺序来迭代队列中的元素。
Object getFirst();　　　　　　//获取、但不删除双向队列的第一个元素。
Object getLast();　　           //获取、但不删除双向队列的最后一个元素。
boolean offerFirst(Object e);//将指定元素插入该双向队列的开头
boolean offerLast(Object e);//将指定元素插入该双向队列的结尾
Object peekFirst();             //获取、但不删除双向队列的第一个元素；如果此双端队列为空，则返回null。
Object peekLast();             //获取、但不删除该双向队列的最后一个元素；如果此双端队列为空，则返回null。
Object pollFirst();              //获取、并删除双向队列的第一个元素；如果此双端队列为空，则返回null。
Object pollLast();              //获取、并删除双向队列的最后一个元素，如果此双端队列为空，则返回null。
Object pop();                    //pop出该双向队列所表示的栈中第一个元素。
void push(Object e);          //将一个元素push进该双向队列所表示的栈中。
Object removeFirst();        //获取、并删除该双向队列的第一个元素。
Object removeFirstOccurrence(Object e);   //删除该双向队列的第一次的出现元素e。
removeLast();　　                    //获取、并删除该双向队列的最后一个元素。
removeLastOccurrence(Object e);    //删除该双向队列的最后一次的出现元素e

① 使用ArrayList模拟队列

import java.util.LinkedList;
import java.util.Queue;
//用linkedList模拟队列，因为链表擅长插入和删除
public class Hi {
    public static void main(String [] args) { //做剑指offer遇见过这个数结
        Queue<String> queue = new LinkedList<String>();
        //入队：追加元素:加到队尾部
        queue.add("zero");
        queue.offer("one");
        queue.offer("two");
        queue.offer("three");
        queue.offer("four");
        System.out.println(queue);//[zero, one, two, three, four]
        //出队：从队首取出元素并删除
        System.out.println(queue.poll());// zero
        System.out.println(queue.remove());//one
        System.out.println(queue);//[two, three, four]
        //查看队首：从队首取出元素但是不删除
        String peek = queue.peek();
        System.out.println(peek); //two
        //遍历队列，这里要注意，每次取完元素后都会删除，整个
        
        //全部出队：队列会变短，所以只需要判断队列的大小即可
        while(queue.size() > 0) {
            System.out.println(queue.poll());
        }//two three four
    }
}
　　

② 用linkedList模拟栈，因为链表擅长插入和删除

import java.util.Deque;
import java.util.LinkedList;
 
public class Hi {
    public static void main(String[] args) {
        /*模拟栈，这是从头开始进来的*/
        Deque<String> deque = new LinkedList<String>();
        /*Pushes an element onto the stack
         *at the head of this dequeue */
        deque.push("a");
        deque.push("b");
        deque.push("c");
        System.out.println(deque); //[c, b, a]
        //获取栈首元素后，元素不会出栈
        System.out.println(deque.peek());//c
        while(deque.size() > 0) {
            //获取栈首元素后，元素将会出栈
            System.out.println(deque.pop());//c b a
        }
        System.out.println(deque);//[]
         
        /*模拟栈*/
        deque.offerLast("a");
        deque.offerLast("b");
        deque.offerLast("c");// [a, b, c]
        while(!deque.isEmpty())
            System.out.println(deque.pollLast());
    }   // 先输出c再b最后a
}