文章目录
Author : lss 路漫漫其修远兮，不至于代码
LinkedList 的 队列 和 栈
简介
上次我们就提到了过了，LinkedList 即是一个顺序容器，也是一个队列 （queue) 和 栈 (Stack), 本节将对 LinkedList 的队列和栈， 进行刨析。
上个章节已经说过，LinkedList 不仅实现了 List 同时 实现了 Deque 。而 Deque 又实现了 Queue。Queue这个接口不仅继承了来自 Collection 接口的方法之外，同时还提供了一些额外方法。这里分为了两组。一组以抛异常的形式(无数据会抛出异常)，另一组以返回值实现(无数据返回 null )
Queue 方法
| Throws exception | Return value | |
|---|---|---|
| insert （添加） | add （ e ) | offer ( e ) |
| Remove(移除) | remove | poll() |
| Examine(获取) | element() | peek() |
说完这个 Queue 后 再来看下 Deque 这个接口。 Deque（ double ended queue）表示双向队列。由于是双向队列，所以需要对列队的头部和尾部都进行操作。它同时也支持了两种实现方式 一种以抛异常形式，另一种为返回值形式。
Deque 方法
| Deque Method | Description |
|---|---|
| addLast （e） | 队尾添加 |
| offerLast (e) / offreFirst | 队尾添加 |
| removeFirst() / removeLast | 获取并删除首元素 |
| pollFirst() / pollLast | 获取并删除首元素 |
| getFirst() / getLast | 获取但不删除栈顶元素 |
| peekFirst() / peekLast | 获取但不删除栈顶元素 |
LinkedList 中的 Queue
// 因为是队列,所以我们的重点只关心头节点数据。
// 获取方法
public E peek() {
final Node<E> f = first;
// 头节点为null 返回 null ： 返回该节点数据
return (f == null) ? null : f.item;
}
// 都是获取头节点的数据方法 唯一区别：这个方法会抛出异常
public E element() {
return getFirst();
}
public E getFirst() {
final Node<E> f = first;
if (f == null)
// 没有数据会抛出异常
throw new NoSuchElementException();
return f.item;
}
// 删除方法
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
// 若头节点存在数据，将头节点数据，指针置null,将 first 改为后驱节点。 如果后驱节点为null,则都设置为 null。
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
// 获取当前节点数据
final E element = f.item;
// 获取当前节点的后驱节点
final Node<E> next = f.next;
// 将当前节点数据 置 null
f.item = null;
// 将当前节点的后驱节点 置 null
f.next = null; // help GC
// 头节点指向 当前节点的后驱节点
first = next;
// 后驱节点为 null
if (next == null)
last = null;
else
// 后驱节点的前驱节点为 null
next.prev = null;
size--;
modCount++;
return element;
}
public E remove() {
return removeFirst();
}
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
// 上面已有解析
return unlinkFirst(f);
}
// 添加
public boolean offer(E e) {
// 其实就是一个正常插入方法 上期已经讲过
return add(e);
}
LinkedList 的 Dueue
// 队尾加入元素
public void addLast(E e) {
// 上期已经解析，不再多说
linkLast(e);
}
// 队尾添加
public boolean offerLast(E e) {
// 也就是正常插入 不在多说。
addLast(e);
return true;
}
// 头部添加
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
// 头部添加 和 尾部添加差不多 。
private void linkFirst(E e) {
// 头节点
final Node<E> f = first;
// 将插入的值包装成 Node
final Node<E> newNode = new Node<>(null, e, f);
// 头节点为 当前插入的节点
first = newNode;
if (f == null)
// 此时只有一个数据 ，既是头节点，也是尾节点
last = newNode;
else
// 将之前的头节的前驱改为 当前插入的节点。
f.prev = newNode;
size++;
modCount++;
}
// 删除头节点
// 这里调用的方法 之前都有讲解。所以没有做过多解析
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
// 获取
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E element() {
return getFirst();
}
至此，已经把两种实现方式都展示出来了。这也就是LinkedList 作为队列的一种操作。那接下来看看栈的一些操作吧。
LinkedList 的 Stack
// 添加。 也就是进栈
public void push(E e) {
addFirst(e);
}
// 上面有讲过。所以不写了哦。
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
// 获取并删除
public E pop() {
return removeFirst();
}
// 这里也就是我们所说的出栈。 将头节点数据取出，再将头节点改为取出节点的后驱节点
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
// 上面都有哦。。
return unlinkFirst(f);
}
//获取但不删除元素
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
至此，LinkedList 中的东西多多少少都已经阐述完了。
总结: LinkedList 既是一个顺序容器 也是一个队列 和 栈。底层是由双向链表组成。不仅实现了 List 还实现了 Deque。 同时Deque 实现了 Queue 。 这两个接口都分别提供了添加，获取，删除。 等操作。分别以两种方式实现。一种以抛异常，另一种为返回值类型。 再作为栈的时候，只有一种方式实现，即抛异常的形式。
上期我们说到过一个东西。不知你还是否记得。 在使用 队列和栈的时候不推荐使用 LinkeList 而是推荐使用ArrayDeque。 从直意上看，是一个双向数组，也就是说数组的两端都可以进行添加和删除元素的操作。即循环数组 Java 中并没有这样的数组。因为Java中的数组是线性的，这里的循环数组表面看是一个数组，但是在逻辑上。他没有数组的固定开头和结尾。即可以在头部添加数据，也可以在尾部添加数据，不需要大面积的挪动数据。
ArrayDeque的实现
先来看一副图吧，从中发现这个循环数组中多了两个指针 head, tail head指针指向了第一个有效的元素,tail指向的是尾端可插入的元素位置。 因为这个数组是循环的所以。 head 不一定是 0 tail 也不一定比 head 大。ArrayDeque 是不允许 null 存储。
添加
从图中观察，在添加元素的时候应该考虑以下几点问题
- 数组容量是否足够大。
- head 是否存在下标越界。
//添加
public void addFirst(E e) {
if (e == null)//不允许放入null
throw new NullPointerException();
// 下标是否越界
// 假设当前在插入一个元素后 head 为0 在调用一次这个方法， 这个时候head 就为 -1 了。
// 这里代表是如果是 -1 的话就对这个数组长度取补数 这里计算head 越界只会是 -1，
// 若有不懂请自行研究二进制
elements[head = (head - 1) & (elements.length - 1)] = e;
// 当两个指针相撞 代表容量已满
if (head == tail)
//扩容 这里是进行的 2 倍的扩容
doubleCapacity();
}
public void addLast(E e) {
if (e == null)
throw new NullPointerException();
// 赋值
elements[tail] = e;
// 下标是否越界。 这里和上面的 其实差不多。
if ( (tail = (tail + 1) & (elements.length - 1)) == head)
//扩容
doubleCapacity();
}
获取并删除 poll
public E pollFirst() {
E result = elements[head];
if (result == null)//null值意味着deque为空
return null;
elements[h] = null;//let GC work
head = (head + 1) & (elements.length - 1);//下标越界处理
return result;
}
public E pollLast() {
//计算tail 的上一个位置
int t = (tail - 1) & (elements.length - 1);
E result = elements[t];
if (result == null)
return null;
elements[t] = null;
tail = t;
return result;
}
返回并不删除 peek
public E peekFirst() {
return elements[head]; // elements[head] is null if deque empty
}
public E peekLast() {
return elements[(tail - 1) & (elements.length - 1)];
}
总结: ArrayDeque 和 LinkedList 性能差距 ？ 为什么选择 ArrayDeque ?
-
ArrayDeque 底层循环数组实现，不容置疑，查询效率肯定高于 LinkedList。
-
循环数组不会存在删除数据后需要挪动后面的数据。所以摒弃了 数组 删除效率慢的问题
public E peekFirst() {
return elements[head]; // elements[head] is null if deque empty
}
public E peekLast() {
return elements[(tail - 1) & (elements.length - 1)];
}
总结: ArrayDeque 和 LinkedList 性能差距 ？ 为什么选择 ArrayDeque ?
-
ArrayDeque 底层循环数组实现，不容置疑，查询效率肯定高于 LinkedList。
-
循环数组不会存在删除数据后需要挪动后面的数据。所以摒弃了 数组 删除效率慢的问题