《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》,点击传送门,即可获取!
// 这样index在后半段的时候可以少遍历一半的元素
if (index < (size >> 1)) {
// 如果是在前半段
// 就从后往前遍历
Node x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
//如果是在前半段
//就从前往后遍历
Node x = last;
for (int i = size - 1; i > index; i–)
x = x.prev;
return x;
}
}
- 头插法
private void linkFirst(E e) {
// 首节点
final Node f = first;
// 创建新节点,新节点的next是首节点
final Node newNode = new Node<>(null, e, f);
first = newNode;
// 判断链表是不是为空
// 如果是就把last也置为新节点
// 否则把原首节点的prev指针置为新节点
if (f == null)
last = newNode;
else
f.prev = newNode;
//元素个数加1
size++;
// 修改次数 +1,用于 fail-fast 处理
modCount++;
}
public void addFirst(E e) {
linkFirst(e);
}
- 尾插法
void linkLast(E e) {
//尾结点
final Node l = last;
//新节点
final Node newNode = new Node<>(l, e, null);
//尾结点置为新节点
last = newNode;
//如果链表为空,头结点指向尾结点
if (l == null)
first = newNode;
else
l.next = newNode;
//元素个数加1
size++;
// 修改次数 +1,用于 fail-fast 处理
modCount++;
}
public void addLast(E e) {
linkLast(e);
}
public boolean add(E e) {
linkLast(e);
return true;
}
在链表头部和尾部插入时间复杂度都是O(1),头插法和尾插法的示意图如下:
- 中间插入法:中间插入需要找到插入位置节点,改变该节点的前趋和该节点前趋节点的后继
//根据索引插入节点
public void add(int index, E element) {
//判断是否越界
checkPositionIndex(index);
//未插入
if (index == size)
linkLast(element);
else
//找到索引位置节点,在该节点前插入新节点
linkBefore(element, node(index));
}
// 在节点succ之前添加元素
void linkBefore(E e, Node succ) {
//节点succ的前趋节点
final Node pred = succ.prev;
//新节点
final Node newNode = new Node<>(pred, e, succ);
//改变节点succ的前趋指向
succ.prev = newNode;
// 判断前置节点是否为空
// 如果为空,说明是第一个添加的元素,头结点重新赋值
// 否则修改前置节点的next为新节点
if (pred == null)
first = newNode;
else
pred.next = newNode;
//元素个数加1
size++;
// 修改次数 +1,用于 fail-fast 处理
modCount++;
}
在中间添加元素效率低一些,首先要先找到插入位置的节点,再修改前后节点的指针,时间复杂度为O(n)。
双链表中删除元素只需要改变前趋和后继的指向。
- 删除头节点
//删除头节点
public E removeFirst() {
final Node f = first;
//如果链表为空,抛出异常
if (f == null)
throw new NoSuchElementException();
// 删除首节点
return unlinkFirst(f);
}
// 删除头节点
private E unlinkFirst(Node f) {
// 头结点
final E element = f.item;
//头结点后继节点
final Node next = f.next;
//头结点数据域后继置空,帮助GC
f.item = null;
f.next = null;
//头结点置为后继节点
first = next;
// 如果只有一个元素,删除了,把last也置为空
// 否则把next的前趋置为空
if (next == null)
last = null;
else
next.prev = null;
size–;
modCount++;
//返回删除的节点
return element;
}
- 删除尾结点
//删除尾结点
public E removeLast() {
//尾结点
final Node l = last;
//链表为空,抛出异常
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
//删除尾结点
private E unlinkLast(Node l) {
// 尾结点元素
final E element = l.item;
//尾结点前趋节点
final Node prev = l.prev;
//尾结点数据、前趋置为null,帮助GC
l.item = null;
l.prev = null;
//尾结点置为前趋节点
last = prev;
// 如果只有一个元素,删除了把first置为空
// 否则把前置节点的next置为空
if (prev == null)
first = null;
else
prev.next = null;
size–;
modCount++;
//返回删除的节点
return element;
}
注意:
不管是上一节的头插入和未插入,还是这一节的删除头节点和删除尾结点,都没有在List中定义。前面提到,LinkedList实现了Deque接口,所以这是作为双向队列的LinkedList插入和删除元素的方式。还有获取头结点和尾结点的方法getFirst()和getLast(),同样都是双向队列的实现。
- 删除指定位置的节点
//删除指定位置的节点
public E remove(int index) {
//检查越界情况
checkElementIndex(index);
//根据索引找到节点,删除
return unlink(node(index));
}
//删除指定节点
E unlink(Node x) {
// 删除节点的值
final E element = x.item;
//被删除节点的后继节点
final Node next = x.next;
//被删除节点的前趋节点
final Node prev = x.prev;
// 如果前趋节点为空
// 说明是首节点,让first指向x的后继节点
// 否则修改前置节点的next为x的后继节点
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
// 如果后继节点为空
// 说明是尾节点,让last指向x的前趋节点
// 否则修改后置节点的prev为x的前趋节点
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
// 清空x的元素值,协助GC
x.item = null;
// 元素个数减1
size–;
// 修改次数加1,fail-fast
modCount++;
//返回删除的元素
return element;
}
删除头尾节点,时间复杂度为O(1)。
在中间删除元素,首先要找到删除位置的节点,再修改前后指针,时间复杂度为O(n)。
前面还提到,LinkedList可以作为栈使用,栈的特点是先进后出,LinkedList同样有作为栈的方法实现。
入栈:插入头节点
public void push(E e) {
addFirst(e);
}
出栈:删除头结点
public E pop() {
return removeFirst();
}
============================================================================
LinkedList作为Java中链表的实现,ArrayList作为顺序表的实现(ArrayList源码阅读笔记),LinkedList常常被拿来和ArrayList来进行比较。
LinkedList、ArrayList基本操作时间效率对比如下(粗略对比):
| 操作 | ArrayList | LinkedList |
| — | — | — |
| get(int index) | O(1) | O(n),平均 n / 4步 |
| add(E element) | 最坏情况(扩容)O(n) ,平均O(1) | O(1) |
| add(int index, E element) | O(n) ,平均n / 2步 | O(n),平均 n / 4步 |
最后
针对最近很多人都在面试,我这边也整理了相当多的面试专题资料,也有其他大厂的面经。希望可以帮助到大家。
上述的面试题答案都整理成文档笔记。 也还整理了一些面试资料&最新2021收集的一些大厂的面试真题(都整理成文档,小部分截图)
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》,点击传送门,即可获取!
常常被拿来和ArrayList来进行比较。
LinkedList、ArrayList基本操作时间效率对比如下(粗略对比):
| 操作 | ArrayList | LinkedList |
| — | — | — |
| get(int index) | O(1) | O(n),平均 n / 4步 |
| add(E element) | 最坏情况(扩容)O(n) ,平均O(1) | O(1) |
| add(int index, E element) | O(n) ,平均n / 2步 | O(n),平均 n / 4步 |
最后
针对最近很多人都在面试,我这边也整理了相当多的面试专题资料,也有其他大厂的面经。希望可以帮助到大家。
[外链图片转存中…(img-SVpD6j75-1714702707791)]
上述的面试题答案都整理成文档笔记。 也还整理了一些面试资料&最新2021收集的一些大厂的面试真题(都整理成文档,小部分截图)
[外链图片转存中…(img-MrYnT0ke-1714702707792)]
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》,点击传送门,即可获取!