在JavaScript中没有链表这种数据结构，但是我们可以用对象(Object)模拟链表，下面让我们先了解链表是什么。
链表（Linked List）是一种基础的数据结构，由一系列节点（Node）组成，每一个节点由两部分组成，分别是数据域和指针域(存放指向下一个节点的指针)，最后一个节点的指针域指向null(即空指针的意思)。链表在插入和删除操作中具有较高的效率，广泛应用于实际开发中。
一、基本概念
链表是一种线性数据结构，它的每个元素都是一个节点。每个节点包含两部分：
- 数据域（Data）：存储元素的值。
- 指针域（Next）：存储指向下一个节点的引用。
二、链表的类型
1、单向链表（Singly Linked List）
- 描述：每个节点只包含指向下一个节点的指针。
2、双向链表（Doubly Linked List）
- 描述：每个节点包含指向前一个节点和下一个节点的指针。
3、循环链表（Circular Linked List）
- 描述：单向或双向链表的最后一个节点指向头节点，形成一个环。
单向循环链表
双向循环链表
二、模拟实现
1. 单向链表
下面是一个简单的单向链表的实现，包括定义节点，添加节点、删除节点、遍历链表等基本方法：
// 定义节点类
class ListNode {
constructor(value) {
this.value = value; // 节点的值
this.next = null; // 指向下一个节点的指针，初始为 null
}
}
// 定义单向链表类
class LinkedList {
constructor() {
this.head = null; // 链表头节点，初始为 null
}
// 在链表末尾添加节点
append(value) {
// 创建一个新的节点
const newNode = new ListNode(value);
// 如果链表为空，新的节点作为头节点
if (this.head === null) {
this.head = newNode;
} else {
let current = this.head;
// 遍历链表找到最后一个节点
while (current.next !== null) {
current = current.next;
}
// 将新的节点添加到最后一个节点的 next
current.next = newNode;
}
}
// 在链表头部添加节点
prepend(value) {
const newNode = new ListNode(value);
newNode.next = this.head;
this.head = newNode;
}
// 删除指定值的节点
remove(value) {
// 链表为空
if (!this.head) {
return null;
}
//如果要删除的节点是头节点
if (this.head.value === value) {
this.head = this.head.next;
return;
}
let current = this.head;
while (current.next && current.next.value !== value) {
current = current.next;
}
// 如果找到了要删除的节点
if (current.next) {
current.next = current.next.next;
}
}
// 遍历链表节点
traverse() {
let current = this.head;
while (current !== null) {
console.log(current.value);
current = current.next;
}
}
}
const list = new LinkedList();
list.append(1);
list.append(2);
list.append(3);
list.prepend(0);
list.traverse(); // 输出 0 1 2 3
2. 双向链表
下面是一个简单的双向链表的实现，包括定义节点，添加节点、删除节点、遍历链表等基本方法：
// 定义双向节点类
class DoublyListNode {
constructor(value) {
this.value = value; // 节点的值
this.next = null; // 指向下一个节点的指针，初始为 null
this.prev = null; // 指向前一个节点的指针，初始为 null
}
}
// 定义双向链表类
class DoublyLinkedList {
constructor() {
this.head = null; // 链表头节点，初始为 null
this.tail = null; // 链表尾节点，初始为 null
}
// 在链表末尾添加节点
append(value) {
// 创建一个新的节点
const newNode = new DoublyListNode(value);
// 如果链表为空，新的节点作为头和尾节点
if (this.tail === null) {
this.head = newNode;
this.tail = newNode;
} else {
// 将新的节点添加到尾节点的 next
this.tail.next = newNode;
// 新节点的 prev 指向当前的尾节点
newNode.prev = this.tail;
// 新节点作为新的尾节点
this.tail = newNode;
}
}
// 在链表头部添加节点
prepend(value) {
const newNode = new DoublyListNode(value);
if (this.head === null) {
this.head = newNode;
this.tail = newNode;
} else {
// 头节点的 prev 指向新的节点
this.head.prev = newNode;
// 新节点的 next 指向当前的头节点
newNode.next = this.head;
// 新节点作为新的头节点
this.head = newNode;
}
}
// 删除指定值的节点
remove(value) {
if (this.head === null) return; // 如果链表为空，直接返回
// 如果头节点就是要删除的节点
if (this.head.value === value) {
this.head = this.head.next;
if (this.head !== null) {
this.head.prev = null;
} else {
this.tail = null; // 如果链表为空，更新尾节点
}
return;
}
let current = this.head;
while (current !== null) {
if (current.value === value) { // 找到要删除的节点
if (current.next !== null) {
current.next.prev = current.prev;
} else {
this.tail = current.prev; // 更新尾节点
}
current.prev.next = current.next;
return;
}
current = current.next;
}
}
// 遍历链表节点
traverse() {
let current = this.head;
while (current !== null) {
console.log(current.value);
current = current.next;
}
}
}
// 示例：使用双向链表
const dList = new DoublyLinkedList();
dList.append(1);
dList.append(2);
dList.append(3);
dList.prepend(0);
dList.traverse(); // 输出 0 1 2 3
三、链表的进阶操作
1. 反转链表
思路：通过三个指针（prev、current和next）来遍历链表，逐个节点地改变其指向，最终实现链表的反转。具体来说，先将prev初始化为null，current指向头节点，然后在循环中不断更新这三个指针的值，直到current为null。
function reverseLinkedList(list) {
let prev = null;
let current = list.head;
while (current !== null) {
// 暂存下一个节点
let next = current.next;
// 将当前节点的 next 指向前一个节点
current.next = prev;
// 更新前一个节点为当前节点
prev = current;
// 继续遍历下一个节点
current = next;
}
// 更新头节点为最后一个非空节点
list.head = prev;
return list;
}
2. 合并两个有序链表
思路：创建一个新的虚拟头节点，然后使用两个指针分别遍历两个有序链表，比较当前节点的值，将较小的节点连接到新链表的末尾，并移动相应的指针。重复此过程，直到其中一个链表为空，然后将另一个非空链表的剩余部分连接到新链表的末尾。
function mergeTwoLists(l1, l2) {
// 创建一个哨兵节点
let dummy = new ListNode(0);
let current = dummy;
let p1 = l1.head;
let p2 = l2.head;
// 遍历两个链表
while (p1 !== null && p2 !== null) {
if (p1.value < p2.value) {
// 将较小值的节点添加到结果链表中
current.next = p1;
p1 = p1.next;
} else {
current.next = p2;
p2 = p2.next;
}
current = current.next;
}
// 将剩余的节点连接到结果链表中
if (p1 !== null) {
current.next = p1;
}
if (p2 !== null) {
current.next = p2;
}
let mergedList = new LinkedList();
// 哨兵节点的 next 为合并后的头节点
mergedList.head = dummy.next;
return mergedList;
}
3. 查找中间节点
思路：使用两个指针的方法，一个指针每次移动一步，另一个指针每次移动两步。当快指针到达链表末尾时，慢指针刚好在中间节点。
function findMiddle(list){
let slow = list.head;
let fast = list.head;
while (fast !== null && fast.next !== null) {
slow = slow.next;
fast = fast.next.next;
}
return slow;
}
四、总结
链表作为一种基础且重要的线性数据结构，在数据处理领域发挥着独特作用，尤其在应对频繁的插入与删除操作时展现出显著优势。深入了解并熟练掌握链表的基本操作以及更为复杂的进阶操作，能够为解决各类实际问题提供有力的支持。
