写在前面
链表是一种常用的线性数据结构，在jdk中也提供具体的实现类java.util.LinkedList。本文来看下其相关内容。
1：链表的特点
链表是一种由很多个节点组成的线性数据结构，每个节点都有一个指向下一个节点的引用，从而构成链,像下图：
这种链表叫做单向链表,如果是节点在此基础上增加一个指向上一个节点的引用，则就变成了双向链表，如下图：
如果是在单链表的基础上尾节点增加一个指向头节点的引用，则就构成了循环链表，如下图：
因此最基础的链表是单向链表，双向链表和循环链表都可以在其基础上通过增加相关的节点引用而成。
2：实现双向链表
因为jdk提供的链表实现就是双向链表，为了在学习链表的同时能够更加熟悉jdk提供的类，所以我们照葫芦画瓢也来自己实现一个双向链表的例子，首先来定义接口：
java
package com.dahuyou.datastructure.linkedlist;
public interface List<E> {
/**
* Appends the specified element to the end of this list (optional
* operation).
* <p>
* 追加元素到尾部！
*/
boolean add(E e);
/**
* Removes the first occurrence of the specified element from this list,
* if it is present (optional operation). If this list does not contain
* the element, it is unchanged. More formally, removes the element with
* the lowest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>
* (if such an element exists). Returns <tt>true</tt> if this list
* contained the specified element (or equivalently, if this list changed
* as a result of the call).
*
* 删除指定的元素，会删除第一个匹配的元素，如果是成功找到并删除则返回true，否则返回false
*/
boolean remove(Object o);
/**
* Returns the element at the specified position in this list.
*
* 返回指定位置的元素
*/
E get(int index);
// --- 其他非java.util.List接口中提供的方法，自己个想的 --- //
boolean addFirst(E e);
boolean addLast(E e);
void printLinkedList();
}支持双向链表的节点类（直接复制的java.util.LinkedList的Node类）：
java
/**
* 链表节点的内部静态类
* @param <E>
*/
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;
}
}实现类：
java
package com.dahuyou.datastructure.linkedlist;
/**
* 链表类
* @param <E>
*/
public class LinkedList<E> implements List<E> {
// transient:我没用，别序列化我！！！
transient int size = 0;
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
@Override
public boolean add(E s) {
return false;
}
@Override
public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
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;
}
private E unlink(Node<E> x) {
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
return element;
}
@Override
public E get(int index) {
return null;
}
@Override
public boolean addFirst(E s) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, s, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
return true;
}
@Override
public boolean addLast(E s) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, s, null);
last = newNode;
if (l == null) {
first = newNode;
} else {
l.next = newNode;
}
size++;
return true;
}
@Override
public void printLinkedList() {
if (this.size == 0) {
System.out.println("链表为空");
} else {
Node<E> temp = first;
System.out.print("目前的列表，头节点：" + first.item + " 尾节点：" + last.item + " 整体：");
while (temp != null) {
System.out.print(temp.item + "，");
temp = temp.next;
}
System.out.println();
}
}
/**
* 链表节点的内部静态类
* @param <E>
*/
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;
}
}
}测试：
java
package com.dahuyou.datastructure.linkedlist;
public class TT {
public static void main(String[] args) {
List<String> list = new LinkedList<>();
// 添加元素
list.add("a");
list.addFirst("b");
list.addLast("c");
// 打印列表
list.printLinkedList();
// 头插元素
list.addFirst("d");
// 删除元素
list.remove("b");
// 打印列表
list.printLinkedList();
}
}运行：
目前的列表，头节点：b 尾节点：c 整体：b，c，
目前的列表，头节点：d 尾节点：c 整体：d，c，
Process finished with exit code 0
3：使用场景
-
频繁插入和删除（时间问题）
相比数组更优的时间复杂度，只需要断开和🔗相关节点即可。
-
元素大小不一样(空间浪费问题)
相比数组要求所有元素占用空间相同，链表并无此限制，因此可更好的避免空间浪费。
-
元素个数不确定（扩容问题）
个数不确定，数组无法实现申请特定的空间，后续如果涉及到扩容，则需要重新申请内存空间。
-
实现高阶数据结构
因为链表更加灵活，所以更适合用来实现高阶的数据结构，如栈，队列，跳表(https://dongyunqi.blog.csdn.net/article/details/127107229)等。