学了js这么久  还没有拿js写一个链表，刚好这段时间复习数据结构的东西,早上结束了对于图的战斗.下午解锁了js链表的“新技能”
 首先关于链表的存储啥的咱就不扯了,我是学c语言的时候学的链表,单链表，双向链表，循环链表....,所以如果对于链表咋存储还不懂得小伙伴还是先看看基础吧,链表确实不难.
  首先呢我们先讲一个叫class的东西.
      ES6引入了class类的概念，创建的每一个class类，都会有一个constructor()方法，该方法是一种用于创建和初始化class创建的对象的特殊方法--构造函数方法。

      class Animal {
 constructor() {
     this.name = "animal";
 }
}

let animal = new Animal();
console.log(animal.name);

如果一个类没有添加constructor()方法,则会自动添加

class Animal(){}
//等同于
class Animal(){
   constructor(){}  //默认的constructor方法
  } 
一个类只允许有一个constructor()方法，如果出现多个，则会报：Uncaught SyntaxError: A class may only have one constructor

ok,那么下来咱们首先建立一个结点:

  class Node { //定义结点
            constructor(val) {
                this.val = val;
                this.next = null;
            }
        }

下面就是相关链表的建立和相关操作函数了，具体的注释都在里面，话不多说，直接上代码.

 class LinkedList {  //定义链表
            constructor(node) {   
                this.head = node;
                this.length = 1;
            }
            isEmpty(){//判空函数
                return !this.length;
            }
            append(node){//增添函数
                var lastNode=this.findAsIndex(this.length-1);
                lastNode.next=node;
                this.length++;
            }
            insert(index,node){   //在那个元素之后插入
                var targetNode=this.findAsIndex(index);
                node.next=targetNode.next;
                targetNode.next=node;
            }
            remove(index){//删除函数
                var preNode=this.findAsIndex(index-1);
                var nextNode=this.findAsIndex(index+1);
                preNode.next=nextNode;
            }
            modify(index,val)//修改函数
            {
              var targetNode = this.findAsIndex(index-1);
              targetNode.val = val;
            }
            query(index)//查询函数
            {
                var targetNode =this.findAsIndex(index-1);;
                return targetNode.val;
            }
            findAsIndex(index){   
                if(index>this.length){
                    console.log('越界');
                    return
                }
                if(index===0){
                    return this.head;
                }
                var curNode=this.head; 
                while(index&&curNode){
                    index--;
                    curNode=curNode.next;
                }
                return curNode;
            }
            toString(){
                var curNode=this.head;
                var arr=[];
                var i=0;
                while(curNode){
                    arr[i++]=curNode.val;
                    curNode=curNode.next;
                }
                return arr.toString();
            }
        }

下面咱们对这些函数调用，检查一下.

let list=new LinkedList(new Node('a'));
        list.append(new Node('b'));
        list.append(new Node('c'));
        list.append(new Node('d'));
        list.append(new Node('e'));
        list.append(new Node('f'));
        list.append(new Node('g'));
        list.remove(1);
        console.log(list.toString())

        console.log(list.query(2));

        list.modify(2,'f');
        console.log(list.toString());

下面在终端稍微node一下 ，大家看看代码

PS D:\js算法\排序算法合集> node js链表.js
a,c,d,e,f,g
c
a,f,d,e,f,g
PS D:\js算法\排序算法合集> 

ok,那么本期的分享就在这里结束了，希望大家可以有所收获吧.如果有不对和可以优化的地方，也希望大家可以和我交流.