JS 双向链表的封装和引用

最新推荐文章于 2024-06-16 21:14:55 发布
最新推荐文章于 2024-06-16 21:14:55 发布
阅读量115 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 双向链表 js封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44828588/article/details/114638915
版权 
<!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">
    <title>Document</title>
</head>

<body>
    <script>
        function DoublyLinkedList() {
            this.head = null;
            this.tail = null;
            this.length = 0;

            function Node(data) {
                this.data = data;
                this.next = null;
                this.prev = null;
            }
            DoublyLinkedList.prototype.append = function(data) {
                    //1.创建data新节点
                    var newNode = new Node(data);
                    //2.判断添加的是否为第一个节点
                    if (this.length == 0) {
                        this.head = newNode
                        this.tail = newNode
                    } else {
                        newNode.prev = this.tail;
                        this.tail.next = newNode
                        this.tail = newNode
                    }
                    this.length += 1
                }
                //2.toString()
            DoublyLinkedList.prototype.toString = function() {
                return this.backWardString()
            }
            DoublyLinkedList.prototype.forWardString = function() {
                var current = this.tail;
                var resultString = "";
                while (current) {
                    resultString += current.data + " ";
                    current = current.prev

                }
                return resultString;
            }


            DoublyLinkedList.prototype.backWardString = function() {
                var current = this.head;
                var resultString = "";
                while (current) {
                    resultString += current.data + " ";
                    current = current.next

                }
                return resultString;
            }
            DoublyLinkedList.prototype.insert = function(position, data) {

                //越界判断
                if (position < 0 || position > this.length) {
                    return false
                }
                //创建data数据节点
                var newNode = new Node(data)
                    //第一个节点位置时
                if (this.length == 0) {
                    this.head = newNode
                    this.tail = newNode
                } else {
                    if (position == 0) {
                        this.head.prev = newNode
                        newNode.next = this.head;
                        this.head = newNode
                    } else if ((position) == this.length) {
                        newNode.prev = this.tail;
                        this.tail.next = newNode
                        this.tail = newNode

                    } else {
                        var current = this.head;
                        var index = 0;
                        while (index++ < position) {

                            current = current.next
                        }
                        newNode.next = current;
                        newNode.prev = current.prev
                        current.prev.next = newNode;
                        current.prev = newNode

                    }


                }
                this.length += 1;
                return true

            }
            DoublyLinkedList.prototype.get = function(position) {
                if (position < 0 || position > this.length) {
                    return null
                }
                var current = this.head;
                var index = 0;
                while (index++ < position) {
                    current = current.next;

                }
                return current.data;
            }
            DoublyLinkedList.prototype.indexOf = function(data) {
                var current = this.head;
                var index = 0;
                while (current) {
                    if (current.data == data) {
                        return index
                    }
                    current = current.next;
                    index++;
                }
                return -1;
            }
            DoublyLinkedList.prototype.updata = function(position, newData) {
                if (position < 0 || position > this.length) {
                    return false
                }
                var current = this.head;
                var index = 0;
                while (index++ < position) {
                    current = current.next;
                }
                current.data = newData;
                return true;

            }
            DoublyLinkedList.prototype.removeAt = function(position) {
                if (position < 0 || position >= this.length) {
                    return null
                }
                console.log(this.length)
                var current = this.head;
                if (this.length == 1) {
                    this.head = null
                    this.tail = null
                } else {
                    if (position == 0) {
                        this.head.next.prev = null;
                        this.head = this.head.next;
                    } else if ((position) == this.length - 1) {
                        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

                    }


                }
                this.length--;
                return current.data;
            }
            DoublyLinkedList.prototype.remove = function(data) {
                var index = this.indexOf(data);
                return this.removeAt(index)
            }
            DoublyLinkedList.prototype.isEmpty = function() {
                return this.length == 0
            }
            DoublyLinkedList.prototype.size = function() {
                    return this.length
                }
                //获取第一个元素
            DoublyLinkedList.prototype.getFirst = function() {
                    return this.head.data
                }
                //获取最后一个元素
            DoublyLinkedList.prototype.getLast = function() {
                return this.tail.data
            }

        }

        var list = new DoublyLinkedList();
        list.append("abc")
        list.append("cba")
        list.append("nba")

        // console.log(list.forWardString())
        console.log("-------------------------------------------------------")
        list.insert(0, 'aaa');
        list.insert(4, 'bbb');
        list.insert(2, 'ccc');
        console.log(list.backWardString())
        console.log(list.indexOf('aaa'))
        console.log(list.indexOf('cba'))
        console.log(list.indexOf('aa'))
        list.updata(0, 'mmm')
        list.updata(1, 'mmm')
        list.updata(2, 'mmm')
        console.log(list.backWardString())
            //ist.removeAt(0)
        console.log(list.backWardString())
            //list.removeAt(1)
        list.remove("nba")
        console.log(list.getFirst())
        console.log(list.getLast())
    </script>
</body>

</html>

 

优价实习
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言中双向链表和双向循环链表详解
08-30
主要介绍了C语言中双向链表和双向循环链表详解的相关资料,需要的朋友可以参考下
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
本篇文章主要介绍了JavaScript数据结构之双向链表和双向循环链表的实现，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
js实现简单双向链表封装
Hiroshi's
03-25 180
function DoublyLinkedList() { this.head = null; this.tail = null; this.length = 0; function Node(data) { this.previous = null; ...
javascript 跨域实现，实现双向通信，提供第3方调用
binyao02123202的专栏
03-04 1203
前言： 专门从事js工作其实也有1年时间了，水平一般。获取前端相关的知识，主要通过 司徒正美的博客 和 司徒正美的QQ群-javascript罗浮宫。 在去年的项目中，做消息推送的时候，由于推送服务部署在一个独立的服务上，后来试了一些方案， 最后是通过window.name和postMessage结合的方式解决跨域问题，从而实现消息推送(AJAX 的长轮询). 最近项目比较
js之间的互相引用踩坑记录
热门推荐
诗水人间
07-07 14万+
首先需要在script标签上的type标记为module <script src="js/api.js" type="module"></script> 而我这里的api.js引用来其他封装的js文件，当时用的是引用的是 ajaxUtils.js 在es6中实际上.js可以不写，但是这样在浏览器中会导致404错误，浏览器下载不到对应的js文件导致报错 import ajax from "./ajaxUtils"; 因此需要填上.js import ajax from "./aja
两个JS之间的函数互相调用
lzrit的博客
10-09 4513
这个问题是我在工作中用到的一个方法 因为要做封装 所以想到能不能在一个js中引用另一个js中的function 这样的话能大大的减少代码量 话不多说 先上代码 首先要在html页面引入两个js文件1.html   &lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta cha...
JavaScript实现双向链表
qq_42710593的博客
03-12 1157
JavaScript实现双向链表
JavaScript双向链表的封装
Li_xiaofen的博客
04-06 914
class DoubleLinkedList { constructor(data) { this.header = null; this.data = data; this.next = null; this.prev=null; this.tail=null this.length = 0; } // 尾部插入 appe.
JavaScript实现双向链表的封装
m0_56756462的博客
12-04 532
function DoublyLinkedList(){ //双向链表需要头指针尾指针 this.head = null this.tail = null this.lenght = 0 function Node(data){ this.data = data; this.next = null; this.prev = null; } //向链表最后添加元素 DoublyLinkedList.
Python单向链表和双向链表原理与用法实例详解
09-20
主要介绍了Python单向链表和双向链表原理与用法,结合实例形式详细分析了单向链表与双向链表的概念、原理以及创建、添加、删除等相关操作技巧,需要的朋友可以参考下
循环链表和双向链表.ppt
09-20
带头结点的链表、循环链表和双向链表的特征，基本运算。 对于循环链表要突出掌握判断链表空满的条件； 双向链表要强调插入和删除算法的实现。 最后通过多项式加法的示例，介绍线性表的应用。 预期目标： 我希望大家...
创建双向链表_双向链表_
09-30
通过建立双向链表，来实现双向查找，增加和删除的功能
【JS数据结构与算法】双向链表（DoublylinkedList）封装及其方法
29的博客
08-02 489
目录 双向链表结构 双向链表的封装 一、追溯方法（append(data)） 二、toString()的两种方式。 1、forwardString()（返回正向遍历的节点字符串形式） 2、backwardString() （返回反向遍历的节点字符串形式） 3、toString() （由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，...
数据结构之B树
嫦娥妹妹等等我的博客
06-16 349
**节点的大小**：每个节点至少有 `t - 1` 个键值（除根节点外），最多有 `2t - 1` 个键值。1. **高效的磁盘读取**：由于每个节点包含多个键值和指针，B树减少了磁盘I/O操作的次数，提高了查找和更新的效率。- **数据库系统**：B树及其变种（如B+树、B*树）广泛用于数据库索引结构，支持快速的数据插入、删除和查询。- 每个节点最多有 `2t - 1` 个键值和 `2t` 个子节点指针，其中 `t` 是B树的最小度数。- **平衡性**：B树是一棵平衡树，所有叶子节点位于同一层。
数据结构：冒泡排序，选择排序，插入排序，希尔排序的实现分析
Zhihuiguoz的博客
06-16 702
这篇博客主要介绍了一些基本的排序算法，从算法思想，算法步骤，动图演示，代码实现，复杂度分析，稳定性分析这几个方面详细的介绍了冒泡排序，选择排序，插入排序，希尔排序的运用。并对其进行了优化实现，简单易懂，很好上手。
排序——希尔排序
2301_80662872的博客
06-16 413
当序列越有顺序时，插入排序的时间效率就越高。时间复杂度：O(N^2)（虽然时间复杂度是N^2，那是在逆序的序列情况下，在现实中这种情况一般不会出现）空间复杂度：O(1)gap＞1：预排序，目的是让序列变得更有序。时间复杂度：O(N^1.3)空间复杂度：O(1)
北航第六次数据结构与程序设计作业（查找与排序）选填题
最新发布
zxy13149285776的博客
06-16 544
但是我们可以根据满二叉树h=log（n+1）大概估计一下，如果是三层的满二叉树，那么n为7，如果是4层的满二叉树，则n为15。的次数，而不是18交换的次数，18先和10比较，发现18比10大。从arr[1]到arr[n-1]，如果本身就递增，那么每个元素只跟自己的直接前驱元素比较一次就行，那么比较了n-1次。发生冲突，说明余数一致，说明能整除，放眼观去，63,9,45都能整除，因此3个和18冲突。看好了，是在序列中的位置，不是下标，位置从1开始，下标从0开始。若查找一个不存在的元素，说明进行了深度次比较。
双向链表和循环链表区别
07-23
双向链表和循环链表在基本结构有一些区别。 双向链表是一种链表结构，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。这样的设计使得在双向链表中可以通过前向或后向指针来访问节点的前后相邻节点...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

优价实习

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值