JavaScript实现单向链表

最新推荐文章于 2022-06-19 10:08:00 发布
最新推荐文章于 2022-06-19 10:08:00 发布
阅读量349 收藏 2
点赞数 2
分类专栏： JavaScript数据结构与算法 文章标签： 数据结构 链表 算法 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42198495/article/details/107967956
版权

​​​​​​

JavaScript实现单向链表

一、单向链表简介

链表和数组一样，可以用于存储一系列的元素，但是链表和数组的实现机制完全不同。链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（有的语言称为指针或连接）组成。类似于火车头，一节车厢载着乘客（数据），通过节点连接另一节车厢。

image-20200227110656733

 

image-20200227110626750

 

image-20200226233942344

  • head属性指向链表的第一个节点；
  • 链表中的最后一个节点指向null；
  • 当链表中一个节点也没有的时候，head直接指向null；

数组存在的缺点：

  • 数组的创建通常需要申请一段连续的内存空间（一整块内存），并且大小是固定的。所以当原数组不能满足容量需求时，需要扩容（一般情况下是申请一个更大的数组，比如2倍，然后将原数组中的元素复制过去）。
  • 在数组的开头或中间位置插入数据的成本很高，需要进行大量元素的位移。

链表的优势：

  • 链表中的元素在内存中不必是连续的空间，可以充分利用计算机的内存，实现灵活的内存动态管理。

  • 链表不必在创建时就确定大小，并且大小可以无限地延伸下去。

  • 链表在插入和删除数据时，时间复杂度可以达到O(1)，相对数组效率高很多。

链表的缺点：

  • 链表访问任何一个位置的元素时，都需要从头开始访问（无法跳过第一个元素访问任何一个元素）。
  • 无法通过下标值直接访问元素，需要从头开始一个个访问，直到找到对应的元素。
  • 虽然可以轻松地到达下一个节点，但是回到前一个节点是很难的。

链表中的常见操作：

  • append（element）：向链表尾部添加一个新的项；
  • insert（position，element）：向链表的特定位置插入一个新的项；
  • get（position）：获取对应位置的元素；
  • indexOf（element）：返回元素在链表中的索引。如果链表中没有该元素就返回-1；
  • update（position，element）：修改某个位置的元素；
  • removeAt（position）：从链表的特定位置移除一项；
  • remove（element）：从链表中移除一项；
  • isEmpty（）：如果链表中不包含任何元素，返回trun，如果链表长度大于0则返回false；
  • size（）：返回链表包含的元素个数，与数组的length属性类似；
  • toString（）：由于链表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值；

首先需要弄清楚：下文中的position指的是两个节点之间，并且与index的关系如下图所示：

image-20200306101534508

position的值一般表示position所指位置的下一个节点。当position的值与index的值相等时，比如position = index = 1，那么它们都表示Node2。

二、封装单向链表类

2.0.创建单向链表类

先创建单向链表类Linklist，并添加基本属性，再实现单向链表的常用方法：

    // 封装单向链表类
    function LinkList(){
      // 封装一个内部类：节点类
      function Node(data){
        this.data = data;
        this.next = null;
      }

      // 属性
      // 属性head指向链表的第一个节点
      this.head = null;
      this.length = 0;
      }

 

2.1.append(element)

代码实现：

      // 一.实现append方法
      LinkList.prototype.append = data => {
        //1.创建新节点
        let newNode = new Node(data)

        //2.添加新节点
        //情况1：只有一个节点时候
        if(this.length == 0){
          this.head = newNode
        //情况2：节点数大于1，在链表的最后添加新节点  
        }else {              
          //让变量current指向第一个节点
          let current = this.head
          //当current.next(下一个节点不为空)不为空时，一直循环，直到current指向最后一个节点
          while (current.next){
            current = current.next
          }
          // 最后节点的next指向新的节点
          current.next = newNode
        }
        //3.添加完新结点之后length+1
        this.length += 1
      }

过程详解：

  • 首先让current指向第一个节点：

image-20200227145315369

  • 通过while循环使current指向最后一个节点，最后通过current.next = newNode，让最后一个节点指向新节点newNode：

image-20200227145453380

 测试代码：

    //测试代码
    //1.创建LinkList
    let list = new LinkList()
    
    //2.测试append方法
    list.append('aaa')
    list.append('bbb')
    list.append('ccc')
    console.log(list);

2.2.toString()

代码实现：

      // 实现toString方法
      LinkList.prototype.toString = () => {
        // 1.定义变量
        let current = this.head
        let listString = ""

        // 2.循环获取一个个的节点
        while(current){ 
          listString += current.data + " "
          current = current.next//千万不要忘了拼接完一个节点数据之后，让current指向下一个节点
        }
        return  listString
      }

测试代码：

    //测试代码
    //1.创建LinkList
    let list = new LinkList()
    
    //2.插入数据
    list.append('aaa')
    list.append('bbb')
    list.append('ccc')
    
    //3.测试toString方法
    console.log(list.toString());

2.3.insert(position,element)

代码实现：

      // 实现insert方法
      LinkList.prototype.insert = (position, data) => {
      //理解positon的含义：position=0表示新界点插入后要成为第1个节点，position=2表示新界点插入后要成为第3个节点
        //1.对position进行越界判断:要求传入的position不能是负数且不能超过LinkList的length
        if(position < 0 || position > this.length){
          return false
        }
        //2.根据data创建newNode
        let newNode = new Node(data)

        //3.插入新节点
        //情况1：插入位置position=0
        if(position == 0){
          // 让新节点指向第一个节点
          newNode.next = this.head
          // 让head指向新节点
          this.head = newNode
        //情况2：插入位置position>0(该情况包含position=length)
        } else{
          let index = 0
          let previous = null
          let current = this.head
          //步骤1：通过while循环使变量current指向position位置的后一个节点(注意while循环的写法)
          while(index++ < position){
          //步骤2：在current指向下一个节点之前，让previous指向current当前指向的节点
            previous = current
            current = current.next
          }
          // 步骤3：通过变量current(此时current已经指向position位置的后一个节点)，使newNode指向position位置的后一个节点
          newNode.next = current
          //步骤4：通过变量previous，使position位置的前一个节点指向newNode
          previous.next = newNode
          /*
            启示：
            1.我们无法直接操作链表中的节点，但是可以通过变量指向这些节点，以此间接地操作节点(替身使者)；
            比如current指向节点3，想要节点3指向节点4只需要：current.next = 4即可。
            2.两个节点间是双向的，想要节点2的前一个节点为节点1，可以通过：1.next=2，来实现；
          */
        }
        //4.新节点插入后要length+1
        this.length += 1;

        return true
      }

过程详解：

inset方法实现的过程：根据插入节点位置的不同可分为多种情况：

  • 情况1：position = 0：

通过： newNode.next = this.head，建立连接1；

通过： this.head = newNode，建立连接2；（不能先建立连接2，否则this.head不再指向Node1）

image-20200306103312580

  • 情况2：position > 0：

首先定义两个变量previous和curent分别指向需要插入位置pos = X的前一个节点和后一个节点；

然后，通过：newNode.next = current，改变指向3；

最后，通过：previous.next = newNode，改变指向4；

image-20200306103541674

 

  • 情况2的特殊情形：position = length：

情况2也包含了pos = length的情况，该情况下current和newNode.next都指向null；建立连接3和连接4的方式与情况2相同。

image-20200306103646576

测试代码：

    //测试代码
    //1.创建LinkList
    let list = new LinkList()
    
    //2.插入数据
    list.append('aaa')
    list.append('bbb')
    list.append('ccc')
    
    //3.测试insert方法
    list.insert(0, '在链表最前面插入节点');
    list.insert(2, '在链表中第二个节点后插入节点');
    list.insert(5, '在链表最后插入节点');
    alert(list);
    console.log(list);

 2.4.get(position)

代码实现：

      //实现get方法
      LinkList.prototype.get = (position) => {
        //1.越界判断
        // 当position = length时，取到的是null所以0 =< position < length
        if(position < 0 || position >= this.length){
          return null
        }
        //2.获取指定的positon位置的后一个节点的data
        //同样使用一个变量间接操作节点
        let current = this.head
        let index = 0
        while(index++ < position){
          current = current.next
        }
        return current.data
      }

过程详解：

get方法的实现过程：以获取position = 2为例，如下图所示：

  • 首先使current指向第一个节点，此时index=0；

image-20200227164308939

  • 通过while循环使current循环指向下一个节点，注意循环终止的条件index++ < position，即当index=position时停止循环，此时循环了1次，current指向第二个节点(Node2)，最后通过current.data返回Node2节点的数据；

image-20200227164351066

 

2.5.indexOf(element)

代码实现：

      //实现indexOf方法
      LinkList.prototype.indexOf = data => {
        //1.定义变量
        let current = this.head
        let index = 0

        //2.开始查找:只要current不指向null就一直循环
        while(current){
          if(current.data == data){
            return index
          }
          current = current.next
          index += 1
        } 

        //3.遍历完链表没有找到，返回-1
        return -1
      }

过程详解：

indexOf方法的实现过程：

  • 使用变量current记录当前指向的节点，使用变量index记录当前节点的索引值（注意index = node数-1）：

image-20200227155230599

2.6.update(position,element)

代码实现：

 

      //实现update方法
      LinkList.prototype.update = (position, newData) => {
        //1.越界判断
        //因为被修改的节点不能为null，所以position不能等于length
        if(position < 0 || position >= this.length){
          return false
        }
        //2.查找正确的节点
        let current = this.head
        let index = 0
        while(index++ < position){
          current = current.next
        }
        //3.将position位置的后一个节点的data修改成newData
        current.data = newData
        //返回true表示修改成功
        return true
      }

2.7.removeAt(position)

代码实现：

      //实现removeAt方法
      LinkList.prototype.removeAt = position => {
        //1.越界判断
        if (position < 0 || position >= this.length) {//position不能为length
          return null
        }
        //2.删除元素
        //情况1：position = 0时(删除第一个节点)
        let current = this.head
        if (position ==0 ) {
        //情况2：position > 0时
          this.head = this.head.next
        }else{
          let index = 0
          let previous = null
          while (index++ < position) {
            previous = current
            current = current.next
          }
          //循环结束后，current指向position后一个节点，previous指向current前一个节点
          //再使前一个节点的next指向current的next即可
          previous.next = current.next
        }
        //3，length-1
        this.length -= 1

        //返回被删除节点的data，为此current定义在最上面
        return current.data
      }

过程详解：

removeAt方法的实现过程：删除节点时存在多种情况：

  • 情况1：position = 0，即移除第一个节点（Node1）。

通过：this.head = this.head.next，改变指向1即可；

虽然Node1的next仍指向Node2，但是没有引用指向Node1，则Node1会被垃圾回收器自动回收，所以不用处理Node1指向Node2的引用next。

image-20200306110518877

  • 情况2：positon > 0，比如pos = 2即移除第三个节点（Node3）。

注意：position = length时position后一个节点为null不能删除，因此position != length；

首先，定义两个变量previous和curent分别指向需要删除位置pos = x的前一个节点和后一个节点；

然后，通过：previous.next = current.next，改变指向1即可；

随后，没有引用指向Node3，Node3就会被自动回收，至此成功删除Node3 。

image-20200306104624457

 

2.8.其他方法

其他方法包括：remove(element)、isEmpty()、size()

代码实现：

/*-------------其他方法的实现--------------*/
      //一.实现remove方法
      LinkList.prototype.remove = (data) => {
        //1.获取data在列表中的位置
        let position = this.indexOf(data)
        //2.根据位置信息，删除结点
        return this.removeAt(position)
      }

      //二.实现isEmpty方法
      LinkList.prototype.isEmpty = () => {
        return this.length == 0
      }

      //三.实现size方法
      LinkList.prototype.size = () => {
        return this.length
      }

 

 

完整实现代码：

    // 封装链表类
    function LinkList(){
      // 封装一个内部类：节点类
      function Node(data){
        this.data = data;
        this.next = null;
      }

      // 属性
      // 属性head指向链表的第一个节点
      this.head = null;
      this.length = 0;

      // 一.实现append方法
      LinkList.prototype.append = data => {
        //1.创建新节点
        let newNode = new Node(data)

        //2.添加新节点
        //情况1：只有一个节点时候
        if(this.length == 0){
          this.head = newNode
        //情况2：节点数大于1，在链表的最后添加新节点  
        }else {              
          //让变量current指向第一个节点
          let current = this.head
          //当current.next(下一个节点不为空)不为空时，一直循环，直到current指向最后一个节点
          while (current.next){
            current = current.next
          }
          // 最后节点的next指向新的节点
          current.next = newNode
        }
        //3.添加完新结点之后length+1
        this.length += 1
      }

      // 二.实现toString方法
      LinkList.prototype.toString = () => {
        // 1.定义变量
        let current = this.head
        let listString = ""

        // 2.循环获取一个个的节点
        while(current){ 
          listString += current.data + " "
          current = current.next//千万不要忘了拼接完一个节点数据之后，让current指向下一个节点
        }
        return  listString
      }

      // 三.实现insert方法
      LinkList.prototype.insert = (position, data) => {
      //理解positon的含义：position=0表示新界点插入后要成为第1个节点，position=2表示新界点插入后要成为第3个节点
        //1.对position进行越界判断:要求传入的position不能是负数且不能超过LinkList的length
        if(position < 0 || position > this.length){
          return false
        }
        //2.根据data创建newNode
        let newNode = new Node(data)

        //3.插入新节点
        //情况1：插入位置position=0
        if(position == 0){
          // 让新节点指向第一个节点
          newNode.next = this.head
          // 让head指向新节点
          this.head = newNode
        //情况2：插入位置position>0(该情况包含position=length)
        } else{
          let index = 0
          let previous = null
          let current = this.head
          //步骤1：通过while循环使变量current指向position位置的后一个节点(注意while循环的写法)
          while(index++ < position){
          //步骤2：在current指向下一个节点之前，让previous指向current当前指向的节点
            previous = current
            current = current.next
          }
          // 步骤3：通过变量current(此时current已经指向position位置的后一个节点)，使newNode指向position位置的后一个节点
          newNode.next = current
          //步骤4：通过变量previous，使position位置的前一个节点指向newNode
          previous.next = newNode
          
		//我们无法直接操作链表中的节点，但是可以通过变量指向这些节点，以此间接地操作节点；
        }
        //4.新节点插入后要length+1
        this.length += 1;

        return true
      }

      //四.实现get方法
      LinkList.prototype.get = (position) => {
        //1.越界判断
        // 当position = length时，取到的是null所以0 =< position < length
        if(position < 0 || position >= this.length){
          return null
        }
        //2.获取指定的positon位置的后一个节点的data
        //同样使用一个变量间接操作节点
        let current = this.head
        let index = 0
        while(index++ < position){
          current = current.next
        }
        return current.data
      }

      //五.实现indexOf方法
      LinkList.prototype.indexOf = data => {
        //1.定义变量
        let current = this.head
        let index = 0

        //2.开始查找:只要current不指向null就一直循环
        while(current){
          if(current.data == data){
            return index
          }
          current = current.next
          index += 1
        } 

        //3.遍历完链表没有找到，返回-1
        return -1
      }

      //六.实现update方法
      LinkList.prototype.update = (position, newData) => {
        //1.越界判断
        //因为被修改的节点不能为null，所以position不能等于length
        if(position < 0 || position >= this.length){
          return false
        }
        //2.查找正确的节点
        let current = this.head
        let index = 0
        while(index++ < position){
          current = current.next
        }
        //3.将position位置的后一个节点的data修改成newData
        current.data = newData
        //返回true表示修改成功
        return true
      }

      //七.实现removeAt方法
      LinkList.prototype.removeAt = position => {
        //1.越界判断
        if (position < 0 || position >= this.length) {
          return null
        }
        //2.删除元素
        //情况1：position = 0时(删除第一个节点)
        let current = this.head
        if (position ==0 ) {
        //情况2：position > 0时
          this.head = this.head.next
        }else{
          let index = 0
          let previous = null
          while (index++ < position) {
            previous = current
            current = current.next
          }
          //循环结束后，current指向position后一个节点，previous指向current前一个节点
          //再使前一个节点的next指向current的next即可
          previous.next = current.next
        }
        //3，length-1
        this.length -= 1

        //返回被删除节点的data，为此current定义在最上面
        return current.data
      }

/*-------------其他方法的实现--------------*/
      //八.实现remove方法
      LinkList.prototype.remove = (data) => {
        //1.获取data在列表中的位置
        let position = this.indexOf(data)
        //2.根据位置信息，删除结点
        return this.removeAt(position)
      }

      //九.实现isEmpty方法
      LinkList.prototype.isEmpty = () => {
        return this.length == 0
      }

      //十.实现size方法
      LinkList.prototype.size = () => {
        return this.length
      }
    }

 

万邺
关注
专栏目录
JavaScript实现单向链表的反转（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-23 75
JavaScript实现单向链表的反转（附完整源码）
【JS数据结构】单向链表
早睡早起长头发的博客
10-18 1085
一. 认识链表 1.数组 1.1 数组的优点 1.2 数组的缺点 2.链表 2.1 相对于数组, 链表有一些优点 2.2 相对于数组, 链表有一些缺点 3.什么是链表 3.1 链表的火车结构 3.2 链表的数据结构 3.3 给火车加上数据后的结构 二. 链表封装 1.创建链表类 1.1 创建一个链表类 1.2 代码解析 2.链表常见操作 2.1append(element)尾部追加数据 2.2 toString()转成字符串 2.3 insert(position
js实现单向链表
Me7on_的博客
12-02 167
class Node { constructor(data) { this.data = data; this.next = null; } } class LinkedList { constructor() { this.length = 0; this.head = null; } append(data) { const newNode = new Node(data); if (this.length === 0) {
JavaScript实现单向链表详解及操作方法
这个简单的单向链表实现可以用来存储和操作一组键值对数据，提供查找和添加的功能。虽然这里的示例不包含删除或插入操作，但可以根据需要扩展链表类来实现这些功能。这个基础实现有助于理解链表数据结构和基本操作的...
JavaScript实现单向链表教程与代码
在JavaScript中创建单向链表需要定义节点结构以及实现链表的基本操作，如插入、删除和搜索节点。通过以下几点可以详细解读如何在JavaScript中实现单向链表： 1. 链表节点定义 链表由多个节点构成，每个节点通常包含...
JavaScript封装单向链表的示例代码
10-14
总结来说，封装JavaScript单向链表涉及创建一个表示链表的类以及一个表示节点的内部类。链表类应包含对链表的基本操作，如添加、删除、查找、更新元素等。通过这种方式，我们可以轻松地在JavaScript应用程序中使用和...
JavaScript实现链表：单向链表与双向链表解析
"本文主要介绍了JavaScript中的数据结构与算法中的链表，包括链表的基本概念、单向链表和双向链表的实现。" 在计算机科学中，数据结构是组织和存储数据的方式，而算法是解决问题的具体步骤。链表作为一种重要的数据...
js-实现单向链表
u010271602的博客
01-12 565
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 javascript实现单向链表代码如下： function LinkedList() { var Node = function (element) { //表示要加入列表的项，next属性指向下一个节点项的指针 this.element = element; thi
JS实现单向链表
热门推荐
橘导的博客
12-19 1万+
前序 回过头看看以前用JS写了一半的链表，终于还是没忍住，实现了前段时间看着头疼的链表，其实链表也就那样。以前没细看数据结构，面试时被顺丰面试官要求手撕链表，怂的直说会用伪代码实现，就没然后了！面完后我就刻苦钻研，还是没搞懂大佬用JS实现的链表，虽然写了一半，但思路还是云里雾里的，昨天看了链表的相关数据结构细节问题，今天无意间看到以前留下的垃圾代码，就根据 把链表的基础属性与功能映射成JS...
用JS实现单向链表
m0_56649557的博客
06-26 260
链表 链表是数据的一种存储结构，一个链表包含若干个节点，每个节点至少包含一个数据域和指针域，指针域指向下一个节点。第0个节点称为头节点，头节点中存放第一个节点的首地址，头节点中没有数据域不存放数据，只是一个指针变量，头节点之后的节点都包含两个域 数据域 存放各种数据 指针域 存放下一个节点的首地址 链表的分类 单向链表 每个节点都只有一个指向其下一个节点的指针域 双向链表 每个节点都有一个指向其前一个节点的指针域和指向其下一个节点的指针域 // 定义节点类 cl
JS实现单链表
庸人方自扰，自在就好
12-03 565
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点（链表中每一个元素称为节点）组成，节点可以在运行时动态生成。每个节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)
js单链表的实现
weixin_45880538的博客
06-19 261
js简单实现单链表
数据结构--基于前端JS实现单向链表
qq_38700505的博客
02-21 457
眼看春招就要开始了，许多想从事前端行业的人士都开始摩拳擦掌准备面试，然而就现在前端来说，已经不是以前单纯的会写HTML、CSS、JS就行了。本人看了几个前端春招的招聘信息，框架自然不用多说，三大框架怎么也得要求熟练一个或多个。更多招聘要求上都写了了解或熟悉数据结构和算法。今天正好一个学弟问到了我这个问题，他在面试中被要求写一个单向链表，实现在尾部添加一项，在特定位置插入一项，移除一项，返回指定元素...
单向链表的JS实现(ES6)
Donnien的博客
05-19 138
创建代码 // 创建节点 class Node { constructor(element) { this.element = element; this.next = null; } } // 创建链表 class MyLinkedList { constructor() { // 初始头节点为空 this.head = null; // 链表长度 this.length = 0; } // 获取链表 即获取头指针 getList
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值