JavaSE---LinkedList

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

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