《恋上数据结构第1季》单向链表、双向链表
链表（Linked List）
- 链表的接口设计
- 单向链表（SingleLinkedList）
- 获取元素 – get()
- 清空元素 – clear()
- 添加元素 – add(int index, E element)
- 删除元素 – remove(int index)
- 单向链表完整源码
- 带虚拟头结点的单向链表
- 动态数组、链表复杂度分析
- 双向链表（LinkedList）
- 双向链表 – get(int index)
- 双向链表 – add(int index, E element)
- 双向链表 – remove(int index)
- 双向链表完整源码
- 双向链表 vs 单向链表
- 双向链表 vs 动态数组
- 练习题
- 练习 – 删除链表中的节点
- 练习 – 反转一个链表（递归、非递归解法）
- 练习 – 判断一个链表是否有环（快慢指针）
数据结构与算法笔记目录：《恋上数据结构》 笔记目录
想加深 Java 基础推荐看这个： Java 强化笔记目录
动态数组有个明显的缺点：
- 可能会造成内存空间的大量浪费。
能否用到多少就申请多少内存？
- 链表可以办到这一点
链表是一种链式存储的线性表，所有元素的内存地址不一定是连续的;
链表的接口设计
由于链表的大部分接口和动态数组一致，我们抽取出一个共同的 List 接口；
package com.mj;
public interface List<E> {
static final int ELEMENT_NOT_FOUND = -1;
/**
* 清除所有元素
*/
void clear();
/**
* 元素的数量
* @return
*/
int size();
/**
* 是否为空
* @return
*/
boolean isEmpty();
/**
* 是否包含某个元素
* @param element
* @return
*/
boolean contains(E element);
/**
* 添加元素到尾部
* @param element
*/
void add(E element);
/**
* 获取index位置的元素
* @param index
* @return
*/
E get(int index);
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素ֵ
*/
E set(int index, E element);
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
void add(int index, E element);
/**
* 删除index位置的元素
* @param index
* @return
*/
E remove(int index);
/**
* 查看元素的索引
* @param element
* @return
*/
int indexOf(E element);
}
再将一些通用的字段与方法放到一个抽象类中，无论是动态数组还是链表都只需要继承这个抽象类即可。
package com.mj;
public abstract class AbstractList<E> implements List<E>{
protected int size;
// 下标越界抛出的异常
protected void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
// 检查下标越界(不可访问或删除size位置)
protected void rangeCheck(int index){
if(index < 0 || index >= size){
outOfBounds(index);
}
}
// 检查add()的下标越界(可以在size位置添加元素)
protected void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
@Override
public boolean contains(E element) {
return indexOf(element)!=ELEMENT_NOT_FOUND;
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public void add(E element) {
add(size, element);
}
}
单向链表（SingleLinkedList）
单向链表的结构如下图所示：
public class SingleLinkedList<E> extends AbstractList<E> {
private Node<E> first;
// 链表中的节点
private static class Node<E> {
E element; // 节点元素
Node<E> next; // 节点指向下一个节点
public Node(E element, Node<E> next) {
this.element = element;
this.next = next;
}
}
}
获取元素 – get()
@Override
public E get(int index) {
return node(index).element;
}
/**
* 根据索引找到节点
*/
private Node<E> node(int index) {
rangeCheck(index);
Node<E> node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
}
清空元素 – clear()
next不需要设置为null，因为first指向了null，后面的Node没有被指向，在 Java 中会自动被垃圾回收。
@Override
public void clear() {
size = 0;
first = null;
}
添加元素 – add(int index, E element)
添加元素尤其要注意 0 位置，给空链表添加第一个节点是个特殊情况：
@Override
public void add(int index, E element) {
/*
* 最好：O(1)
* 最坏：O(n)
* 平均：O(n)
*/
rangeCheckForAdd(index);
if(index == 0){ // 给空链表添加第一个元素的情况
first = new Node<>(element, first);
}else{
Node<E> prev = node(index - 1);
prev.next = new Node<>(element, prev.next);
}
size++;
}
删除元素 – remove(int index)
@Override
public E remove(int index) {
/*
* 最好：O(1)
* 最坏：O(n)
* 平均：O(n)
*/
rangeCheck(index);
Node<E> node = first;
if (index == 0) { // 删除第一个元素是特殊情况
first = first.next;
} else {
Node<E> prev = node(index - 1); // 找到前一个元素
node = prev.next; // 要删除的元素
prev.next = node.next; // 删除元素
}
size--;
return node.element;
}
单向链表完整源码
package com.mj.single;
import com.mj.AbstractList;
/**
* 单向链表
* @author yusael
*/
public class SingleLinkedList<E> extends AbstractList<E> {
private Node<E> first;
// 链表中的节点
private static class Node<E> {
E element; // 节点元素
Node<E> next; // 节点指向下一个节点
public Node(E element, Node<E> next) {
this.element = element;
this.next = next;
}
}
/**
* 根据索引找到节点对象
*/
private Node<E> node(int index) {
rangeCheck(index);
Node<E> node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
}
@Override
public void clear() {
size = 0;
first = null;
}
@Override
public E get(int index) {
/*
* 最好:O(1)
* 最坏:O(n)
* 平均:O(n)
*/
return node(index).element;
}
@Override
public E set(int index, E element) {
/*
* 最好:O(1)
* 最坏:O(n)
* 平均:O(n)
*/
E old = node(index).element;
node(index).element = element;
return old;
}
@Override
public void add(int index, E element) {
/*
* 最好：O(1)
* 最坏：O(n)
* 平均：O(n)
*/
rangeCheckForAdd(index);
if (index == 0) { // 给空链表添加第一个元素的情况
first = new Node<>(element, first);
} else {
Node<E> prev = node(index - 1);
prev.next = new Node<>(element, prev.next);
}
size++;
}
@Override
public E remove(int index) {
/*
* 最好：O(1)
* 最坏：O(n)
* 平均：O(n)
*/
rangeCheck(index);
Node<E> node = first;
if (index == 0) { // 删除第一个元素是特殊情况
first = first.next;
} else {
Node<E> prev = node(index - 1); // 找到前一个元素
node = prev.next; // 要删除的元素
prev.next = node.next; // 删除元素
}
size--;
return node.element;
}
@Override
public int indexOf(E element) {
// 有个注意点, 如果传入元素为null, 则不能调用equals方法, 否则会空指针
// 因此需要对元素是否为null做分别处理
if (element == null) {
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (node.element == null) return i;
node = node.next;
}
} else {
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (node.element.equals(element)) return i;
node = node.next;
}
}
return ELEMENT_NOT_FOUND;
}
@Override
public String toString() {
StringBuilder string = new StringBuilder();
string.append("[size=").append(size).append(", ");
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (i != 0) {
string.append(", ");
}
string.append(node.element);
node = node.next;
}
string.append("]");
return string.toString();
}
}
带虚拟头结点的单向链表
有时候为了让代码更加精简，统一所有节点的处理逻辑，可以在最前面增加一个虚拟的头结点（不存储数据）。
带虚拟头结点的单向链表与普通单向链表代码类似：但是 add、reomove 略有不同；
package com.mj.single;
import com.mj.AbstractList;
/**
* 增加一个虚拟头结点
* @author yusael
*/
public class SingleLinkedList2<E> extends AbstractList<E> {
private Node<E> first;
//**********************************
public SingleLinkedList2() { // 初始化一个虚拟头结点
first = new Node<>(null, null);
};
//**********************************
private static class Node<E> {
E element;
Node<E> next;
public Node(E element, Node<E> next) {
this.element = element;
this.next = next;
}
}
@Override
public void clear() {
size = 0;
first = null;
}
@Override
public E get(int index) {
return node(index).element;
}
@Override
public E set(int index, E element) {
E old = node(index).element;
node(index).element = element;
return old;
}
@Override
public void add(int index, E element) {
rangeCheckForAdd(index);
Node<E> prev = (index == 0) ? first : node(index - 1);
prev.next = new Node<>(element, prev.next);
size++;
}
@Override
public E remove(int index) {
rangeCheck(index);
Node<E> prev = (index == 0) ? first : node(index - 1);
Node<E> node = prev.next;
prev.next = node.next;
size--;
return prev.element;
}
@Override
public int indexOf(E element) {
// 有个注意点, 如果传入元素为null, 则不能调用equals方法, 否则会空指针
// 因此需要对元素是否为null做分别处理
if (element == null) {
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (node.element == null) return i;
node = node.next;
}
} else {
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (node.element.equals(element)) return i;
node = node.next;
}
}
return ELEMENT_NOT_FOUND;
}
/**
* 根据索引找到节点
*
* @param index
* @return
*/
private Node<E> node(int index) {
rangeCheck(index);
Node<E> node = first.next;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
}
@Override
public String toString() {
StringBuilder string = new StringBuilder();
string.append("[size=").append(size).append(", ");
Node<E> node = first.next;
for (int i = 0; i < size; i++) {
if (i != 0) {
string.append(", ");
}
string.append(node.element);
node = node.next;
}
string.append("]");
return string.toString();
}
}
动态数组、链表复杂度分析
数组的随机访问速度非常快：elements[n] 的效率与 n 是多少无关；
双向链表（LinkedList）
双向链表可以提升链表的综合性能；
双向链表只有一个元素的情况：first、last 指向同一个节点
/**
* 双向链表
* @author yusael
*/
public class LinkedList<E> extends AbstractList<E> {
private Node<E> first;
private Node<E> last;
private static class Node<E> {
E element;
Node<E> prev;
Node<E> next;
public Node(Node<E> prev, E element, Node<E> next) {
this.prev = prev;
this.element = element;
this.next = next;
}
@Override
public String toString(){
StringBuilder sb = new StringBuilder();
if(prev != null){
sb.append(prev.element);
}else{
sb.append("null");
}
sb.append("_").append(element).append("_");
if(next != null){
sb.append(next.element);
}else{
sb.append("null");
}
return sb.toString();
}
}
}
双向链表 – get(int index)
@Override
public E get(int index) {
return node(index).element;
}
/**
* 根据索引找到节点
*/
private Node<E> node(int index) {
rangeCheck(index);
if (index < (size >> 1)) { // 索引小于一半从前往后找
Node<E> node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
} else { // 索引大于一半从后往前找
Node<E> node = last;
for (int i = size - 1; i > index; i--) {
node = node.prev;
}
return node;
}
}
双向链表 – add(int index, E element)
@Override
public void add(int index, E element) {
rangeCheckForAdd(index);
// size == 0
// index == 0
if (index == size) { // 往最后面添加元素
Node<E> oldLast = last;
last = new Node<>(oldLast, element, null);
if (oldLast == null) { // 这是链表添加的第一个元素
first = last;
} else {
oldLast.next = last;
}
} else { // 正常添加元素
Node<E> next = node(index);
Node<E> prev = next.prev;
Node<E> node = new Node<>(prev, element, next);
next.prev = node;
if (prev == null) { // index == 0
first = node;
} else {
prev.next = node;
}
}
size++;
}
双向链表 – remove(int index)
@Override
public E remove(int index) {
rangeCheck(index);
Node<E> node = node(index);
Node<E> prev = node.prev;
Node<E> next = node.next;
if (prev == null) { // index == 0
first = next;
} else {
prev.next = next;
}
if (next == null) { // index == size - 1
last = prev;
} else {
next.prev = prev;
}
size--;
return node.element;
}
双向链表完整源码
package com.mj;
import com.mj.AbstractList;
/**
* 双向链表
* @author yusael
*/
public class LinkedList<E> extends AbstractList<E> {
private Node<E> first;
private Node<E> last;
private static class Node<E> {
E element;
Node<E> prev; // 指向前驱节点
Node<E> next; // 指向后继节点
public Node(Node<E> prev, E element, Node<E> next) {
this.prev = prev;
this.element = element;
this.next = next;
}
@Override
public String toString(){
StringBuilder sb = new StringBuilder();
if(prev != null){
sb.append(prev.element);
}else{
sb.append("null");
}
sb.append("_").append(element).append("_");
if(next != null){
sb.append(next.element);
}else{
sb.append("null");
}
return sb.toString();
}
}
@Override
public void clear() {
size = 0;
first = null;
last = null;
}
@Override
public E get(int index) {
return node(index).element;
}
@Override
public E set(int index, E element) {
Node<E> node = node(index);
E old = node.element;
node.element = element;
return old;
}
@Override
public void add(int index, E element) {
rangeCheckForAdd(index);
// size == 0
// index == 0
if (index == size) { // 往最后面添加元素
Node<E> oldLast = last;
last = new Node<>(oldLast, element, null);
if (oldLast == null) { // 这是链表添加的第一个元素
first = last;
} else {
oldLast.next = last;
}
} else { // 正常添加元素
Node<E> next = node(index);
Node<E> prev = next.prev;
Node<E> node = new Node<>(prev, element, next);
next.prev = node;
if (prev == null) { // index == 0
first = node;
} else {
prev.next = node;
}
}
size++;
}
@Override
public E remove(int index) {
rangeCheck(index);
Node<E> node = node(index);
Node<E> prev = node.prev;
Node<E> next = node.next;
if (prev == null) { // index == 0
first = next;
} else {
prev.next = next;
}
if (next == null) { // index == size - 1
last = prev;
} else {
next.prev = prev;
}
size--;
return node.element;
}
@Override
public int indexOf(E element) {
if (element == null) {
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (node.element == element) return i;
node = node.next;
}
} else {
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (node.element.equals(element)) return i;
node = node.next;
}
}
return ELEMENT_NOT_FOUND;
}
/**
* 根据索引找到节点
*
* @param index
* @return
*/
private Node<E> node(int index) {
rangeCheck(index);
if (index < (size >> 1)) { // 索引小于一半从前往后找
Node<E> node = first;
for (int i = 0; i < index; i++) {
node = node.next;
}
return node;
} else { // 索引大于一半从后往前找
Node<E> node = last;
for (int i = size - 1; i > index; i--) {
node = node.prev;
}
return node;
}
}
@Override
public String toString() {
StringBuilder string = new StringBuilder();
string.append("[size=").append(size).append(", ");
Node<E> node = first;
for (int i = 0; i < size; i++) {
if (i != 0) {
string.append(", ");
}
string.append(node);
node = node.next;
}
string.append("]");
return string.toString();
}
}
双向链表 vs 单向链表
粗略对比一下删除的操作数量：操作数量缩减了近一半
有了双向链表，单向链表是否就没有任何用处了？
- 并非如此，在哈希表的设计中就用到了单链表
- 至于原因，在哈希表章节中会讲到
双向链表 vs 动态数组
动态数组：开辟、销毁内存空间的次数相对较少，但可能造成内存空间浪费（可以通过缩容解决）
双向链表：开辟、销毁内存空间的次数相对较多，但不会造成内存空间的浪费
- 如果频繁在尾部进行添加、删除操作，动态数组、双向链表均可选择
- 如果频繁在头部进行添加、删除操作，建议选择使用双向链表
- 如果有频繁的 （在任意位置）添加、删除操作，建议选择使用双向链表
- 如果有频繁的查询操作（随机访问操作），建议选择使用动态数组
练习题
练习 – 删除链表中的节点
237_删除链表中的节点：https://leetcode-cn.com/problems/delete-node-in-a-linked-list/
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public void deleteNode(ListNode node) {
node.val = node.next.val;
node.next = node.next.next;
}
}
练习 – 反转一个链表（递归、非递归解法）
206_反转链表：https://leetcode-cn.com/problems/reverse-linked-list/
递归解法：
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode reverseList(ListNode head) {
if(head == null) return null; // 空链表
if(head.next == null) return head; // 只有一个节点
ListNode newHead = reverseList(head.next);
head.next.next = head; // newHead->1->2->3->4->5->null
head.next = null;
return newHead;
}
}
非递归解法 - 头插法：
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode reverseList(ListNode head) {
ListNode newHead = null;
while (head != null) {
ListNode tmp = head.next;
head.next = newHead;
newHead = head;
head = tmp;
}
return newHead;
}
}
练习 – 判断一个链表是否有环（快慢指针）
141_环形链表：https://leetcode-cn.com/problems/linked-list-cycle/
快慢指针解法：
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public boolean hasCycle(ListNode head) {
if(head == null || head.next == null) return false;
ListNode slow = head;
ListNode fast = head.next; // 快指针每次都比慢指针快一步(包括开始)
while (fast != null && fast.next != null) {
if (slow.val == fast.val) return true;
slow = slow.next;
fast = fast.next.next;
}
return false;
}
}