1. 什么是链表
链表的逻辑模型
链表是由n个子节点组合起来的一种线形数据结构
每个节点由两个部分构成：
- 节点值
- 下一个节点的地址
每个节点中包含下一个节点的地址是将n个无关系的节点组合到一起的关键部分
2. java中对应的链表模型
java是一种面向对象的编程语言，万事万物皆对象，我们可以将每一个节点用代码表述出来：
该类应该拥有值、下一个节点地址两个属性
public class Node<T> {
/**
* 节点值
*/
private T value;
/**
* 下一个节点
*/
private Node next;
public Node() {
}
public Node(T value, Node next) {
this.value = value;
this.next = next;
}
public Node(T value) {
this(value,null);
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
}
将各节点组合成链表后，最终层次关系如下图所示 ：
java链表层次关系
3. 数组与链表
数组与链表结构对比
- 与数组相比，链表丧失了随机访问的能力
与链表不同，数组在创建时，就开辟了一整块空间，划分成等分的大小，因此只要知道数组中任意节点的引用地址，就可以推算出其他任一节点的地址，因此数组具有根据下标随机访问的能力，链表这种结构是环环相扣的，我们得知某一个节点的引用地址后，只能得到下一个节点的引用地址，因此链表不具有随机访问的能力
- 与数组相比，链表的容量是动态的
数组创建时，开辟固定大小的空间后，想扩容的话，只能够重新开辟一块更大的空间，然后将原来的值，拷贝到新开辟的空间中，链表则不具有这一限制，链表的每一个节点可以在任意地址创建，只要将上一个节点的next指向该地址即可
| 数组 | 链表 | |
|---|---|---|
| 优点 | 支持随机访问，快速查询 | 动态，大小不受限制 |
| 缺点 | 大小受限制，扩容代价较大 | 不支持随机访问 |
| 适用场景 | 适用于索引具有语义的情况 | 适用于不需要随机访问的场景 |
4. java实现链表结构
下面使用我们封装的节点信息，来实现一个具有新增、查询等功能的链表结构。
基础代码：
public class LinkedList {
/**
* 头节点
*/
private Node head;
/**
* 链表当前元素个数
*/
int size;
public LinkedList() {
head = null;
size = 0;
}
/**
* 获取链表元素个数
* @return size num
*/
public int getSize() {
return size;
}
}
4.1 头部插入数据
头部插入数据
头部插入数据，只需要将新节点的next指向当前头节点，然后将头结点指向新节点
代码实现如下：
public void addFirst(T value){
Node newNode = new Node(value);
newNode.setNext(head);
head = newNode;
size++;
}
4.2 非头部插入数据
链表中间插入数据
中间插入数据，需要先找到插入位置的前一个节点prev，将新节点的next指向prev的next，然后将prev的next指向新节点
代码实现如下：
public void add(int index, T value) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("index not in rule");
}
if (index == 0) {
addFirst(value);
} else {
Node prev = head;
// 查找待插入位置的前一个节点
for (int i = 0; i < index - 1; i++) {
prev = prev.getNext();
}
// 新节点的next指向prev的next
Node newNode = new Node(value);
newNode.setNext(prev.getNext());
// prev的next指向新节点
prev.setNext(newNode);
}
}
public void addLast(T value){
add(size,value);
}
4.3 虚拟头节点
插入数据时，对头节点为空的情况进行了判断，在链表的实现过程中，常用的技巧是插入一个虚拟的头节点，这样就规避掉了每次需要判断链表是否为空的情况。
改造后的基础代码：
public class LinkedList<T> {
/**
* 头节点
*/
private Node dummyHead;
/**
* 链表当前元素个数
*/
int size;
public LinkedList() {
// 虚拟头结点
dummyHead = new Node(null,null);
size = 0;
}
/**
* 获取链表元素个数
*
* @return size num
*/
public int getSize() {
return size;
}
}
改造后的添加节点代码
/**
* 链表头部插入节点
*
* @param value
*/
public void addFirst(T value) {
add(0, value);
}
/**
* 链表中部插入节点
*
* @param value
*/
public void add(int index, T value) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("index not in rule");
}
Node prev = dummyHead;
// 查找待插入位置的前一个节点
for (int i = 0; i < index; i++) {
prev = prev.getNext();
}
// 新节点的next指向prev的next
Node newNode = new Node(value);
newNode.setNext(prev.getNext());
// prev的next指向新节点
prev.setNext(newNode);
}
/**
* 链表尾部插入节点
*
* @param value
*/
public void addLast(T value) {
add(size, value);
}
4.4 删除节点
删除节点
删除指定位置的节点，需要先找到前一个节点 prev，将prev.next执行该位置节点的next，然后将改位置节点设置为null，方便垃圾回收
代码实现如下：
/**
* 删除指定位置的节点
* @param index 索引
* @return 删除节点的数据
*/
public T remove(int index) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("index not in rule");
}
Node<T> prev = dummyHead;
// 查找待插入位置的前一个节点
for (int i = 0; i < index; i++) {
prev = prev.getNext();
}
Node<T> retNode = prev.getNext();
prev.setNext(retNode.getNext());
retNode.setNext(null);
size--;
return retNode.getValue();
}
/**
* 删除第一个节点
* @return 删除节点的数据
*/
public T removeFirst() {
return remove(0);
}
/**
* 删除最后一个节点的数据
* @return 删除节点的数据
*/
public T removeLast() {
return remove(size - 1);
}
/**
* 删除节点中所有等于某个值的节点
* @param value 值
*/
public void remove(T value) {
Node<T> current = dummyHead;
while (current.getNext() != null) {
if (current.getNext().getValue().equals(value)) {
current.setNext(current.getNext().getNext());
}else{
current = current.getNext();
}
}
}
4.5 获取链表中指定位置的值
从头结点遍历，获取到对应的节点后，取出里面的值，在使用虚拟头结点的情况下，需要对遍历一个节点。
代码实现如下：
/**
* 获取链表中指定位置的节点值
* @param index
* @return
*/
public T get(int index) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("index not in rule");
}
// dummyHead.next 等于索引为0处的第一个值
Node<T> current = dummyHead.getNext();
for (int i = 0; i < index; i++) {
current = current.getNext();
}
return current.getValue();
}
/**
* 获取链表头值
* @return
*/
public T getFirst() {
return get(0);
}
/**
* 获取链表尾值
* @return
*/
public T getLast() {
return get(size - 1);
}
4.6 修改链表中制定位置的节点值
从头结点遍历，获取到对应的节点后，更新值信息，在使用虚拟头结点的情况下，需要对遍历一个节点。
代码实现如下:
public void set(int index,T value) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("index not in rule");
}
// dummyHead.next 等于索引为0处的第一个值
Node<T> current = dummyHead.getNext();
for (int i = 0; i < index; i++) {
current = current.getNext();
}
current.setValue(value);
}
4.7 查询链表中是否有某个元素
从头结点开始遍历链表，一直到找到该元素，或者到达链表尾部
代码实现如下：
public boolean contains(T value) {
Node current = dummyHead.getNext();
while (current != null) {
if(current.getValue().equals(value)){
return true;
}
current = current.getNext();
}
return false;
}
4.8 各项操作时间复杂度分析
| 方法名 | 时间复杂度 |
|---|---|
| addLast(value) | O(n) |
| addFirst(value) | O(1) |
| add(index,value) | O(n) |
| removeLast() | O(n) |
| removeFirst() | O(1) |
| remove(index) | O(n) |
| set(index,value) | O(n) |
| contains(value) | O(n) |
附：全量代码
public class Node<T> {
/**
* 节点值
*/
private T value;
/**
* 下一个节点
*/
private Node next;
public Node() {
}
public Node(T value, Node next) {
this.value = value;
this.next = next;
}
public Node(T value) {
this(value,null);
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
}
public class LinkedList<T> {
/**
* 头节点
*/
private Node<T> dummyHead;
/**
* 链表当前元素个数
*/
int size;
public LinkedList() {
// 虚拟头结点
dummyHead = new Node(null, null);
size = 0;
}
/**
* 获取链表元素个数
*
* @return size num
*/
public int getSize() {
return size;
}
/**
* 链表头部插入节点
*
* @param value
*/
public void addFirst(T value) {
add(0, value);
}
/**
* 链表中部插入节点
*
* @param value
*/
public void add(int index, T value) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("index not in rule");
}
Node<T> prev = dummyHead;
// 查找待插入位置的前一个节点
for (int i = 0; i < index; i++) {
prev = prev.getNext();
}
// 新节点的next指向prev的next
Node<T> newNode = new Node(value);
newNode.setNext(prev.getNext());
// prev的next指向新节点
prev.setNext(newNode);
}
/**
* 链表尾部插入节点
*
* @param value
*/
public void addLast(T value) {
add(size, value);
}
/**
* 获取链表中指定位置的节点值
*
* @param index
* @return
*/
public T get(int index) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("index not in rule");
}
// dummyHead.next 等于索引为0处的第一个值
Node<T> current = dummyHead.getNext();
for (int i = 0; i < index; i++) {
current = current.getNext();
}
return current.getValue();
}
/**
* 获取链表头值
*
* @return
*/
public T getFirst() {
return get(0);
}
/**
* 获取链表尾值
*
* @return 删除节点的数据
*/
public T getLast() {
return get(size - 1);
}
/**
* 删除指定位置的节点
* @param index 索引
* @return 删除节点的数据
*/
public T remove(int index) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("index not in rule");
}
Node<T> prev = dummyHead;
// 查找待插入位置的前一个节点
for (int i = 0; i < index; i++) {
prev = prev.getNext();
}
Node<T> retNode = prev.getNext();
prev.setNext(retNode.getNext());
retNode.setNext(null);
size--;
return retNode.getValue();
}
/**
* 删除第一个节点
* @return 删除节点的数据
*/
public T removeFirst() {
return remove(0);
}
/**
* 删除最后一个节点的数据
* @return 删除节点的数据
*/
public T removeLast() {
return remove(size - 1);
}
/**
* 设置指定位置的节点的值
* @param index 索引
* @param value 值
*/
public void set(int index, T value) {
if (index < 0 || index > size) {
throw new IllegalArgumentException("index not in rule");
}
// dummyHead.next 等于索引为0处的第一个值
Node<T> current = dummyHead.getNext();
for (int i = 0; i < index; i++) {
current = current.getNext();
}
current.setValue(value);
}
/**
* 判断是否包含某个值
* @param value 值
* @return true 包含，false 不包含
*/
public boolean contains(T value) {
Node<T> current = dummyHead.getNext();
while (current != null) {
if (current.getValue().equals(value)) {
return true;
}
current = current.getNext();
}
return false;
}
}
