数据结构（JavaScript）------单向链表

最新推荐文章于 2024-06-14 04:49:50 发布
最新推荐文章于 2024-06-14 04:49:50 发布
阅读量111 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45423131/article/details/119482559
版权

单向链表

1.定义

​ 单向链表是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。链表是使用指针进行构造的列表，并且是由一个个结点组装起来的，因此又称为结点列表。其中每个结点都有指针成员变量指向列表中的下一个结点，head指针指向第一个结点称为表头，而终止于最后一个指向nuLL的指针。

在这里插入图片描述

2.链表优势

  • 要存储多个元素，另外一个选择是链表
  • 不同于数组，链表中的元素在内存中不必是连续的空间
  • 链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（有些语言称为指针或连接）组成

相对于数组，链表的一些优点

  • 内存空间不是必须连续的，可以充分利用计算机的内存，实现灵活的内存动态管理
  • 链表不必在创建时就确定大小，并且大小可以无限延伸下去
  • 链表在插入和删除数据时，时间复杂度可以达到O(1)，相对于数组效率高很多

相对于数组，链表的一些缺点

  • 链表访问任何一个位置的元素时，都需要从头开始访问（无法跳过第一个元素访问任何一个元素）
  • 无法通过下标直接访问元素，需要从头一个个访问，直到找到对应元素

3.链表的一些常见操作(增、删、改、查)

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

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

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

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

update(position):修改某个位置的元素

remove(element):从列表中移除一项

removeAt(position):从列表的特定位置移除一项

isEmpty():判断链表是否为空，为空则返回true，否则返回false

size():返回链表包含的元素个数

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

3.1 append()方法

 //1.增加方法
            LinkedList.prototype.append = function(data){
                //创建新的节点
                var newNode = new Node(data)
                //判断是否添加的为第一个节点
                if(this.length == 0){
                    this.head = newNode
                }else{
                    //找到最后一个节点
                    var current = this.head
                    while(current.next){
                        current = current.next
                    }
                    //最后节点的next指向新的节点
                    current.next = newNode
                }
                this.length += 1
            }

3.2 toString()方法

 //2.toString方法
            LinkedList.prototype.toString = function(){
                //2.1定义变量
                var current = this.head
                var listString = ""
                //2.2循环获取一个个的节点
                while(current){
                    listString += current.data + " "
                    current = current.next
                }
                return listString
            }

3.3 insert()方法

//3.insert方法
            LinkedList.prototype.insert = function(position,data){
                //对position进行越界判断
                if(position < 0 || position > this.length) return false
                //创建newNode
                var newNode = new Node(data)
                //判断插入位置是否是第一个
                if(position == 0){
                    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
                }
                this.length += 1
                return true
            }

3.4 get()方法

//get方法
            LinkedList.prototype.get = function(position){
                //越界判断
                if(position < 0 || position >= this.length) return false
                //获取对应data
                var current = this.head
                var index = 0
                while(index++ < position){
                    current = current.next
                }
                return current.data
            }

3.5 indexOf()方法

//indexOf方法
            LinkedList.prototype.indexOf = function(data){
                //定义变量
                var current = this.head
                var index = 0
                //开始查找
                while(current){
                    if(current.data == data){
                        return index
                    }else{
                        current = current.next
                        index +=1
                    }
                }
                //找到最后没有找到，返回-1
                return -1
            }

3.6 updata()方法

 //updata方法
            LinkedList.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
                }
                //将position位置的node的data修改成newData
                current.data = newData
                return true
            }

3.7 removeAt()方法

 //removeAt方法
            LinkedList.prototype.removeAt = function(position){
                //越界判断
                if(position < 0 || position >= this.length) return false
                //判断是否删除的是第一个节点
                var current = this.head
                if(position == 0){
                    this.head = this.head.next
                }else{
                    var index = 0
                    var previous = null
                    while(index++ < position){
                        previous = current
                        current = current.next
                    }
                    //前一个节点的next指向，current的next即可
                    previous.next = current.next
                }
                this.length -= 1
                return current.data
            }

3.8 remove()方法

 //remove方法
            LinkedList.prototype.remove = function(data){
                //获取data在列表中的位置
                var position = this.indexOf(data)

                //根据位置信息删除节点
                return this.removeAt(position)
            }

3.9 isEmpty()方法

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

3.10 size()方法

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

4.链表结构的封装

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

5. 完整代码

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

            //1.增加方法
            LinkedList.prototype.append = function(data){
                //创建新的节点
                var newNode = new Node(data)
                //判断是否添加的为第一个节点
                if(this.length == 0){
                    this.head = newNode
                }else{
                    //找到最后一个节点
                    var current = this.head
                    while(current.next){
                        current = current.next
                    }
                    //最后节点的next指向新的节点
                    current.next = newNode
                }
                this.length += 1
            }

            //2.toString方法
            LinkedList.prototype.toString = function(){
                //2.1定义变量
                var current = this.head
                var listString = ""
                //2.2循环获取一个个的节点
                while(current){
                    listString += current.data + " "
                    current = current.next
                }
                return listString
            }

            //3.insert方法
            LinkedList.prototype.insert = function(position,data){
                //对position进行越界判断
                if(position < 0 || position > this.length) return false
                //创建newNode
                var newNode = new Node(data)
                //判断插入位置是否是第一个
                if(position == 0){
                    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
                }
                this.length += 1
                return true
            }

            //get方法
            LinkedList.prototype.get = function(position){
                //越界判断
                if(position < 0 || position >= this.length) return false
                //获取对应data
                var current = this.head
                var index = 0
                while(index++ < position){
                    current = current.next
                }
                return current.data
            }

            //indexOf方法
            LinkedList.prototype.indexOf = function(data){
                //定义变量
                var current = this.head
                var index = 0
                //开始查找
                while(current){
                    if(current.data == data){
                        return index
                    }else{
                        current = current.next
                        index +=1
                    }
                }
                //找到最后没有找到，返回-1
                return -1
            }

            //updata方法
            LinkedList.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
                }
                //将position位置的node的data修改成newData
                current.data = newData
                return true
            }

            //removeAt方法
            LinkedList.prototype.removeAt = function(position){
                //越界判断
                if(position < 0 || position >= this.length) return false
                //判断是否删除的是第一个节点
                var current = this.head
                if(position == 0){
                    this.head = this.head.next
                }else{
                    var index = 0
                    var previous = null
                    while(index++ < position){
                        previous = current
                        current = current.next
                    }
                    //前一个节点的next指向，current的next即可
                    previous.next = current.next
                }
                this.length -= 1
                return current.data
            }

            //remove方法
            LinkedList.prototype.remove = function(data){
                //获取data在列表中的位置
                var position = this.indexOf(data)

                //根据位置信息删除节点
                return this.removeAt(position)
            }
            
            //isEmpty方法
            LinkedList.prototype.isEmpty = function(){
                return this.length == 0
            }

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

测试

 //测试

        var list = new LinkedList()

        list.append('asd')
        list.append('qwe')
        list.append('zzx')
        //alert(list)

        list.insert(0,'qqq')
        list.insert(3,'mmm')
        list.insert(5,'ppp')
        //alert(list)

        //alert(list.get(0))
        //alert(list.get(3))

        // alert(list.indexOf('ppp'))
        // alert(list.indexOf('asd'))
        // alert(list.indexOf('ccc'))

        list.updata(0,'ooo')
        list.updata(3,'uuu')
        //alert(list)

        list.removeAt(0)
        //alert(list)

        list.remove('ppp')
        //alert(list)
        list.remove('mmm')
        //alert(list)

        alert(list.isEmpty())
        alert(list.size())
咩羊羊♛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javascript数据结构-链表
Y
11-10 590
1. 链表数据结构 链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不算连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。下图展示一个链表结构： 相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。然而，链表需要使用指针，因此实现链表时需要额外注意。在数组中，我们可以直接访问任何位置的任何元素，而想要访问链表中间的一个元素，则需要从起点（表头）开始迭代链表直到找到所需的元素。 可以用火车来说明链表。每节车厢都是链表的元素，车
约瑟夫环-数据结构.doc
11-29
约瑟夫环是一种常见的数据结构问题，考察了链表的实现和算法设计。该问题的主要目标是设计一个程序来求出出列顺序，即按照约瑟夫环的规则，输出各个人的编号。 约瑟夫环的定义：编号是 1，2，……,n 的 n 个人按照...
JavaScript链表---单向链表
qq_33721778的博客
07-05 243
链表是由一组节点组成的集合，每个节点都有一个对象的引用指向下一个节点。指向下一个节点的引用叫做链。data中保存数据，next保存下一个节点的引用。我们可以看到链表的尾元素指向null，表示结束。由于链表的头结点确定起来很麻烦，由此我们又引入了头结点，来表示链表的头部。首先我们定义一个Node类来表示节点。从图中可以看出，Node类中需要包含两个属性： 我们再定义一个LinkedList类来提供操作链表的一些方法，LinkedList 中只有一个头节点属性。 查看链表 定义一个方法，打印出链表的值，遍历链表
JS数据结构（5）——单向链表
echomsy的博客
07-06 163
JS数据结构（5）——单向链表 链表和数组的区别： 数组的优缺点： 数组是最常用的数据结构，它用来存储多个元素。 几乎每一种编程语言中都有默认实现数组结构，并且有很多关于数组的操作方法。 数组的修改和查找操作，时间复杂度低。 数组的创建通常需要申请一段连续的内存空间，并且大小是固定的，所以当当前的数组不能满足容量需求的时候，就需要扩容（一般情况下会申请一个更大的数组，比如说原数组的2倍，然后将原数组中的元素再复制过去）,这对空间造成了大量浪费。 而且在数组开头或者中间插入数据的成本非常高，需要进行大量元素
数据结构之链表---单向链表
weixin_55530858的博客
07-15 1391
单向链表，数据结构
什么是单链表一
m0_60226024的博客
08-06 1715
1. 单链表概念&设计 单链表是一种链式存取的数据结构，，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。 对于链表的每一个结点，我们使用结构体（struct）进行设计，其主要内容有： 其中，DATA数据元素，可以为你想要储存的任何数据格式，可以是数组，可以是int，甚至可以是结构体（这就是传说中
数据结构之单向链表
凯耐的博客
11-13 413
（一）单向链表简介 单向链表是指每个节点只由值域和一个指针域组成，指针域用来存储数据元素直接后继节点的位置。 示意图 数组和链表都是线性表的存储结构，在上一篇 数据结构之栈和队列 应用到了数组和链表实现栈和队列。下面分析数组和链表的优缺点。 数组： 事先设定存储单元的大小，在实际应用中局限线比较大，使用起来不够 灵活 预定过大的浪费空间，预定过小可能造成存储空间不足 查询效率高...
javascript实现数据结构 --- 链表
通俗易懂
07-04 264
单向链表，双向链表
JavaScript数据结构------单向链表实现
m0_63077733的博客
10-21 292
JavaScript数据结构---单向链表
JavaScript 数据结构-单向链表
weixin_63712639的博客
03-24 1063
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title>Document</title> <style></style> </head> <body> <script> // 封装单向链表类 function linkedList() { .
链表_数据结构--链表_
10-01
在windows端利用python实现链表的相关功能
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
javascript-datastructures-算法
01-30
学习JavaScript数据结构和算法基础（ ）栈（堆栈）类别（队列）链表（LinkedList）单链表（LinkedList）双链表（DoublyLinkedList）循环链表（CircularLinkedList）判断链表是否成环（LinkedListWithCycle）链表插入...
数据结构实验--链表合并
03-05
输出一次合并前A，B表 输出一次合并后A, B表
数据结构——bitset（位图）模拟实现
mastershooter的博客
06-11 636
第一种：构造一个8位的位图，所有为初始化为0//00000000第二种：构造一个8位的位图，根据所给的值初始化位图前N位//01100100第三种：构造一个8位的位图，根据字符串中的0/1序列来初始化位图的前N位//00111001。
13. 第十三章 案例研究-选择数据结构
最新发布
清风
06-14 203
【代码】13. 第十三章 案例研究-选择数据结构。
数据结构下的线性回归模型
qq_35320456的博客
06-11 633
线性回归是一种强大的统计工具，它可以帮助我们理解和预测数据之间的关系。通过使用适当的数据结构，我们可以有效地构建和训练线性回归模型，从而对新的输入进行准确的预测。在实际应用中，我们需要根据问题的具体情况进行适当的模型调整和优化，以获得最佳的结果。在本文中，我们介绍了线性回归模型的基本概念、原理以及如何在C#中实现一个简单的线性回归模型。通过示例代码，我们展示了如何使用数据结构来存储和处理数据，以及如何训练模型并进行预测。希望这篇博客能够帮助你更好地理解线性回归模型及其在实际中的应用。
数据结构 -＞反转链表
2401_83373946的博客
06-12 246
这个函数使用迭代的方法反转了一个单向链表。通过逐个节点的处理，将每个节点的next指针反转，最终得到反转后的链表。
【数据结构】单链表
weixin_73483158的博客
06-11 236
c语言，带头不循环单链表。
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值