Js实现链表

最新推荐文章于 2024-04-16 01:56:33 发布
最新推荐文章于 2024-04-16 01:56:33 发布
阅读量1.4k 收藏 4
点赞数 1
分类专栏： Js与数据结构 文章标签： javascript 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiayngbaidu12345/article/details/123670695
版权

1.链表的插入（尾插法）

  1. 图形描述过程
    在这里插入图片描述

  2. 代码实现

function LinkedList(){

     //节点类
     function Node(data){
         this.data=data;
         this.next=null;
     }

     //属性
     this.head=null;//空链表时head指向null
     this.length=0;//链表长度

     //向链表尾部添加一个新的项(尾插法)
     LinkedList.prototype.append=function(data){
         //创建一个新节点
         var newNode=new Node();
         //如果要插入的是第一个链表，让head指向第一个节点
         if(this.length==0){
             this.head=newNode;
         }
         //如果不是第一个节点，则找到链表尾部的最后一个节点，让这个节点指向要插入的节点
         else{
             var current=this.head;//此时current指向第一个节点
             while(current.next){
                  current=current.next;
             }
             current.next=newNode;
         }
         //插入节点后，链表长度+1
         this.length+=1;
     }

   }

2.链表特定位置插入一个新的项

LinkedList.prototype.insert=function(position,data){
         //判断position是否合法
         if(position<0||position>this.length){
             return false;
         }
         //创建一个新节点
         var newNode=new Node(data);
         //要插入的位置是第一个
         if(position==0){
             newNode.next=this.head;
             this.head=newNode;
         }
         //要插入的位置不是第一个,寻找要插入的位置，previous指向其前一个节点，current指向插入位置的节点，让新节点指向current，previous指向新节点
         else{
            var index=0;
            var current=this.head,previous=null;
            while(index++<position){
                previous=current;
                current=current.next;
            }
            newNode.next=current;
            previous.next=newNode;
         }
         //节点插入成功，节点个数+1
         this.length+=1;
         return true;
         
     }

3.获取对应位置的元素

LinkedList.prototype.get=function(position){
         //判断position合法,因为position是从0开始的，举个例子,有0 1 2 ，此时length=3，position不能大于等于3
         if(position<0||position>=this.length){
             return false;
         }
         //找位置
         var current=this.head;
         var index=0;//从位置0开始找
         //index最终到position前一个位置，current最终指向position位置的节点
         while(index++<position){
             current=current.next;
         }
         //找到后返回元素
         return current.data;
     }

4.返回元素在链表中的索引，如果链表中没有，返回-1

LinkedList.prototype.indexOf=function(data){
         var current=this.head;
         var index=0//默认链表节点索引从0开始
         var c=0
         while(current){
             if(current.data==data){
                 return index;
             }
             else{
                current=current.next;
                index+=1;
             }
         }
         //匹配玩所有的节点，都没找到
         return -1;
     }

5.修改某个位置的元素

LinkedList.prototype.update=function (position,data){
        //判断position合法,因为position是从0开始的，举个例子,有0 1 2 ，此时length=3，position不能大于等于3
        if(position<0||position>=this.length){
             return false;
         }
         //找位置
         var current=this.head;
         var index=0;//从位置0开始找
         //index最终到position前一个位置，current最终指向position位置的节点
         while(index++<position){
             current=current.next;
         }
         //找到后更改元素
         current.data=data;
         return true;
    }

6.从链表的特定位置删除一项

LinkedList.prototype.removeAt=function(position){
         //判断position合法性
         if(position<0||position>=this.length){
             return false;
         }
         //如果删除的是第一个元素,让head直接指向它的next
         if(position==0){
             this.head=this.head.next;
         }
         //不是第一个元素时，找到要删除的位置的节点由current指向，要删除位置的前一个节点由previous指向，让previous.next指向current.next
         else{
             var current=this.head;
             var previous=null;
             var index=0;
             while(index++<position){
                 previous=current;
                 current=current.next;
             }
             previous.next=current.next;
         }
         //删除节点成功，节点数-1
         this.length-=1;
         return true;
     }

7.从链表中移除一项

//通过indexOf()方法找到对应位置，然后根据位置删除对应项removeAt(position);
     LinkedList.prototype.remove=function(data){
         var position=this.indexOf(data);
         return this.removeAt(position);
     }

8.链表是否为空

LinkedList.prototype.IsEmpty=function(){
        return this.length?false:true;
    }

9.返回链表的个数

 LinkedList.prototype.Size=function(){
        return this.length;
    }

10.将链表以字符串的形式输出

LinkedList.prototype.toString=function(){
        var str='';
        var current=this.head;
        while(current) {
            str+=current.data+' ';
            current=current.next;
        }
        return str;    
        }

对于单链表的基本操作就是这些了，下面是这些方法的汇合：

//链表
   
   function LinkedList(){

     //节点类
     function Node(data){
         this.data=data;
         this.next=null;
     }

     //属性
     this.head=null;//空链表时head指向null
     this.length=0;//链表长度

     //向链表尾部添加一个新的项(尾插法)
     LinkedList.prototype.append=function(data){
         //创建一个新节点
         var newNode=new Node(data);
         //如果要插入的是第一个链表，让head指向第一个节点
         if(this.length==0){
             this.head=newNode;
         }
         //如果不是第一个节点，则找到链表尾部的最后一个节点，让这个节点指向要插入的节点
         else{
             var current=this.head;//此时current指向第一个节点
             while(current.next){
                  current=current.next;
             }
             current.next=newNode;
         }
         //插入节点后，链表长度+1
         this.length+=1;
     }


     //向链表的特定位置插入一个新的项
     LinkedList.prototype.insert=function(position,data){
         //判断position是否合法
         if(position<0||position>this.length){
             return false;
         }
         //创建一个新节点
         var newNode=new Node(data);
         //要插入的位置是第一个
         if(position==0){
             newNode.next=this.head;
             this.head=newNode;
         }
         //要插入的位置不是第一个,寻找要插入的位置，previous指向其前一个节点，current指向插入位置的节点，让新节点指向current，previous指向新节点
         else{
            var index=0;
            var current=this.head,previous=null;
            while(index++<position){
                previous=current;
                current=current.next;
            }
            newNode.next=current;
            previous.next=newNode;
         }
         //节点插入成功，节点个数+1
         this.length+=1;
         return true;
         
     }


     //获取对应位置的元素
     LinkedList.prototype.get=function(position){
         //判断position合法,因为position是从0开始的，举个例子,有0 1 2 ，此时length=3，position不能大于等于3
         if(position<0||position>=this.length){
             return false;
         }
         //找位置
         var current=this.head;
         var index=0;//从位置0开始找
         //index最终到position前一个位置，current最终指向position位置的节点
         while(index++<position){
             current=current.next;
         }
         //找到后返回元素
         return current.data;
     }


     //返回元素在链表中的索引，如果链表中没有，返回-1
     LinkedList.prototype.indexOf=function(data){
         var current=this.head;
         var index=0//默认链表节点索引从0开始
         var c=0
         while(current){
             if(current.data==data){
                 return index;
             }
             else{
                current=current.next;
                index+=1;
             }
         }
         //匹配玩所有的节点，都没找到
         return -1;
     }


     //修改某个位置的元素
    LinkedList.prototype.update=function (position,data){
        //判断position合法,因为position是从0开始的，举个例子,有0 1 2 ，此时length=3，position不能大于等于3
        if(position<0||position>=this.length){
             return false;
         }
         //找位置
         var current=this.head;
         var index=0;//从位置0开始找
         //index最终到position前一个位置，current最终指向position位置的节点
         while(index++<position){
             current=current.next;
         }
         //找到后更改元素
         current.data=data;
         return true;
    }


     //从链表的特定位置删除一项
     LinkedList.prototype.removeAt=function(position){
         //判断position合法性
         if(position<0||position>=this.length){
             return false;
         }
         //如果删除的是第一个元素,让head直接指向它的next
         if(position==0){
             this.head=this.head.next;
         }
         //不是第一个元素时，找到要删除的位置的节点由current指向，要删除位置的前一个节点由previous指向，让previous.next指向current.next
         else{
             var current=this.head;
             var previous=null;
             var index=0;
             while(index++<position){
                 previous=current;
                 current=current.next;
             }
             previous.next=current.next;
         }
         //删除节点成功，节点数-1
         this.length-=1;
         return true;
     }


     //从链表中移除一项
     //通过indexOf()方法找到对应位置，然后根据位置删除对应项removeAt(position);
     LinkedList.prototype.remove=function(data){
         var position=this.indexOf(data);
         return this.removeAt(position);
     }


     //链表是否为空
    LinkedList.prototype.IsEmpty=function(){
        return this.length?false:true;
    }

    
    //返回链表的个数
    LinkedList.prototype.Size=function(){
        return this.length;
    }


    //将链表以字符串的形式输出 
    LinkedList.prototype.toString=function(){
        var str='';
        var current=this.head;
        while(current) {
            str+=current.data+' ';
            current=current.next;
        }
        return str;    
        }

   }


   
   //使用链表
   var linkedList=new LinkedList();

   linkedList.append('abc');
   linkedList.append('123');
   linkedList.append('hello');
   console.log(linkedList.toString());//abc 123 hello 
   linkedList.insert(0,'####');
   linkedList.insert(2,'?');
   console.log(linkedList.toString());//#### abc ? 123 hello 
   console.log(linkedList.get(1));//abc
   console.log(linkedList.indexOf('@'));//-1
   console.log(linkedList.indexOf('?'));//2
   console.log(linkedList.update(1,'@'));//true
   console.log(linkedList.toString());//#### @ ? 123 hello 
   console.log(linkedList.removeAt(1));//true
   console.log(linkedList.toString());//#### ? 123 hello 
   console.log(linkedList.remove('data'));//false
   console.log(linkedList.remove('123'));//true
   console.log(linkedList.toString());//#### ? hello 
   console.log(linkedList.IsEmpty());//false
   console.log(linkedList.Size());//3

结果：
在这里插入图片描述

岑**
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
js 往指定位置添加对象
weixin_45865992的博客
03-24 640
【代码】js 往指定位置添加对象。
js实现链表
ssjjrr的博客
02-02 940
js实现链表
双向链表（JavaScript实现）
最新发布
2301_79099606的博客
04-16 986
后记总结一下这三次面试下来我的经验是：一定不要死记硬背，要理解原理，否则面试官一深入就会露馅！代码能力一定要注重，尤其是很多原理性的代码（之前两次让我写过Node中间件，Promise.all，双向绑定原理，被虐的怀疑人生）！尽量从面试官的问题中表现自己知识的深度与广度，让面试官发现你的闪光点！多刷面经！
JavaScript实现双向链表
qwe02315的博客
04-13 332
双向链表：既可以从头遍历到尾，又可以从尾遍历到头。也就是说链表连接的过程是双向的，它的实现原理是：一个节点既有向前连接的引用，也有一个向后连接的引用。每次在插入或删除某个节点时，都需要处理四个引用，而不是两个，实现起来会困难些；相对于单向链表，所占内存空间更大一些；但是，相对于双向链表的便利性而言，这些缺点微不足道。双向链表不仅有head指针指向第一个节点，而且有tail指针指向最后一个节点；item储存数据、prev指向前一个节点、next指向后一个节点；
js链表的实现
shou_11的博客
07-11 161
【代码】【无标题】
用JS实现链表 --单链表
weixin_43850639的博客
02-15 968
用JS实现单链表
JS实现链表，前端必会
09-20
在前端开发中，通过JS实现链表有助于理解和优化数据处理，尤其是在需要频繁添加、删除和查找元素，而对内存位置无特殊要求的场景下。JS实现链表的文档和HTML文件可能包含了上述操作的详细示例代码，供学习者参考和...
JavaScript实现链表插入排序和链表归并排序
10-21
主要介绍了JavaScript实现链表插入排序和链表归并排序,较为详细的分析了插入排序和归并排序,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下。
使用JavaScript实现链表的数据结构的代码
10-19
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer) 。下面我们用 JavaScript 代码对链表的数据结构进行实现
linkedList:javascript中的链表实现
07-03
链表javascript中的链表实现请通过 mocha 测试文档npm 测试链表堆栈： ✓ allows adding elements through array inside constructor ✓ allows adding elements ✓ allows taking out elements at top ✓ has an ...
Js实现链表操作
StevenYanghahha的博客
05-23 253
​​实现链表主要操作，包括创建链表、遍历链表、获取链表长度、获取第​​i​​​个元素值、获取倒数第​​i​​个元素值、插入节点、删除节点、有序链表合并、有序链表交集。
用js写一个链表（详细注释)
qq_53145332的博客
03-18 1999
//先定义节点 class linkNode { val; next; constructor(val, next) { this.val = val; this.next = next } } //定义链表 //链表包含头指针，尾指针，和链表长度 class linkedList { constructor() { //初始化一个空链表 this._size = 0; this._head = nu
JS实现链表
Sco_jing的博客
06-18 4056
链表
前端必备数据结构——链表
MaNqo的博客
08-08 2127
一、单向链表 链表的优势 链表相对于数组的优点在于： 内存空间不是必须连续的，可以充分利用计算机的内存，实现灵活的内存动态管理。 链表不需要再创建的时候就确定大小，并且它的大小可以无限的延伸下去。 链表在插入和删除数据时，时间复杂度(即执行算法所需要的计算工作量)可以达到O(1)，相对数组效率高许多。 链表相对于数组的缺点在于： 链表访问任何一个位置的元素时，都需要从头开始访问 无法像数组一样通过下标值访问元素，需要从头开始访问，直到找到对应的元素 封装链表 链表的每个元素由一个存储元素本身的节点和
js 实现链表和树的结构
lulula的博客
10-28 3596
最近在学习es6 所以代码主要使用了es6的一些东西 链表的设计 我们设计链表包含两个类，一个是 Node 类用来表示节点，另一个事 LinkedList 类提供插入节点、删除节点等一些操作。 /** * 一般的语言实现链表都需要指针来实现 * 而js的引用类型本来就是按值引用的 * 变量中保存的实质上是一个指向其对应对象的一个...
JS实现链表类
哒哒哒
08-15 1345
最近在学习基础的数据机构，之前学校学的都差不多忘记了，现在都温故下并尝试着用JS来实现基本的数据结构类，有些地方可能有些不合理的地方 链表不熟悉的可以自行温故链表的基础知识，就特性啦可以对链表哪些操作啦等等，首先链表是以节点为单位的，一个节点包含值和指向下一个节点的指针，因此需要一个节点类 Node.js export default class Node { constructo...
js实现对链表的操作
最初的梦想
11-14 3467
介绍 关于对链表这种数据结构，原来在c语言中有提到过，链表一种长度可变的动态列表。分为单向列表和双向列表。 单向列表：每个节点不仅存在自身的值，同时也存在指向下一个元素的指针 双向链表：它的节点中存在两个指针，一个指向上一个节点的指针，一个指向下一个节点的指针，并且存在自己的一个值。 // 定义一个几点类型构造函数 function Node(v) { this.val = v; ...
将数字各位存入链表类中
05-29
好的，我可以帮你解决这个问题。下面是一个示例代码，可以将一个数字的各位数字存入链表中： ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def digit_to_list(num): if num == 0: return ListNode(0) dummy = ListNode(0) curr = dummy while num > 0: curr.next = ListNode(num % 10) curr = curr.next num //= 10 return dummy.next ``` 这个函数接受一个整数 `num` 作为参数，将其各个数字存入链表中并返回链表的头节点。例如，如果 `num` 为 123，那么函数将返回一个链表，其头节点的 `val` 属性为 1，第二个节点的 `val` 属性为 2，第三个节点的 `val` 属性为 3。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值