【数据结构与算法】详解什么是双向链表，并用代码手动实现一个双向链表

其中，属性 head 表示双向链表中的第一个元素；属性 tail 表示双向链表中的最后一个元素

（2）创建内部构造函数

---

双向链表的每一个元素都有三个属性，即prev 、item 和 next，分别表示该元素的前一个元素是谁 、存储着该元素的值和该元素的后一个元素是谁。所以我们就在双向链表的构造函数内部创建一个内部构造函数用于之后创建元素的实例对象

function DoubleLinkedList() {

//属性

this.head = null

this.tail = null

this.length = 0

//元素的构造函数

function Node(item) {

this.item = item

this.next = null

this.prev = null

}

}

（3）实现append()方法

---

append()方法就是将元素添加到双向链表的末尾。

实现思路：

1. 先创建新元素的实例对象 node

2. 先判断双向链表内有无元素，若没有元素，则将属性 head 和 属性 tail 都指向 node，最后属性 length + 1

3. 若双向链表中有元素了，则因为双向链表内多了一个指针 tail，所以我们要实现 append()方法也就方便了很多，只需要将 tail 指向 node，然后将原本的末尾元素 old_node 的 next 指向 node，并将 node 的 prev属性指向 old_node即可，然后属性 length + 1

为了方便大家理解，我用一个动图来向大家演示一下：

思路讲解完了，我们来实现一下该方法

function DoubleLinkedList() {

//属性

this.head = null

this.tail = null

this.length = 0

//元素的构造函数

function Node(item) {

this.item = item

this.next = null

this.prev = null

}

//在末尾加入元素

DoubleLinkedList.prototype.append = function (item) {

// 1.创建新元素的实例对象

let node = new Node(item)

// 2.判断双向链表内是否有元素

if(this.length === 0) {

this.head = node

this.tail = node

}

else {

node.prev = this.tail

this.tail.next = node

this.tail = node

}

// 3. 双向链表内元素 + 1

this.length ++

}

}

接下里我们来使用一下该方法

let dl = new DoubleLinkedList()

dl.append(‘js’)

dl.append(‘python’)

此时的链表内是这样的

（4）实现insert()方法

---

insert()方法就是在指定的索引位置插入元素。一共需要传入两个参数，第一个是 position，表示需要插入元素的位置；第二个参数是 item，表示元素的值

实现思路：

1. 创建新的元素实例对象 node

2. 判断指定的索引位置 position 是否越界，即是否小于0，或者大于双向链表的长度。若越界了，则直接返回false

3. 判断 position 是否为0。若为0，则直接将双向链表原本的第一个元素 ，也就是 head所对应的元素 old_node 赋值给 node的 next属性，再将 node 赋值给 old_node 的 prev 属性，然后将 node赋值给 head，表示现在链表的第一个元素为 node

4. 若 position 不为0，则遍历双向链表，同时记录遍历的索引 index 、遍历的上一个元素 prev 和在 index索引位置上的元素 current，当 index == position时，将 node赋值给 prev的 next属性，将 current 赋值给 node的 next属性，再将 prev 赋值给 node 的 prev 属性，最后将 node 赋值给 current 的 prev 属性

5. 属性 length + 1

为了方便大家理解，我用一个动图来向大家演示一下：

看完了方法的实现思路，我们来用代码实现一下该方法

function DoubleLinkedList() {

//属性

this.head = null

this.tail = null

this.length = 0

//元素的构造函数

function Node(item) {

this.item = item

this.next = null

this.prev = null

}

//向指定位置插入元素

DoubleLinkedList.prototype.insert = function (position, item) {

// 1.判断是否越界

if(position < 0 || position > this.length) {

return false

}

// 2.创建新元素的实例对象

let node = new Node(item)

let index = 0

let current = this.head

let prev = null

// 3.判断插入位置是否等于元素个数

if(position === this.length) {

//当 position 与 length相等时，就相当于在末尾添加元素

this.append(item)

}

// 4. 判断元素是否添加到第一个位置

else if(position === 0) {

node.next = this.head

this.head.prev = node

this.head = node

this.length ++

}

else {

// 5.遍历链表，直到找到position位置上的元素

while (index < position) {

prev = current

current = current.next

index ++

}

// 6.插入新元素

prev.next = node

current.prev = node

node.prev = prev

node.next = current

this.length ++

}

}

}

接下来我们来使用一下该方法

let dl = new DoubleLinkedList()

dl.insert(0, ‘C++’)

此时的双向链表是这样的

在执行一次 insert()方法

di.append(‘js’) //在末尾添加元素 js

dl.insert(1, ‘python’) //在索引 1处插入元素python

此时的双向链表是这样的

最后我们再向索引为 3 的位置插入元素 java，因为此时 length = 3，即双向链表元素个数为 3，这就相当于在末尾添加元素

dl.insert(3, ‘java’)

所以此时的链表是这样的

（5）实现get()方法

---

get()方法就是获取对应位置上的元素。需要传入一个参数，即 position，表示需要获取元素的索引

实现思路：

1. 判断 position 是否越界。若越界，则直接返回false

2. 遍历链表，同时记录当前索引 index，当 index == position时，返回当前位置上的元素

该方法思路比较简单，几乎跟链表的 get()方法一样，我们来看一下

function DoubleLinkedList() {

//属性

this.head = null

this.tail = null

this.length = 0

//元素的构造函数

function Node(item) {

this.item = item

this.next = null

this.prev = null

}

//获取对应位置上的元素

DoubleLinkedList.prototype.get = function (position) {

if(position < 0 || position > this.length - 1) {

return false

}

let index = 0

let current = this.head

while (index < position) {

current = current.next

index ++

}

return current.item

}

}

我们来使用一下该方法

let dl = new DoubleLinkedList()

dl.append(‘C++’)

dl.append(‘js’)

dl.append(‘python’)

dl.get(-2) //返回 false

dl.get(0) //返回 C++

dl.get(2) //返回 python

dl.get(3) //返回 false

（6）实现indexOf()方法

---

indexOf()方法就跟数组的一样，获取某元素在双向链表中的索引值，若双向链表中不存在该元素，则返回 -1。

这个方法思路很简单，就不详细讲解了，直接来看代码

function DoubleLinkedList() {

//属性

this.head = null

this.tail = null

this.length = 0

//元素的构造函数

function Node(item) {

this.item = item

this.next = null

this.prev = null

}

//获取元素的索引

DoubleLinkedList.prototype.indexOf = function (item) {

let current = this.head

let index = 0

// 1.遍历双向链表

while (index < this.length) {

// 2. 找到对应元素，返回索引值

if(current.item === item) {

return index

}

else {

index ++

current = current.next

}

}

// 3.未找到对应元素，返回 -1

return -1

}

}

我们来使用一下该方法

let dl = new DoubleLinkedList()

dl.append(‘C++’)

dl.append(‘js’)

dl.append(‘python’)

dl.indexOf(‘C++’) //返回 0

dl.indexOf(‘js’) //返回 1

dl.indexOf(‘python’) //返回 2

dl.indexOf(‘java’) //返回 -1

（7）实现update()方法

---

update()方法就是用于修改双向链表中某位置上的元素的值。因此该方法需要传入两个参数，第一个参数是 position，表示需要修改的元素的索引；第二个参数是 NewItem，表示修改后的值

该方法的实现思路跟普通链表一模一样，所以就不讲解具体的实现思路了，直接来看代码吧

function DoubleLinkedList() {

//属性

this.head = null

this.tail = null

this.length = 0

//元素的构造函数

function Node(item) {

this.item = item

this.next = null

this.prev = null

}

//修改某位置上的元素

DoubleLinkedList.prototype.update = function (position, item) {

// 1.判断是否越界

if(position < 0 || position >= this.length) {

return false

}

let index = 0

let current = this.head

// 2.遍历双向链表，直到找到对应位置上的元素

while (index < position) {

index ++

current = current.next

}

// 3.修改position索引位置上的元素的值

current.item = item

return true

}

}

我们来使用一下该方法

let dl = new DoubleLinkedList()

dl.append(‘C++’)

dl.append(‘js’)

dl.append(‘python’)

此时的链表是这样的

现在调用一下 update()方法，修改索引位置为 2 的元素的值

dl.update(2, ‘java’)

此时的链表是这样的

（8）实现removeAt()方法

---

removeAt()方法就是用于移除双向链表中某位置上的某元素。该方法只需要传入一个参数 position，表示需要移除元素的索引

实现思路：

1. 先判断 position 是否越界，若越界了，则直接返回 false 表示移除元素失败

2. 若没有越界，则判断 position 是否为 0，若等于 0，则直接将第一个链表的 next 值赋值给 head，然后 length - 1

3. 若 position 不等于 0而等于 length - 1，则将末尾元素的前一个元素，即 tail 的 prev对应的元素的 next 属性设置成 null，并将 tail 指向当前 tail 的 prev，最后 length - 1

4. 若 position 既不等于 0，又不等于 length - 1，则遍历双向链表，同时记录当前索引 index，遍历的当前元素 current，current的上一个元素 prev

5. 当 index === position时，将 current 的下一个元素，即 current 的 next 属性值赋值给 prev 的 next 属性，同时将 current 的下一个元素的 prev 的 prev 属性设置成 prev，最后 length - 1

为了让大家更好地理解该方法的实现思路，我制作了一个动图来帮助大家理解，如图

思路讲完了，我们直接来看代码

function DoubleLinkedList() {

//属性

this.head = null

this.tail = null

this.length = 0

//元素的构造函数

function Node(item) {

this.item = item

this.next = null

this.prev = null

}

//移除某位置上的元素

DoubleLinkedList.prototype.removeAt = function (position) {

// 1.判断是否越界

if(position < 0 || position >= this.length) {

return false

}

// 2.判断清除的元素是否为链表的唯一元素

if(position === 0 && position === this.length - 1) {

this.head = null

this.tail = null

}

// 3.判断清除的元素是否为链表的第一个元素

else if(position === 0) {

this.head.next.prev = null

this.head = this.head.next

}

// 4.判断清除的元素是否为链表的最后一个元素

else if(position === this.length - 1) {

this.tail.prev.next = null

this.tail = this.tail.prev

}

else {

let current = this.head

let prev = null

let index = 0

// 5.遍历双向链表

while (index < position) {

index ++

prev = current

current = current.next

}

// 6.删除对应位置上的元素

prev.next = current.next

current.next.prev = prev

}

// 7.元素个数 - 1

this.length –

return true

}

}

我们来使用一下该方法

let dl = new DoubleLinkedList()

dl.append(‘C++’)

dl.append(‘js’)

dl.append(‘python’)

dl.removeAt(2) //删除索引为 2位置上的元素

此时的双向链表是这样的

（9）实现remove()方法

---

remove()方法就是用于移除双向链表链表中的某元素，并返回被删除元素所在的索引位置，若链表中没有对应元素，则返回 false 。该方法需要传入一个参数 data用于查找链表中对应的元素

实现思路：

1. 利用上面封装的 indexOf()方法，将 data 作为参数传入，获取到 data 在链表中的索引 index 。

2. 再利用上面封装的 removeAt()方法，将 index 作为参数传入，就可以实现 remove()方法的功能了。

我们简单来写一下代码实现该方法

function DoubleLinkedList() {

//属性

this.head = null

this.tail = null

this.length = 0

//元素的构造函数

function Node(item) {

this.item = item

this.next = null

this.prev = null

}

//移除某元素

DoubleLinkedList.prototype.remove = function (data) {

// 1.获取data在双向链表中的索引

let index = this.indexOf(data)

// 2.利用removeAt()方法删除双向链表中的data

this.removeAt(index)

// 3.返回被删除元素data在双向链表中的索引

return index

}

}

我们来使用一下该方法

let dl = new DoubleLinkedList()

dl.append(‘C++’)

dl.append(‘js’)

dl.append(‘python’)

dl.remove(‘js’) //返回 1,此时length = 2

dl.remove(‘python’) //返回 1,此时length = 1

此时的链表是这样的

（10）实现isEmpty()方法

---

isEmpty()方法就是判断双向链表中是否有元素。若有元素，则返回 false；反之，返回 true

该方法的实现思路很简单，直接判断属性 length 是否等于 0 就可以了。

话不多说，我们赶紧写代码实现一下该方法

function DoubleLinkedList() {

//属性

this.head = null

this.tail = null

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注前端）

总结一下

面试前要精心做好准备，简历上写的知识点和原理都需要准备好，项目上多想想难点和亮点，这是面试时能和别人不一样的地方。

还有就是表现出自己的谦虚好学，以及对于未来持续进阶的规划，企业招人更偏爱稳定的人。

万事开头难，但是程序员这一条路坚持几年后发展空间还是非常大的，一切重在坚持。

为了帮助大家更好更高效的准备面试，特别整理了《前端工程师面试手册》电子稿文件。

前端面试题汇总

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

学提升又不知道该从何学起的朋友，同时减轻大家的负担。**
[外链图片转存中…(img-3fUAwU6u-1712879930123)]
[外链图片转存中…(img-ezXsxALa-1712879930124)]
[外链图片转存中…(img-Cf2srMQy-1712879930124)]
[外链图片转存中…(img-cRsfTiE0-1712879930125)]
[外链图片转存中…(img-f8o00Jvn-1712879930125)]
[外链图片转存中…(img-jKWLhfrE-1712879930125)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注前端）
[外链图片转存中…(img-Uyli9Fwx-1712879930126)]

总结一下

面试前要精心做好准备，简历上写的知识点和原理都需要准备好，项目上多想想难点和亮点，这是面试时能和别人不一样的地方。

还有就是表现出自己的谦虚好学，以及对于未来持续进阶的规划，企业招人更偏爱稳定的人。

万事开头难，但是程序员这一条路坚持几年后发展空间还是非常大的，一切重在坚持。

为了帮助大家更好更高效的准备面试，特别整理了《前端工程师面试手册》电子稿文件。

前端面试题汇总

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-sfhhNIso-1712879930126)]