JavaScript 数据结构-双向链表

最新推荐文章于 2024-10-12 16:35:22 发布
最新推荐文章于 2024-10-12 16:35:22 发布
阅读量1.7k 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63712639/article/details/123773967
版权 
<!DOCTYPE html>
<html>

<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <style></style>
</head>

<body>

    <script>
        // 封装双向链表类
        function DoublyLinkedList() {
            // 内部类:用来创建链表节点
            function Node(data) {
                this.data = data
                this.prev = null //上指针 指向上一个节点
                this.next = null //下指针 指向下一个节点
            }

            // 定义属性
            this.length = 0
            this.head = null //头结点
            this.tail = null //尾结点

            // 定义相关方法
            // 1.在尾部追加数据
            DoublyLinkedList.prototype.append = function (data) {
                // 1.创建新的节点
                var newNode = new Node(data)

                // 2.判断是否为空链表
                if (this.head == null) {
                    this.head = newNode
                    this.tail = newNode
                } else {
                    this.tail.next = newNode
                    newNode.prev = this.tail
                    this.tail = newNode
                }

                // 3.length+1
                this.length += 1
            }

            // 2.转为字符串的方法 方便我们调试alert输出 否则会显示undefined
            // 2.1从前往后转为字符串
            DoublyLinkedList.prototype.forwardString = function () {
                var current = this.head
                var forwardStr = ""

                while (current) {
                    forwardStr += "," + current.data
                    current = current.next
                }

                return forwardStr.slice(1)
            }

            // 2.2反向遍历的方法 从后往前
            DoublyLinkedList.prototype.reverseString = function () {
                var current = this.tail
                var reverseStr = ""

                while (current) {
                    reverseStr += "," + current.data
                    current = current.prev
                }

                return reverseStr.slice(1)
            }

            // 2.3实现toString方法
            DoublyLinkedList.prototype.toString = function () {
                return this.forwardString()
            }

            // 3.根据索引插入元素的方法
            DoublyLinkedList.prototype.insert = function (position, data) {
                // 1.判断是否越界
                if (position < 0 || position > this.length) {
                    return false
                }

                // 2.创建新的节点
                var newNode = new Node(data)

                // 3.判断原来的链表是否为空链表
                if (this.length == 0) {
                    this.head = newNode //头指针指向新的节点
                    this.tail = newNode //尾指针指向新的节点
                } else {
                    if (position == 0) { //3.1判断插入位置是否为第一个
                        this.head.prev = newNode //原来头节点的上一个节点为新节点
                        newNode.next = this.head //新节点的下一个节点为原来的头结点
                        this.head = newNode      //头结点为新的节点
                    } else if (position == this.length) { //3.2判断插入位置是否为最后一个
                        newNode.prev = this.tail  //新节点的上节点为之前的尾结点
                        this.tail.next = newNode  //之前尾结点的下节点为新节点
                        this.tail = newNode       //新节点成为尾结点
                    } else {                      //3.3插入位置在中间
                        var current = this.head
                        var index = 0

                        while (index++ < position) {
                            current = current.next
                        }
                        //当循环终止时就找到了目标节点位置(position索引处的节点)
                        newNode.next = current       //新节点的下节点为目标节点
                        newNode.prev = current.prev  //新节点的上节点为目标节点的上节点
                        current.prev.next = newNode  //目标节点的上节点的下节点为新节点
                        current.prev = newNode       //目标节点的上节点为新节点
                    }
                }
                // 4.长度+1
                this.length += 1
            }

            // 4.根据索引获取元素的方法
            DoublyLinkedList.prototype.get = function (position) {
                // 1.判断是否越界
                if (position < 0 || position >= this.length) {
                    return null
                }
                if (this.length / 2 >= position) { //2.从前往后查找
                    var current = this.head
                    var index = 0
                    while (index++ < position) {
                        current = current.next
                    }
                    // 循环结束时已找到目标索引
                    return current.data
                } else {                      //3.从后往前查找
                    var current = this.tail
                    var index = this.length - 1
                    while (index-- > position) {
                        current = current.prev
                    }
                    // 循环结束时已找到目标索引
                    return current.data
                }
            }

            // 5.根据元素返回索引的方法
            DoublyLinkedList.prototype.indexOf = function (data) {
                // 1.定义变量
                var current = this.head
                var index = 0

                // 2.循环查找和data相同的节点
                while (current) {
                    if (current.data == data) {
                        return index
                    }
                    current = current.next
                    index += 1
                }
                return -1 //循环结束说明没有找到和data相同的节点 返回-1
            }

            // 6.根据索引修改元素的方法
            DoublyLinkedList.prototype.update = function (position, newData) {
                // 1.判断是否越界
                if (position < 0 || position >= this.length) return false

                if (this.length / 2 >= position) { //2.从前往后查找
                    var current = this.head
                    var index = 0
                    while (index++ < position) {
                        current = current.next
                    }
                    // 循环结束时已找到目标索引
                    current.data = newData
                } else {                            //3.从后往前查找
                    var current = this.tail
                    var index = this.length - 1
                    while (index-- > position) {
                        current = current.prev
                    }
                    // 循环结束时已找到目标索引
                    current.data = newData
                }
            }

            // 7.根据索引删除元素的方法
            DoublyLinkedList.prototype.removeAt = function (position) {
                // 1.判断是否越界
                if (position < 0 || position >= this.length) return null

                // 2.判断是否只有一个节点
                var current = this.head
                if (this.length == 1) {
                    this.head = null
                    this.tail = null
                } else {
                    if (position == 0) { //判断是否删除第一个节点
                        this.head.next.prev = null //头结点的下节点的上节点为null(删除第一个节点)
                        this.head = this.head.next //头结点为原来头结点的下节点
                    } else if (position == this.length - 1) { //最后节点
                        current = this.tail
                        this.tail.prev.next = null //删除最后节点
                        this.tail = this.tail.prev //尾结点为原来尾结点的上节点
                    } else { //中间删除
                        var index = 0
                        while (index++ < position) {
                            current = current.next
                        }
                        // 循环结束找到目标元素
                        current.prev.next = current.next  //目标节点的上节点 的下节点 为目标节点的下节点
                        current.next.prev = current.prev  //目标节点的下节点 的上节点 为目标节点的上节点
                    }
                }
                // 3.长度-1
                this.length -= 1
                return current.data
            }

            // 8.根据元素删除元素的方法
            DoublyLinkedList.prototype.remove = function (data) {
                // 1.根据data获取索引值
                var index = this.indexOf(data)

                // 2.根据index删除对应的节点
                return this.removeAt(index)
            }

            // 9.判断链表是否为空
            DoublyLinkedList.prototype.isEmpty = function () {
                return this.length == 0
            }

            // 10获取链表长度
            DoublyLinkedList.prototype.size=function (){
                return this.length
            }

            // 11.获取链表的第一个元素
            DoublyLinkedList.prototype.getHead=function (){
                return this.head.data
            }

            // 12.获取链表的最后一个元素
            DoublyLinkedList.prototype.getTail=function(){
                return this.tail.data
            }
        }

        // 方法测试
        var list = new DoublyLinkedList()

        // 1.测试末尾追加方法
        list.append(10)
        list.append(20)
        list.append(30)
        alert(list)

        // 2.测试转字符串的方法
        // alert(list.forwardString())
        // alert(list.reverseString())

        // 3.测试根据索引插入元素的方法
        // list.insert(0, 00)
        // list.insert(1, 11)
        // list.insert(2, 22)
        // alert(list)

        // 4.测试获取目标索引的元素
        // alert(list.get(0))
        // alert(list.get(4))

        // 5.测试根据元素获取索引的方法
        // alert(list.indexOf(10))
        // alert(list.indexOf(30))

        // 6.测试根据索引修改元素的方法
        // list.update(0,'000')
        // list.update(1,'111')
        // list.update(2,'222')
        // alert(list)

        // 7.测试根据索引删除元素的方法
        // list.removeAt(0)
        // list.removeAt(0)
        // alert(list)

        // 8.测试根据元素删除元素的方法
        // list.remove('10')
        // list.remove('20')
        // alert(list)

        // 9.测试链表是否为空的方法
        // alert(list.isEmpty())

        // 10.测试获取链表长度的方法
        // alert(list.size())

        // 11.测试获取链表第一个元素的方法
        // alert(list.getHead())

        // 12.测试获取链表最后一个元素的方法
        // alert(list.getTail())

    </script>
</body>

</html>

嗷呜~嗷呜~呜呜~
关注
专栏目录
数据结构-双向链表
qq_43714814的博客
12-12 2039
数据结构-双向链表
【JavaScript数据结构】 --- 双向链表
qq_53061847的博客
06-12 389
既可以从头遍历到尾，又可以从尾遍历到头。也就是说链表连接的过程是双向的，它的实现原理是：一个节点既有向前连接的引用，也有一个向后连接的引用。
数据结构-双向链表实现
qq_47700940的博客
10-10 102
【代码】数据结构-双向链表实现。
js数据结构- 双向链表
wlijun_0808的博客
03-03 207
双向链表 双向链表概念： 既可以从头遍历到尾，又可以从尾遍历到头。也就是说链表连接的过程是双向的，它的实现原理是：一个节点既有向前连接的引用，也有一个向后连接的引用。 双向链表的缺点： 每次在插入或删除某个节点时，都需要处理四个引用，而不是两个，实现起来会困难些； 相对于单向链表，所占内存空间更大一些； 但是，相对于双向链表的便利性而言，这些缺点微不足道。 双向链表的结构： 双向链表不仅有head指针指向第一个节点，而且有tail指针指向最后一个节点； 每一个节点由三部分组成：item储存数据、
javascript实现数据结构 --- 链表
通俗易懂
07-04 329
单向链表，双向链表
js数据结构学习--双向链表
qq_44998582的博客
11-21 184
5.双向链表 双向链表优点 即可以从头遍历到尾，也可以从尾遍历到头 一个节点既有向前连接的引用，也有一个向后连接的引用 双向链表缺点 每次插入或删除某个节点时，需要处理四个引用 相对于单向链表，所占内存空间更大 5.1双向链表的特点 使用一个head指向头部，一个tail指向尾部 每个节点都由三部分组成：前一个节点指针（prev）/保存的元素（item）/后一个节点的指针（next） 双向链表第一个节点的prev为null，最后的节点
JavaScript链表---双向链表
qq_33721778的博客
07-08 377
上一篇介绍了单向链表，我们发现从链表的头部通过next向后遍历链表很简单，但是从后向前遍历却不容易。既然我们可以把下一个节点存起来，那也可以定义一个prev属性，来指向上一个节点，这样就形成了双向链表首先在Node类中增加一个prev属性 插入节点 将新节点的next指向给定节点的next，新节点的prev指向给定节点 将给定节点next的prev指向新节点指向新节点，给定节点的next指向新节点 删除节点 将需要删除节点的prev的next指向需要删除节点的next 将需要删除节点的next的prev指
javascript数据结构-链表
Y
11-10 673
1. 链表数据结构 链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不算连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。下图展示一个链表结构： 相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。然而，链表需要使用指针，因此实现链表时需要额外注意。在数组中，我们可以直接访问任何位置的任何元素，而想要访问链表中间的一个元素，则需要从起点（表头）开始迭代链表直到找到所需的元素。 可以用火车来说明链表。每节车厢都是链表的元素，车
JavaScript数据结构与算法03----双向链表
m0_47531829的博客
02-09 514
javascript封装数据结构中的双向链表， <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
JavaScript数据结构之双向链表定义与使用方法示例
10-19
在JavaScript中，数据结构是构建高效算法的基础，而双向链表是一种重要的线性数据结构。本文将深入探讨双向链表的定义、工作原理以及如何在JavaScript中实现和使用它。 双向链表，顾名思义，是每个节点不仅包含指向...
每日学习一个数据结构-图
wendao76的专栏
10-08 1179
在数学中，图是描述于一组对象的结构，其中某些对象对在某种意义上是“相关的”。这些对象对应于称为顶点的数学抽象（也称为节点或点），并且每个相关的顶点对都称为边（也称为链接或线）。通常，图形以图解形式描绘为顶点的一组点或环，并通过边的线或曲线连接。图（Graph）是由顶点的有穷非空集合和顶点之间的连线（边）的集合组成，通常表示为G=(V, E)，其中G表示一个图，V(G)代表图G中的顶点集合，E(G)代表图G中的边集合。
数据结构-5.1.树的定义和基本术语
ADCvbV的博客
10-08 210
1.祖先结点：从所指节点上方开始，沿一个方向一直到根结点之间(包括根结点)所遇到的结点都是祖先结点：如：结点"你"的祖先结点有"父亲"和"爷爷";2.子孙结点：从一个结点出发，他的所有分支以及他的分支的分支，一直到没有分支时的所有结点:如：结点"父亲"的子孙结点有"你","K","L"和"F";3.双亲结点(父结点/前驱结点)：如结点"你"的双亲结点为"父亲";4.孩子结点(后继结点)：如结点"你"的孩子结点为"K"和"L";
利用编程思维做题之求节点 x 在二叉树中的双亲节点算法
跟着信仰走
10-12 539
通过递归遍历二叉树，可以有效地查找目标节点的双亲节点。如果树结构较为复杂，递归的方法也能较为清晰地处理问题。
浙大数据结构：07-图5 Saving James Bond - Hard Version
qq_74924951的博客
10-08 1389
bfs难题
numexpr-2.8.3-cp38-cp38-win_amd64.whl
10-14
numexpr-2.8.3-cp38-cp38-win_amd64.whl
ujson-5.3.0-cp311-cp311-win_amd64.whl
10-14
ujson-5.3.0-cp311-cp311-win_amd64.whl
基于MATLAB车牌识别程序技术实现面板GUI.zip
最新发布
10-14
vos3000
RJFireWall-maste赛资源
10-14
RJFireWall-maste赛资源
JavaScript数据结构与算法：链表详解
"本文主要探讨了JavaScript中的链表数据结构，包括单链表、静态链表、循环链表和双向链表。文章通过代码实例详细解释了如何在JavaScript中实现链表的增加和删除操作，并对比了链表与数组的区别。" 在JavaScript中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值