/**
* 【java.util.Queue】
*
* The {@link #remove()} and {@link #poll()} methods remove and return the head of the queue.
* Exactly which element is removed from the queue is a function of the queue's ordering policy, which differs from implementation to implementation.
* The {@code remove()} and {@code poll()} methods differ only in their behavior when the queue is empty: the {@code remove()} method throws an exception, while the {@code poll()} method returns {@code null}.
* remove、poll 方法 移除并返回 头元素；
* 从队列中 删除哪个元素 是队列排序策略的一个函数，这在不同的实现中是不同的。
* remove 和 poll 在空队列中行为不同：remove 抛异常、poll 返回null；
*
* The {@link #element()} and {@link #peek()} methods return, but do not remove, the head of the queue.
* element 和 peek 方法 仅返回（不移除）头元素；
*
* {@code Queue} implementations generally do not allow insertion of {@code null} elements.
* Queue 实现 不允许插入null元素值；
*
* public interface Queue<E> extends Collection<E> {
*
* }
*
*
* 【java.util.Deque】
* A linear collection that supports element insertion and removal at both ends.
* The name deque is short for "double ended queue".
* 线性集合：支持 双端 插入、移除；
* double ended queue 的缩写；
*
* This interface extends the {@link Queue} interface.
* When a deque is used as a queue, FIFO (First-In-First-Out) behavior results.
* Deques can also be used as LIFO (Last-In-First-Out) stacks.
*
*
*
*
*/
/**
* 【java.util.LinkedList】
* Doubly-linked list implementation of the {@code List} and {@code Deque} interfaces.
* Implements all optional list operations, and permits all elements (including {@code null}).
* 实现了 List、Deque 接口的 双向链表；
* LinkedList 允许 null元素值；
*
* public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
*
* private static class Node<E> {
* E item;
* Node<E> next;
* Node<E> prev;
*
* Node(Node<E> prev, E element, Node<E> next) {
* this.item = element;
* this.next = next;
* this.prev = prev;
* }
* }
*
* transient int size = 0;
* transient Node<E> first;
* transient Node<E> last;
*
*
* // ***时间复杂度分析
*
* // >>>add 追加到tail node
* O(1);
* public boolean add(E e) {
* linkLast(e);
* return true;
* }
*
* void linkLast(E e) {
* final Node<E> l = last;
* final Node<E> newNode = new Node<>(l, e, null);
* last = newNode;
* if (l == null)
* first = newNode;
* else
* l.next = newNode;
* size++;
* modCount++;
* }
*
* public void addFirst(E e) {
* linkFirst(e);
* }
*
* public void addLast(E e) {
* linkLast(e);
* }
*
* public void add(int index, E element) { insert
* if (index == size)
* linkLast(element); // tail 插入， O(1)
* else
* linkBefore(element, node(index)); // 中间插入， O(n/2)
* }
*
* public E set(int index, E element) { replace
* Node<E> x = node(index);
* E oldVal = x.item;
* x.item = element;
* return oldVal;
* }
*
* // >>>get
* O(n/2)
* public E get(int index) {
* checkElementIndex(index);
* return node(index).item;
* }
*
* Node<E> node(int index) {
* if (index < (size >> 1)) { // 二分法
* Node<E> x = first;
* for (int i = 0; i < index; i++)
* x = x.next;
* return x;
* } else {
* Node<E> x = last;
* for (int i = size - 1; i > index; i--)
* x = x.prev;
* return x;
* }
* }
*
* // ***remove
* public boolean remove(Object o) {
* if (o == null) {
* for (Node<E> x = first; x != null; x = x.next) { // head O(1)
* if (x.item == null) { // tail O(n)
* unlink(x);
* return true;
* }
* }
* } else {
* for (Node<E> x = first; x != null; x = x.next) {
* if (o.equals(x.item)) {
* unlink(x);
* return true;
* }
* }
* }
* return false;
* }
*
* public E remove() { // O(1)
* return removeFirst();
* }
*
* // ***indexOf
* public int indexOf(Object o) {
* int index = 0;
* if (o == null) {
* for (Node<E> x = first; x != null; x = x.next) { // head O(1)
* if (x.item == null) // tail O(n)
* return index;
* index++;
* }
* } else {
* for (Node<E> x = first; x != null; x = x.next) {
* if (o.equals(x.item))
* return index;
* index++;
* }
* }
* return -1;
* }
*
* // ***peek
* public E peek() { // Retrieves, but does not remove, the head (first element) of this list.
* final Node<E> f = first;
* return (f == null) ? null : f.item;
* }
*
* // ***poll
* public E poll() { // Retrieves and removes the head (first element) of this list.
* final Node<E> f = first;
* return (f == null) ? null : unlinkFirst(f);
* }
*
* // ***pop
* public E pop() {
* return removeFirst();
* }
*
* }
*
*
*/
