JavaScript 数据结构【链表】

已于 2022-07-12 11:43:57 修改
阅读量1.2k 收藏
点赞数
分类专栏： Javascript 文章标签： 链表 数据结构 散列表
于 2022-05-03 18:47:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44810886/article/details/124540822
版权

来自视频学习：

一、单向链表

只能从头到尾或者从尾遍历到头

封装单向链表： 

  function LinkedList() {
            //内部的类：节点类
            function Node(data) {
                this.data = data;
                this.next = null
            }
            //属性
            this.head = null;
            this.length = 0;
}

常见操作

1. append(element) ：向列表尾部添加一个新的项

2. insert(position,element): 向列表的特定位置插入一个新的项

3. get(position): 获取对应位置的元素

4. indexOf(element): 返回元素在列表中的索引。如果没有该元素返回-1

5. updata(position,element) : 修改某个位置的元素

6. removeAt(position)：从列表的特定位置移除某一项

7. remove(element)：从列表中移除一项

8. isEmpty()：如果链表中不包含任何元素，返回true，如果链表长度大于0则返回false

9. size() ：返回链表包含的元素个数。与数组的length属性类似

10. toString()： 由于列表使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值

链表和数组非常类似，因为链表本身就是一种可以替代数组的结构

//1。append：向列表尾部添加一个新的项
            LinkedList.prototype.append = function(data) {
                //1.创建新的节点
                var newNode = new Node(data)
                    //2.判断是否添加的第一个节点
                if (this.length == 0) { //2.1 是第一个节点
                    this.head = newNode
                } else { //2.2 不是第一个节点
                    //找到最后一个节点
                    var current = this.head //先指向第一个节点
                    while (current.next) { //判断这个节点是否为空，如果为空，代表是最后一个节点；通过while循环一个一个判断是否为最后一个节点
                        current = current.next
                    }
                    //最后节点的next指向新的节点
                    current.next = newNode
                }
                //3. length+1
                this.length += 1
            }

 // 2. toString方法 只输出链表的值
            LinkedList.prototype.toString = function() {
                //1.定义变量
                var current = this.head
                var listString = ""
                    //2,循环获取一个个的节点
                while (current) {
                    listString += current.data + " "
                    current = current.next
                }
                return listString
            }
 //3.insert 方法
            LinkedList.prototype.insert = function(position, data) {
                //1.对position进行跨界判断
                if (position < 0 || position > this.length) return false
                    //2.根据data 创建Node
                var newNode = new Node(data)

                //3.判断插入的位置是否是第一个
                if (position == 0) {
                    // this.head = newNode
                    // newNode.next =要指向原来的第一个，如何实现？改变这两句位置
                    newNode.next = this.head; //即指向了原来的第一个
                    this.head = newNode
                } else {
                    var index = 0
                    var current = this.head;
                    var previous = null;
                    while (index++ < position) {
                        previous = current
                        current = current.next
                    }
                    newNode.next = current
                    previous.next = newNode
                }

                //4. length+1
                this.length += 1;
                return true
            }


             //4.get 获取对应位置的元素
            LinkedList.prototype.get = function(position) {
                if (position < 0 || position >= this.length) return null
                    //2.获取对应的数据
                var current = this.head;
                var index = 0
                    // 假设position=2
                    // 第一次循环 index = 0, current指向第一个，
                    // 2. index = 1， current指向第二个，
                    // 3. index = 2， 不小于2
                while (index++ < position)
                    current = current.next
                return current.data
            }
 //5. 修改某个位置的元素
            LinkedList.prototype.updata = function(position, newData) {
                if (position < 0 || position >= this.length) return null
                    //2.
                var current = this.head
                var index = 0;
                while (index++ < position) {
                    current = current.next
                }
                current.data = newData
                return true
            }


            //6.从列表的特定位置移除某一项
            LinkedList.prototype.removeAt = function(position) {
                //1. 越界判断
                if (position < 0 || position >= this.length) return null
                    //2.判断是否删除的是第一个节点
                if (position == 0) {
                    this.head = this.head.next;
                } else {
                    var index = 0;
                    var current = this.head;
                    var previous = null;
                    while (index++ < position) {
                        previous = current;
                        current = current.next;
                    }
                    previous.next = current.next
                }
                this.length -= 1;
                return true
                    //return current.data,把current定义在外面
            }

            //7.remove方法 
            LinkedList.prototype.remove = function(data) {
                //1.获取data在列表中的位置
                var position = this.indexOf(data)
                    //2.根据位置删除节点
                return this.removeAt(position)
            }

            //8.isEmpty方法
            LinkedList.prototype.isEmpty = function() {
                return this.length == 0
            }

            //9.size方法
            LinkedList.prototype.size = function() {
                return this.length
            }

二、双向链表

1. 既可以从头遍历到尾，又可以从尾遍历到头

2. 链表相连的过程是双向的

封装双向链表

 //封装双向链表
        function DoublyLinkedList() {
            //内部类：节点类
            function Node(data) {
                this.data = data;
                this.prev = null;
                this.next = null;
            }
            //属性
            this.head = null;
            this.tail = null;
            this.length = 0;
}

常见操作

1. append(element) ：向列表尾部添加一个新的项

2. insert(position,element): 向列表的特定位置插入一个新的项

3. get(position): 获取对应位置的元素

4. indexOf(element): 返回元素在列表中的索引。如果没有该元素返回-1

5. updata(position,element) : 修改某个位置的元素

6. removeAt(position)：从列表的特定位置移除某一项

7. remove(element)：从列表中移除一项

8. isEmpty()：如果链表中不包含任何元素，返回true，如果链表长度大于0则返回false

9. size() ：返回链表包含的元素个数。与数组的length属性类似

10. toString()： 由于列表使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值

11. forwardString()：返回正向遍历的节点字符串形式

12. backwardString()：返回反向遍历的节点字符串形式

//常见的操作封装
            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.1 toString
            DoublyLinkedList.prototype.toString = function() {
                    return this.backwardString()

                }
                //2.2 forwardString方法
            DoublyLinkedList.prototype.forwardString = function() {
                //1.定义变量
                var current = this.tail;
                var resultString = ""
                    //2.依次向前遍历，获取每一个节点
                while (current) {
                    resultString += current.data + " ";
                    current = current.prev
                }
                return resultString

            }

            //2.3 backwardString方法
            DoublyLinkedList.prototype.backwardString = function() {
                //1. 定义变量
                var current = this.head; //指向了第一个
                var resultString = "";
                //2.依次向后遍历，获取每一个节点
                while (current) { //只要current有值
                    resultString += current.data + " ";
                    current = current.next;
                }
                return resultString
            }


            //insert
            DoublyLinkedList.prototype.insert = function(position, data) {
                //1. 越界判断
                if (position < 0 || position > this.length) return false
                    //2.根据data创建新的节点
                var newNode = new Node(data)
                    //3. 判断原来的列表是否为空
                if (this.length == 0) {
                    this.head = newNode
                    this.tail = newNode
                } else {
                    if (position == 0) { //3.1 判断position是否为0
                        this.head.prev = newNode; //原来的第一个节点的prev指向新插入的节点
                        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
            }

            //get方法
            DoublyLinkedList.prototype.get = function(position) {
                //1. 越界判断，注意后面有=
                if (position < 0 || position >= this.length) return null
                    // 思路：this.length/2 >position  从头向后遍历
                    // this.length/2 <position  从后向头遍历
                    //2.获取元素
                var index = 0;
                var current = this.head;
                while (index++ < position) {
                    current = current.next;
                }
                return current.data
            }

            //indexOf
            DoublyLinkedList.prototype.indexOf = function(element) {
                var current = this.head;
                var index = 0;
                while (current) {
                    if (current.data == element) {
                        return index
                    } else {
                        current = current.next
                        index += 1
                    }
                    return -1
                }
            }

            //updata方法
            DoublyLinkedList.prototype.updata = function(position, newData) {
                //1. 越界判断，注意后面有=
                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
            }

            //removeAt
            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;
                        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. 
                this.length -= 1;
                return current.data
            }


            //remove方法
            DoublyLinkedList.prototype.remove = function(data) {
                //1.根据data获取下标
                var index = this.indexOf(data)
                    //2. 根据index删除对应位置的节点
                return this.removeAt(index)
            }

            //
            DoublyLinkedList.prototype.isEmpty = function() {
                return this.length == 0
            }

            DoublyLinkedList.prototype.size = function() {
                return this.length
            }

            DoublyLinkedList.prototype.getHead = function() {
                return this.head.data
            }

            DoublyLinkedList.prototype.getTail = function() {
                return this.tail.data
            }

大肥妹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript数据结构链表知识详解
10-21
存储有序的元素集合，但不同于数组，链表中的元素在内存中不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。下面通过本文给大家详细介绍下，需要的朋友参考下
【前端】JavaScript 数据结构 -- 链表
weixin_44746306的博客
10-05 692
JavaScript 的链表数据结构
JS 数据结构：链表
weixin_46015333的博客
11-24 4106
本文介绍了什么是链表以及他的优缺点，并分别介绍了单链表、双向链表和循环链表之间的细微差别和各自的特点，一些有明显差异的操作都分别给出了图和代码，更易于理解和实践。
有关$.post(url,{param:"param"},function(data){})中的返回对象data
lixld的专栏
09-30 1万+
之前用了$.post()已经很久了，可是从来没有好好研究过这里的data对象，今天好好总结下： jquery文档中说,这里的data类型可以是：xml, html, script, json, text, _default 下面介绍我用过的几种： 1.json 后台： PrintWriter out = null; try { JSONArray json = JSONArray.f
js数据结构与算法：链表
m0_51311990的博客
06-20 1368
目录1.链表初认识1.1链表1.2为什么使用链表2.链表的各种方法2.1搭建链表2.2 push()2.3 removeAt(index)2.4 getElement(index)2.5 isEmpty()和size()2.6 toString()3.使用链表并总结3.1使用链表3.2总结 head用作指向第一个元素的指针（引用）node里面的value代表数据，next代表指向下一项的指针当node.next指向的为空时，代表此时的node为最后一个元素链表的最后一个元素，他的next指向一定是undef
【解决】JS表单提交数据入库成功，回调函数function(data)不执行
weixin_44220068的博客
03-02 1362
问题描述： 问题分析： Q、function(data)中的data代表什么？ A、data是回调函数默认的形式参数，可随意取名，它表示服务器返回的json格式的数据。 找到SystResult实体类，发现没有加@Data和@Accessors注解, 也就没有toString方法，无法将实体类转化成JSON格式的字符串， 因此导致返回的data格式不正确从而使回调函数function(data)...
JavaScript数据结构——链表数据结构
Jyao_In的博客
04-26 375
链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和指向下一个元素的引用（也称指针或链接）组成。 创建链表，并实现一些方法： push(element): 向链表尾部添加一个新元素。 insert(element, position): 向链表的特定位置添加一个新元素。 getElementAt(index): 返回链表中特定位置的元素。如果链表中不存在这样的元素则返回undefined。 remove(element): 从链表中移除一个
js使用List，在指定数据后面添加数据
热门推荐
勋勋勋勋小勋勋的博客
07-17 2万+
&lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;列表&lt;/title&gt; &lt;/head&gt; &lt;body&gt; &lt;/body&
js中的Data()对象
weixin_43613849的博客
04-07 1332
在JS中使用Date对象来表示一个时间，其中Date()为一个构造函数 如果直接使用构造函数创建一个Date对象，则会封装为当前代码执行时间 var d = new Date(); 如果想要显示一个指定的时间，则应该在构造函数中传入一个表示时间的字符串 var d2 = new Date("1/3/2019"); // 月/日/年 时间都为北京时间 对象名.getDate() //获取当前时间对象是几号 对象名.getDay()//获取当前时间对象时周几 ，0表示周日 对象名...
js中this的用法
isoble的博客
04-11 317
js中this的四种用法1.在一般函数中使用this指代全局对象function test(){ 　　　　this.x = 1; 　　　　alert(this.x); 　　} 　　test(); // 12.作为对象方法调用，this指代上级对象function test(){ 　　alert(this.x); } var o = {}; o.x = 1; o.m = test; o.m(); //
JavaScript实现的链表数据结构实例
10-24
主要介绍了JavaScript实现的链表数据结构实例,本文直接给出实现代码,需要的朋友可以参考下
数据结构-使用javascript讲解数据结构之链表.zip
02-12
数据结构 数据结构_使用javascript讲解数据结构之链表
JavaScript数据结构与算法之链表
10-22
链表就是线性表中针对顺序存储结构的一种优化手段，但是在javascript语言中由于数组的特殊性（自动更新引用位置），所以我们可以采用对象的方式做链表存储的结构
JavaScript数据结构之双向链表定义与使用方法示例
10-19
主要介绍了JavaScript数据结构之双向链表定义与使用方法,简单介绍了双向链表的原理,并结合实例形式分析了双向链表的定义与使用方法,需要的朋友可以参考下
数据结构 ： 树的分类及在数据库索引中的运用
simensk的博客
04-27 859
树 数据库索引 b树 b+树
JSON转CSV：使用Java处理复杂数据结构
qq_33326733的博客
04-29 139
在数据处理和分析的世界中，经常需要将数据从一种格式转换为另一种更便于处理或分析的格式。本文将详细介绍如何使用Java语言，配合Jackson和Apache Commons CSV库，将嵌套的JSON数据转换成CSV格式。通过上述步骤，我们不仅学会了如何处理和转换嵌套的JSON数据，还确保了数据的完整性和灵活性。为了进一步提高效率和可读性，可以考虑添加异常处理和数据验证的逻辑，确保在处理大量或复杂数据时的健壮性。首先，确保你的Java项目中引入了必要的库。中的数据，并将其转换为CSV格式。
acwing算法提高之数据结构--可持久化数据结构
最新发布
YMWM_的博客
04-30 165
acwing算法提高之数据结构--可持久化数据结构
数据结构九：线性表之链式队列的设计
weixin_47040031的博客
04-30 350
现在，我们可以知道，其实从本质上来讲，链式队列就是重新设计头节点的单链表结构，并且只允许头删和尾插（队尾入队头出）；对于循环队列与链队列的比较，可以从两方面来考虑，从时间上，其实它们的基本操作都是常数时间，即都为O(1)的，不过循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点也会存在一些时间开销，如果入队出队频繁，则两者还是有细微差异。对于空间上来说，循环队列必须有一个固定的长度，所以就有了存储元素个数和空间浪费的问题。
【java数据结构之八大排序（上）-直接插入排序，希尔排序，选择排序，堆排序，向下调整(大根堆，小根堆)等知识详解】
2301_76249062的博客
04-27 972
【java数据结构之八大排序（上）-直接插入排序，希尔排序，选择排序，堆排序，向下调整(大根堆，小根堆)等知识详解】
详解JavaScript数据结构
08-19
学习JavaScript数据结构与算法是非常重要的，因为它可以帮助我们更好地理解和应用JavaScript语言。数据结构和算法是计算机科学的基础，它们可以帮助我们更好地解决问题和优化代码。在学习过程中，我们需要掌握各种...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值