链表与双向链表实现及操作详解
链表和数组一样，可以用于存储一系列的元素，但是列表和数组的实现机制完全不同。
在学习链表之前我们先了解一下数组的不足（缺点）：
- 要存储多个元素，数组可能是最常用的数据结构。几乎每一种编程语言都有默认实现的数组结构，数组的创建通常需要申请一段连续的内存空间，并且大小是固定的（大多数语言是固定的），所以当数组不能满足容量需求时，需要扩容，一般情况下是申请一个更大的数组，将原来数组中元素复制过去。而且数组开头或中间位置插入数据的成本很高，需要进行大量元素的位移。尽管JavaScript中的Array类可以帮助我们做这些事，但背后的原理依然事这样的。
相对于数组链表的优势：
-
链表的内存空间不是必须连续的，可以充分利用计算机的内存，实习灵活的内存动态管理，链表不必在创建的时候确定大小，并且大小可以无限制的延申下去，链表在插入和删除数据时，时间复杂度可达到O（1），相对于数组效率会高很多。
-
但是相对于数组，列表也有一些缺点：链表访问任何一个位置的元素时，都需要从头开始访问，无法跳过第一个元素访问任何一个元素，无法通过下标直接访问元素，需要从头一个个访问，直到找到对应的元素。
什么是链表
在上面已经简单提及链表的结构，我们用图的方式在清晰的了解一下什么是链表结构。
如上图所示，在链表中，每一个元素都包含两个属性，即 该元素的值item 和 下一个元素next，next指向下一个节点。同时链表中有一个指针 head 指向链表第一个元素，最后一个元素则指向null。
链表中的常见操作
- 向链表尾部添加一个新的项。append(element)
- 向链表的特定位置插入一个新的项。insert(position,element)
- 获取对应位置的元素。get(position)
- 返回元素在链表中的索引。如果链表中没有该元素则返回-1。indexOf(element)
- 修改某个位置的元素。update(position ,element)
- 从列表的特定位置移除一项。removeAt(position)
- 从链表中移除一项。remove(element)
- 如果链表中不包含任何元素，返回true，如果链表的长度大于0则返回false。isEmpty()
- 返回链表包含的元素个数。与数组length属性类似。size()
封装单向链表结构
class Node {
constructor(element) {
// 保存元素
this.element = element;
// 指向下一个元素
this.next = null;
}
}
class LinkedList {
constructor() {
this.head = null;
this.length = 0;
}
// - 向链表尾部添加一个新的项。append(element)
append(element) {
// 根据element创建Node对象
const newNode = new Node(element);
// 追加到最后 判断链表结构head是否为空（为空就表示链表中没有任何节点），将新创建的节点赋值给head，此时表示该链表中已有节点
if (!this.head) {
this.head = newNode;
}
// 如果head不为空（表示链表中已有节点），最开始定义一个变量将头节点（head）赋值给current（也就是指向第一个节点），
//利用while循环依次判断是否存在下一个节点,如果不存在，就将这个新创建的额节点赋值给最后一个节点的next属性
else {
let current = this.head;
while (current.next) {
current = current.next;
}
current.next = newNode;
}
this.length++;
}
// - 向链表的特定位置插入一个新的项。insert(position,element) position表示插入元素的位置
insert(position, element) {
// 判断输入的值是否越界
if (position < 0 || position > this.length) return false;
// 创建新的节点
const newNode = new Node(element);
// 插入元素
// 判断插入的元素的位置是否在头节点（head）
if (position === 0) {
// 插入的节点在第一个就将此时指向头节点的节点赋值给插入节点的next属性
newNode.next = this.head;
//之后再将新插入的节点赋值给头节点
this.head = newNode;
}
// 在其他位置插入节点 ，需要将插入位置的新节点前一个节点指向该新节点，再将新节点的next属性指向后一个节点
else {
let index = 0;
let current = this.head;
// 插入节点的前一个位置
let previous = null;
while (index++ < position) {
previous = current;
current = current.next;
}
previous.next = newNode;
newNode.next = current;
}
this.length++;
// 表示插入成功
return true;
}
// - 获取对应位置的元素。get(position)
get(position) {
if (position < 0 || position > this.length - 1) return null;
// 查找指定位置的元素时，需要一个一个的往后找，直到找到指定位置将此位置的节点next属性赋值给变量current
let index = 0;
let current = this.head;
while (index++ < position) {
current = current.next;
}
return current.element;
}
// - 返回元素在链表中的索引。如果链表中没有该元素则返回-1。indexOf(element)
indexOf(element) {
let current = this.head;
let index = 0;
while (current) {
if (current.element === element) {
return index;
}
index++;
current = current.next;
}
return -1;
}
// - 修改某个位置的元素。update(position ,element)
update(position, element) {
let result = this.removeAt(position);
this.insert(position, element);
return result;
}
// - 从列表的特定位置移除一项。removeAt(position)
removeAt(position) {
if (position < 0 || position > this.length - 1) return null;
let current = this.head;
let previous = null;
let index = 0;
if (position === 0) {
this.head = current.next;
} else {
while (index++ < position) {
previous = current;
current = current.next;
}
previous.next = current.next;
}
this.length--;
return current.element;
}
// - 从链表中移除一项。remove(element)
remove(element) {
const index = this.indexOf(element);
if (index === -1) return;
this.removeAt(index);
}
// - 如果链表中不包含任何元素，返回true，如果链表的长度大于0则返回false。isEmpty()
isEmpty() {
return this.length === 0;
}
// - 返回链表包含的元素个数。与数组length属性类似。size()
size() {
return this.length;
}
}
module.exports = new LinkedList();
测试
const linkedList = require("./linkdeList");
// 测试向链表添加节点
linkedList.append("a");
linkedList.append("b");
linkedList.append("c");
linkedList.append("d");
linkedList.append("e");
console.log(linkedList);
// 测试向指定位置插入节点
const res = linkedList.insert("1", "f");
console.log(linkedList, res);
// 测试获取指定位置的元素
console.log(linkedList.get(1));
// 测试通过元素获取下标值{}
console.log(linkedList.indexOf("b"));
// 测试从列表的特定位置移除一项
console.log(linkedList.removeAt(4));
console.log(linkedList);
// 测试修改某个位置的元素
console.log(linkedList.update(1, "www"));
console.log(linkedList);
// 测试从链表中移除一项
console.log(linkedList.remove("a"));
console.log(linkedList);
认识双向列表
- 为什么要使用双向链表
单向链表只能从头遍历到尾或者从尾遍历到头，也就是链表相连过程是 单向的，实现的原理是上一个节点中有一个指向下一个的引用。
单向链表有一个明显的缺点，我们可以轻松的拿到下一个节点，但是返回前一个节点是很难的（需要从头在开始遍历），但是在实际开发中，经常会遇到回到上一个节点的情况。所以双向链表可以解决单向链表很难拿到上一个节点的情况。
- 双向链表实现的原理
双向链表基于单向链表实现，其实就是在每个节点中添加一个指向上一个节点的引用（prev），第一个节点的prev指向的是null，最后一个节点的next指向的也是null（如下图），这样双向链表就可以有效的解决上面提出的问题。
但是双向链表也有一些缺点，每次在插入或者删除某个节点时，需要处理四个引用，而不是两个，实现起来也比较麻烦。并且相当于单向链表，必然占用的内存空间更大一些。
封装双向链表
根据双向链表的要求，我们只需要继承单向链表来重写添加，插入，根据下标删除三个方法
const { LinkedList, Node } = require("./linkdeList");
class DoublyNode extends Node {
constructor(element) {
super(element);
this.prev = null;
}
}
class DoublyLinkedList extends LinkedList {
constructor() {
super();
this.tail = null;
}
// - 向链表尾部添加一个新的项。append(element)
append(element) {
const newNode = new DoublyNode(element);
if (this.head === null) {
this.head = newNode;
this.tail = newNode;
} else {
this.tail.next = newNode;
newNode.prev = this.tail;
this.tail = newNode;
}
this.length++;
}
// - 向链表的特定位置插入一个新的项。insert(position,element)
insert(position, element) {
if (position < 0 || position > this.length) return false;
const newNode = new DoublyNode(element);
if (position === 0) {
if (this.head == null) {
this.head = newNode;
this.tail = newNode;
} else {
newNode.next = this.head;
this.head.prev = newNode;
this.head = newNode;
}
} else if (position === this.length) {
this.tail.next = newNode;
newNode.prev = this.tail;
this.tail = newNode;
} else {
let index = 0;
let current = this.head;
let previous = null;
while (index++ < position) {
previous = current;
current = current.next;
}
previous.next = newNode;
newNode.prev = previous;
newNode.next = current;
current.prev = newNode;
}
}
// - 获取对应位置的元素。get(position)
// - 返回元素在链表中的索引。如果链表中没有该元素则返回-1。indexOf(element)
// - 修改某个位置的元素。update(position ,element)
// - 从列表的特定位置移除一项。removeAt(position)
removeAt(position) {
if (position < 0 || position > this.length - 1) return null;
let current = this.head;
if (position === 0) {
if (this.length === 1) {
this.head = null;
this.tail = null;
} else {
this.head = this.head.next;
this.head.prev = null;
}
} else if (position === this.length - 1) {
current = this.tail;
this.tail.prev.next = null;
this.tail = this.tail.prev;
} else {
let index = 0;
let previous = null;
while (index++ < position) {
previous = current;
current = current.next;
}
previous.next = current.next;
current.next.prev = previous;
}
return current.element;
}
// - 从链表中移除一项。remove(element)
// - 如果链表中不包含任何元素，返回true，如果链表的长度大于0则返回false。isEmpty()
// - 返回链表包含的元素个数。与数组length属性类似。size()
}
module.exports = DoublyLinkedList;
测试
const DoublyLinkedList = require("./doubly_linkedList");
const doublyLinkedList = new DoublyLinkedList();
doublyLinkedList.append("a");
doublyLinkedList.append("b");
doublyLinkedList.append("c");
doublyLinkedList.append("d");
doublyLinkedList.append("e");
doublyLinkedList.append("f");
console.log(doublyLinkedList);
doublyLinkedList.insert(1, "g");
console.log(doublyLinkedList);
console.log(doublyLinkedList.get(1));
console.log(doublyLinkedList.indexOf("g"));
console.log(doublyLinkedList.removeAt(1));
console.log(doublyLinkedList.update(0, "nnn"));
console.log(doublyLinkedList.remove("f"));
扫一扫
890
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
