链表-单链表实现
关于链表
要存储多个元素的时候, 数组/列表 是最为常用的数据结构, 几乎每个编程语言都实现了数组或者列表.
但这种结构的缺点是, 通常数组大小是固定的, 即便类似 js Array 或者 Python 中的 list, 当我们从中间插入或者删除元素时成本很高.
数组特点是: 访问快 (有索引), 中间或者头部插入效率慢, 需要连续存储.
而链表这种结构, 里面的元素不是连续放置的. 每个元素由一个存储元素本身的节点 和 指向下一个元素的引用 (指针/链接) 组成. 其好处在于, 添加或者删除元素, 不需要移动其他元素, 但经常需要指针从头节点去遍历查找.
链表的特点是: 访问效率低 (都要遍历), 中间或头部插入效率高 (不用移动其他元素), 分散存储.
创建链表
要创建链表, 首先我们需要创建一个 Node 类来表示每个节点元素, 其存储自身的值 和 一个指针属性, 默认指向 null.
// 节点类
class Node {
constructor(element) {
this.element = element
this.next = null
}
}
然后是链表的初始状态, 用一个变量 count 来动态记录链表大小, 用 head 来指向头结点对象, 默认是 null.
// 链表类
class LinkedList {
constructor(equalsFn = defaultEquals) {
this.count = 0 // 链表元素数量
this.head = null // 头结点元素的引用
}
}
链表常用方法
基本的方法包括获取链表的大小, 插入元素, 查询元素, 链表查看等.
- size() 获取链表的大小
- isEmpty() 判断链表是否为空
- getHead() 获取头结点的值
- toString() 以字符形式打印链表元素
- getElement(index) 根据位置查询对应节点元素值
- indexOf(element) 获取元素的位置, 不存在则返回 -1
- push(element) 从链表尾部添加元素
- insert(index, element) 从链表任意位置插入元素 (前插)
- removeAt(index) 根据位置删除元素
- remove(element) 根据元素值
共用方法
- size() 获取链表的大小
- isEmpty() 判断链表是否为空
- getHead() 获取头结点的值
- toString() 以字符形式打印链表元素
- getElement(index) 根据位置查询对应节点元素值
// 节点类
class Node {
constructor(element) {
this.element = element
this.nex = null
}
}
// 链表类
class LinkedList {
constructor() {
this.count = 0
this.head = null
}
// 基础公用方法, 链表大小, 头节点, 打印值 ...
size() {
return this.count
}
isEmpty() {
return this.count == 0
}
getHead() {
// 这里的 element 就是 Node 的值
return this.head.element
}
toString() {
if (this.head == null) return undefined
let str = `${this.head.element}`
// current 指向头结点的下一个元素, 然后开始移动, 直至为空节点
let current = this.head.next
for (let i = 1; i < this.size() && current != null; i++) {
str = `${str}, ${current.element}`
current = current.next
}
return str
}
// 根据节点位置索引, 查询并返回该节点对象
// 这个方法使用频繁, 不论是查询, 增删节点都会用到
getElementAt(index) {
// 越界检查
if (index < 0 || index > this.count) return undefined
// 从链表头部开始迭代 0 -> index, 取出元素值即可
let node = this.head
for (let i = 0; i < index && node != null) {
node = node.next
}
return node
}
}
链尾插入元素
- 如果是空链表, 直接让 head 指向该元素
- 如果链表非空, 则移动指针到链尾, 指向该元素
- 最后要记得更新链表长度 +1
// 链尾添加元素
push(element) {
// 实例化节点元素 和 声明 current 指针, 默认指向 head 节点
const node = new Node(element)
let current = this.head
// 当链表为空时, 让链表 head 指向 node 即可
if (this.head == null) {
this.head = node
} else {
// 移动指针到最后, 然后添加元素
while (current.next != null) {
current = current.next
}
}
// 循环结束后, 只是指针处于链尾, 将其 next 指向新元素即可
current.next = node
}
// 最后一定要记得更新链表长度哦
this.count += 1
任意位置添加元素
这就要用到之前定义的 getElementAt(index) 方法了, 然后要根据插入位置做不同处理.
当插入的位置是 0, 即从头结点插入时:
node -> []; [node]
或者: note -> [1, 2, 3] => [node, 1, 2, 3]
则: this.head = node; node.next = current
当从中间插入时, 则要先找到这个元素, 并对其前, 后 元素进行先断链, 新增元素后再链接的操作:
node -> [1, 2, 3, 4], 要在位置 2 的位置插入:
[1, 2, node, 3, 4]
先获取目标位置的前一个元素 previous = p(2-1) = 2;
然后目标位置的元素 current = previous.next = 3;
然后断链插入操作, 让 current 往后 "挪" 一下即可.
previous.next = node
node.next = current
// 任意位置插入元素
insert(index, element) {
// 越界检查
if (index < 0 || index > this.count) return false
// 创建节点对象, 并判断是在哪个位置添加
const node = new Node(element)
if (index == 0) {
// 如果是第一个位置添加, 则让 this.head -> node -> head_old 即可
node.next = this.head
this.head = node
} else {
// 获取插入位置的前一个节点 previous, 以当前节点 current
const previous = this.getElementAt(index - 1)
const current = previous.next
// 断链插入 node 以后, current 往后 "挪" 了一下
previous.next = node
node.next = current
}
// 添加了都要更新链表长度
this.count++
return true
}
任意位置删除元素
也是要用到上面定义的 getElementAt(index) 方法, 整体逻辑和插入逻辑是差不多的.
首先都是要根据位置, 获取到该元素节点 target, 然后根据位置进行分别断链处理即可.
- 删除的是头元素, 直接让 head -> target.next
- 删除的是非头元素, 让
target前一个节点 -> target 的后一个节点就搞定
// 任意位置删除元素
removeAt(index) {
// 索引越界检查
if (index < 0 || index > this.count) return false
let current = this.head
// 判断 index 是否为 0, 对应不同的处理方式
if (index == 0) {
// 若移除的是头元素, 则将链表头指针指向下一个元素
this.head = current.next
} else {
// 找到目标位置的前一个元素, 后一个元素, 进行相连即可
const previous = this.getElementAt(index -1)
current = previous.next
previous.next = current.next
}
// 最后记得长度减1, 并返回被删除的元素
this.count -= 1
return current.element
}
返回元素的位置
即从头到尾遍历链表, 当找到时就返回位置, 没有找到则返回 -1.
indexOf(element) {
let current = this.head
for (let i = 0; i < this.count && current != null) {
if (current.element = element) return i
// 往后移动指针
current = current.next
}
// 移动完都没找到就返回 -1
return -1
}
删除元素
直接用上面的 indexOf(element) 找到元素的位置, 然后用 removeAt(index) 就搞定啦.
remove(element) {
const index = indexOf(element)
return removeAt(index)
}
完整实现
// 节点类, 辅助
class Node {
constructor(element) {
this.element = element
this.next = null
}
}
// 链表类
class LinkedList {
constructor() {
this.count = 0 // 链表元素数量
this.head = null // 头结点元素的引用
}
// 链表大小, 是否为空, 返回头结点, toString 等
size() {
return this.count
}
isEmpty() {
return this.count == 0
}
getHead() {
return this.head.element
}
toString() {
if (this.head == null) return undefined
let objString = `${this.head.element}`
let current = this.head.next
// 遍历节点将元素链接起来
for (let i = 1; i < this.size() && current != null; i++) {
objString = `${objString}, ${current.element}`
current = current.next
}
return objString
}
// 根据元素位置索引, 查询并返回该元素
getElementAt(index) {
// 越界检查
if (index < 0 || index > this.count) return undefined
// 从链表头部开始迭代
let node = this.head
for (let i = 0; i < index && node != null; i++) {
node = node.next
}
return node
}
// 链尾添加元素
push(element) {
// 元素添加进节点, 和声明 current 指针, 默认指向 head
const node = new Node(element)
let current = this.head
// 当尾空链表时, 此时的元素是第一个, 则让链表的 head 指向该 node
if (this.head == null) {
this.head = node
} else {
// 链表中已有元素, 移动 current 指针到最后
while (current.next != undefined) {
current = current.next
}
current.next = node
}
this.count++
}
// 任意位置插入元素
insert(index, element) {
// 越界检查
if (index < 0 || index > this.count) return false
const node = new Node(element)
if (index == 0) {
node.next = this.head
this.head = node
} else {
// 获取目标位置的前一个元素, 当前元素, 下一个元素
const previous = this.getElementAt(index - 1)
const current = previous.next
previous.next = node
node.next = current
}
this.count++
return true
}
// 移除指定位置的元素
removeAt(index) {
// 索引越界检查
if (index < 0 || index > this.count) return undefined
// 用一个指针默认指向链表头元素
let current = this.head
if (index == 0) {
// 如果移除的是第一项, 则将链表的头元素指向下一个元素即可
this.head = current.next
} else {
const previous = this.getElementAt(index - 1)
current = previous.next
previous.next = current.next
}
this.count--
return current.element
}
// 返回元素的位置
indexOf(element) {
let current = this.head
for (let i = 0; i < this.count && current != null; i++) {
if (current.element === element) return i
// 移动指针
current = current.next
}
return -1
}
// 移除元素
remove(element) {
const index = this.indexOf(element)
return this.removeAt(index)
}
}
// test
const list = new LinkedList()
console.log('链表元素是:', list.toString());
list.push(10)
console.log('链表元素是:', list.toString());
list.push(20)
list.push(30)
list.push(40)
console.log('链表元素是:', list.toString());
console.log('链表的长度是: ', list.count);
console.log('删除的元素是: ', list.removeAt(0))
console.log('链表元素是:', list.toString());
console.log('链表的长度是: ', list.count);
console.log('在位置 2 的地方添加 666:', list.insert(2, 666))
console.log('在位置 0 的地方添加 999:', list.insert(0, 999))
console.log('此时的头结点值是: ', list.getHead());
console.log('链表元素是:', list.toString());
console.log('链表的长度是: ', list.count);
console.log('查找 666 的索引位置是: ', list.indexOf(666))
console.log('查找 888 的索引位置是: ', list.indexOf(888))
console.log('删除掉元素 666: ', list.remove(666))
console.log('链表元素是:', list.toString());
console.log('链表的长度是: ', list.count);
console.log('此时的头结点值是: ', list.getHead());
console.log('从头节点插入 nb: ', list.insert(0, 'nb'))
console.log('此时链表元素是:', list.toString());
console.log('此时的头结点值是: ', list.getHead());
console.log('从位置 2 出插入 222: ', list.insert(2, 222))
console.log('此时链表元素是:', list.toString());
console.log('此时的头结点值是: ', list.getHead());
输出:
PS F:\algorithms> node .\linkedList.js
链表元素是: undefined
链表元素是: 10
链表元素是: 10, 20, 30, 40
链表的长度是: 4
删除的元素是: 10
链表元素是: 20, 30, 40
链表的长度是: 3
在位置 2 的地方添加 666: true
在位置 0 的地方添加 999: true
此时的头结点值是: 999
链表元素是: 999, 20, 30, 666, 40
链表的长度是: 5
查找 666 的索引位置是: 3
查找 888 的索引位置是: -1
删除掉元素 666: 666
链表元素是: 999, 20, 30, 40
链表的长度是: 4
此时的头结点值是: 999
从头节点插入 nb: true
此时链表元素是: nb, 999, 20, 30, 40
此时的头结点值是: nb
从位置 2 出插入 222: true
此时链表元素是: nb, 999, 222, 20, 30, 40
此时的头结点值是: nb
至此, 单链表相关的基本实现就搞定了, 实际应用中基本不用, 但关键在于理解这个过程和训练编程思维.
耐心和恒心, 总会获得回报的.
