栈Stack |队列Queue| 双端队列Deque| 优先队列PriorityQueue
堆栈和队列特点： 1. Stack - First In Last Out(FILO) 先入后出，先进来的被压入栈底 .Array or Linked List 2. Queue - First In First Out(FIFO) 排队时先来先出 .Array or Doubly Linked List
1. 栈Stack
Stack中文名可叫堆栈，不能叫堆，堆是heap
手写栈堆比较少了，很多语言在标准库都实现了。
1.1 概念与特性
后进先出，先进后出，这就是典型的“栈”结构。
从栈的操作特性上来看，栈是一种“操作受限”的线性表，只允许在一端插入和删除数据。从功能上来说，数组或链表可以替代栈，但特定的数据结构是对特定场景的抽象，而且，数组或链表暴露了太多的操作接口，操作上的确灵活自由，但使用时就比较不可控，自然也就更容易出错。
当某个数据集合只涉及在一端插入和删除数据，并且满足后进先出、先进后出的特性，我们就应该首选“栈”这种数据结构。
最近相关性 《====》 栈 现实中的洋葱，一层层，反应在工程中都具有 从外而内 或者 由内而外这种逐渐扩散，且它的最外层和最外层是一对，最内层和最内层是一对 可叫最近相关性。
栈：查询 O(n)，平均情况，要看它栈中栈底的元素，要清空了才能看到。
插入和删除它的栈顶元素只需要一次性操作，时间复杂度是O(1)。
1.2 如何实现一个“栈”？
从栈的定义里，栈主要包含两个操作，入栈和出栈，即在栈顶插入一个数据和从栈顶删除一个数据。
自定义一个栈既可以用数组来实现，也可以用链表来实现。 用数组实现的栈，叫作顺序栈，用链表实现的栈，叫作链式栈。
// 基于数组实现的顺序栈 public class ArrayStack { private String[] items; // 数组 private int count; // 栈中元素个数 private int n; // 栈的大小 // 初始化数组，申请一个大小为 n 的数组空间 public ArrayStack(int n) { this.items = new String[n]; this.n = n; this.count = 0; } // 入栈操作 public boolean push(String item) { // 数组空间不够了，直接返回 false，入栈失败。 if (count == n) return false; // 将 item 放到下标为 count 的位置，并且 count 加一 items[count] = item; ++count; return true; } // 出栈操作 public String pop() { // 栈为空，则直接返回 null if (count == 0) return null; // 返回下标为 count-1 的数组元素，并且栈中元素个数 count 减一 String tmp = items[count - 1]; --count; return tmp; } }
不管是顺序栈还是链式栈，存储数据只需要一个大小为 n 的数组就够了。在入栈和出栈过程中，只需要一两个临时变量存储空间，所以空间复杂度是 O(1)。（空间复杂度是指除了原本的数据存储空间外，算法运行还需要额外的存储空间，这里存储数据需要一个大小为 n 的数组，并不是说空间复杂度就是 O(n) ）
不管是顺序栈还是链式栈，入栈、出栈只涉及栈顶个别数据的操作，时间复杂度都是 O(1)。
在Java中，用Deque可以实现Stack的功能：
- 把元素压栈：
push(E)/addFirst(E)； - 把栈顶的元素“弹出”：
pop(E)/removeFirst()； - 取栈顶元素但不弹出：
peek(E)/peekFirst()。
为什么Java的集合类没有单独的Stack接口呢？因为有个遗留类名字就叫Stack，出于兼容性考虑，所以没办法创建Stack接口，只能用Deque接口来“模拟”一个Stack了。不要使用遗留类Stack
当我们把Deque作为Stack使用时，注意只调用push()/pop()/peek()方法，不要调用addFirst()/removeFirst()/peekFirst()方法，这样代码更加清晰。
1.3 栈的应用
① 栈在函数调用中的应用，经典的一个应用场景就是函数调用栈。
操作系统给每个线程分配了一块独立的内存空间，这块内存被组织成“栈”这种结构, 用来存储函数调用时的临时变量。每进入一个函数，就会将临时变量作为一个栈帧入栈，当被调用函数执行完成，返回之后，将这个函数对应的栈帧出栈。
② 栈在表达式求值中的应用
我们再来看栈的另一个常见的应用场景，编译器如何利用栈来实现表达式求值。
为了方便解释，我将算术表达式简化为只包含加减乘除四则运算，比如：34+13*9+44-12/3。
③ 栈在括号匹配中的应用
假设表达式中只包含三种括号，圆括号 ()、方括号 [] 和花括号{}，并且它们可以任意嵌套。比如，{[{}]}或 [{()}([])] 等都为合法格式，而{[}()] 或 [({)] 为不合法的格式。那我现在给你一个包含三种括号的表达式字符串，如何检查它是否合法呢？
这里也可以用栈来解决。我们用栈来保存未匹配的左括号，从左到右依次扫描字符串。当扫描到左括号时，则将其压入栈中；当扫描到右括号时，从栈顶取出一个左括号。如果能够匹配，比如“(”跟“)”匹配，“[”跟“]”匹配，“{”跟“}”匹配，则继续扫描剩下的字符串。如果扫描的过程中，遇到不能配对的右括号，或者栈中没有数据，则说明为非法格式。
当所有的括号都扫描完成之后，如果栈为空，则说明字符串为合法格式；否则，说明有未匹配的左括号，为非法格式。
基于栈实现浏览器的前进和后退功能
当你依次访问完一串页面 a-b-c 之后，点击浏览器的后退按钮，就可以查看之前浏览过的页面 b 和 a。当你后退到页面 a，点击前进按钮，就可以重新查看页面 b 和 c。但是，如果你后退到页面 b 后，点击了新的页面 d，那就无法再通过前进、后退功能查看页面 c 了。
用两个栈就可以非常完美地解决这个问题。
我们使用两个栈，X 和 Y，我们把首次浏览的页面依次压入栈 X，当点击后退按钮时，再依次从栈 X 中出栈，并将出栈的数据依次放入栈 Y。当我们点击前进按钮时，我们依次从栈 Y 中取出数据，放入栈 X 中。当栈 X 中没有数据时，那就说明没有页面可以继续后退浏览了。当栈 Y 中没有数据，那就说明没有页面可以点击前进按钮浏览了。
栈的应用场景
1) 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
2) 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
3) 表达式的转换与求值(实际解决)。
4) 二叉树的遍历。
5) 图形的深度优先(depth一first)搜索法。
思考
内存中的堆栈和数据结构堆栈不是一个概念，可以说内存中的堆栈是真实存在的物理区，数据结构中的堆栈是抽象的数据存储结构。
内存空间在逻辑上分为三部分：代码区、静态数据区和动态数据区，动态数据区又分为栈区和堆区。
- 代码区：存储方法体的二进制代码。高级调度（作业调度）、中级调度（内存调度）、低级调度（进程调度）控制代码区执行代码的切换。
- 静态数据区：存储全局变量、静态变量、常量，常量包括final修饰的常量和String常量。系统自动分配和回收。
- 栈区：存储运行方法的形参、局部变量、返回值。由系统自动分配和回收。
- 堆区：new一个对象的引用或地址存储在栈区，指向该对象存储在堆区中的真实数据。
2. 队列Queue
2.1 概念和特性
队列，排队，先来先出，依次排队。 一头进另外一头出。
队列 ，先来后到，公平性，队列
栈：查询 O(n)，平均情况，要看它栈中栈底的元素，要清空了才能看到。
插入和删除它的栈顶元素只需要一次性操作，时间复杂度是O(1)。
队列：与栈类似， 查询是O(n），插入和删除是O(1）。
查询操作O(n)，因为它是元素无序的 ，就必须把这个数据结构遍历一遍
把它想象成排队买票，先来的先买，后来的人只能站末尾，不允许插队。先进者先出，这就是典型的“队列”。
我们知道，栈只支持两个基本操作：入栈 push()和出栈 pop()。
队列跟栈非常相似，支持的操作也很有限，最基本的操作也是两个：
入队 enqueue()，放一个数据到队列尾部；出队 dequeue()，从队列头部取一个元素。
所以，队列跟栈一样，也是一种操作受限的线性表数据结构。
作为一种非常基础的数据结构，队列的应用也非常广泛，特别是一些具有某些额外特性的队列，比如循环队列、阻塞队列、并发队列。它们在很多偏底层系统、框架、中间件的开发中，起着关键性的作用。比如高性能队列 Disruptor、Linux 环形缓存，都用到了循环并发队列；Java concurrent 并发包利用 ArrayBlockingQueue 来实现公平锁等。
2.2 顺序队列和链式队列
队列跟栈一样，也是一种抽象的数据结构。它具有先进先出的特性，支持在队尾插入元素，在队头删除元素，如何实现一个队列？
跟栈一样，队列可以用数组来实现，也可以用链表来实现。用数组实现的栈叫作顺序栈，用链表实现的栈叫作链式栈。
同样，用数组实现的队列叫作顺序队列，用链表实现的队列叫作链式队列。
对于栈来说，我们只需要一个栈顶指针就可以了。但是队列需要两个指针：一个是 head 指针，指向队头；一个是 tail 指针，指向队尾。
队列Queue实现了一个先进先出（FIFO）的数据结构：
- 通过
add()/offer()方法将元素添加到队尾； - 通过
remove()/poll()从队首获取元素并删除； - 通过
element()/peek()从队首获取元素但不删除。
要避免把null添加到队列。
// 这是一个List: List<String> list = new LinkedList<>(); // 这是一个Queue: Queue<String> queue = new LinkedList<>();LinkedList即实现了List接口，又实现了Queue接口，但是，在使用的时候，如果我们把它当作List，就获取List的引用，如果我们把它当作Queue，就获取Queue的引用：
2.3 循环队列
循环队列是为了解决顺序队列在 tail == n 时，需要数据搬运操作的问题。
队列为空时可以根据 head == tail 来判断。循环队列满时，tail 指针位置不存储数据，所以队满判断公式为：
(tail + 1) % n = head
2.4 阻塞队列和并发队列
阻塞队列其实就是在队列基础上增加了阻塞操作。简单来说，就是在队列为空的时候，从队头取数据会被阻塞。因为此时还没有数据可取，直到队列中有了数据才能返回；如果队列已经满了，那么插入数据的操作就会被阻塞，直到队列中有空闲位置后再插入数据，然后再返回。 即 “生产者 - 消费者模型”，可使用阻塞队列实现一个“生产者 - 消费者模型”， 这种基于阻塞队列实现的“生产者 - 消费者模型”，可以有效地协调生产和消费的速度。
阻塞队列，在多线程情况下，会有多个线程同时操作队列，这个时候就会存在线程安全问题，如何实现一个线程安全的队列呢？
线程安全的队列我们叫作并发队列。最简单直接的实现方式是直接在 enqueue()、dequeue() 方法上加锁，但是锁粒度大并发度会比较低，同一时刻仅允许一个存或者取操作。实际上，基于数组的循环队列，利用 CAS 原子操作，可以实现非常高效的并发队列。这也是循环队列比链式队列应用更加广泛的原因。
2.5 优先队列 PriorityQueue
正常⼊、按照优先级出
实现了一个优先队列：从队首获取元素时，总是获取优先级最高的元素。
PriorityQueue默认按元素比较的顺序排序（必须实现Comparable接口），也可以通过Comparator自定义排序算法（元素就不必实现Comparable接口）。
PriorityQueue和Queue的区别在于，它的出队顺序与元素的优先级有关，对PriorityQueue调用remove()或poll()方法，返回的总是优先级最高的元素。
要使用PriorityQueue，我们就必须给每个元素定义“优先级”。
2.6 双端队列 Deque （Double Ended Queue）
- 既可以添加到队尾，也可以添加到队首；
- 既可以从队首获取，又可以从队尾获取。
同时具有queue和stack的功能。
Deques can also be used as LIFO (Last-In-First-Out) stacks. This
* interface should be used in preference to the legacy {@link Stack} class.
* When a deque is used as a stack, elements are pushed and popped from the
* beginning of the deque.
Deque是一个接口，它的实现类有ArrayDeque和LinkedList （LinkedList真是一个全能选手，它即是List，又是Queue，还是Deque）
// 不推荐的写法: LinkedList<String> deque = new LinkedList<>();
// 推荐的写法： Deque<String> deque = new LinkedList<>(); （面向抽象编程的一个原则就是：尽量持有接口，而不是具体的实现类。）
- 将元素添加到队首或队尾：/
addFirst()即push()/offerFirst()；addLast()/offerLast() - 从队首／队尾获取元素并删除：
removeFirst()即pop()/pollFirst()/removeLast()/pollLast()； - 从队首／队尾获取元素但不删除：
getFirst()/peekFirst()/getLast()/peekLast()； - 总是调用
xxxFirst()/xxxLast()以便与Queue的方法区分开； - 避免把
null添加到队列。
2.7 队列的应用
队列在线程池等有限资源池中的应用
CPU 资源是有限的，任务的处理速度与线程个数并不是线性正相关。相反，过多的线程反而会导致 CPU 频繁切换，处理性能下降。所以，线程池的大小一般都是综合考虑要处理任务的特点和硬件环境，来事先设置的。
当我们向固定大小的线程池中请求一个线程时，如果线程池中没有空闲资源了，这个时候线程池如何处理这个请求？是拒绝请求还是排队请求？各种处理策略又是怎么实现的呢？
两种处理策略：
- 一种是非阻塞的处理方式，直接拒绝任务请求；
- 一种是阻塞的处理方式，将请求排队，等到有空闲线程时，取出排队的请求继续处理。
那如何存储排队的请求呢？
公平地处理每个排队的请求，先进者先服务，所以队列这种数据结构很适合来存储排队请求。队列有基于链表和基于数组这两种实现方式。这两种实现方式对于排队请求又有什么区别呢？
基于链表的实现方式，可以实现一个支持无限排队的无界队列（unbounded queue），但是可能会导致过多的请求排队等待，请求处理的响应时间过长。所以，针对响应时间比较敏感的系统，基于链表实现的无限排队的线程池是不合适的。
基于数组实现的有界队列（bounded queue），队列的大小有限，所以线程池中排队的请求超过队列大小时，接下来的请求就会被拒绝，这种方式对响应时间敏感的系统来说，就相对更加合理。不过，设置一个合理的队列大小，也是非常有讲究的。队列太大导致等待的请求太多，队列太小会导致无法充分利用系统资源、发挥最大性能。