Js算法中的链表

1，链表的常见

• append(element)：想列表尾部添加一个新的项
• insert(position,element)：想列表特定的位置插入一个新的项
• get(position)：获取对应位置的元素
• indexOf(element)：返回元素在列表中的索引，没有返回-1
• update(position,element)：修改某个位置中的元素
• removeAt(position)：从列表特定位置移除一项
• remove(position)：从列表中移除一项
• isEmpty()：链表为空时，返回true，否则返回false
• size()：返回链表的元素个数
• toString()：输出元素的值
• forwardString()：返回正向遍历节点字符串形式
• backwardString()：返回反向遍历节点字符串形式

一，单向链表的结构

二，单向链表的实现

class Node{
    constructor(data){
        //内部节点类
        this.data=data
        this.next=null
    }
}
class LinkedList{
    constructor(){
        this.head=null
        this.length=0
    }
    //1，追加方法
    append(data){
        //创建一个新的节点
        var newNode=new Node(data)
        //判断添加的是否为第一个节点
        if(this.length==0){
            this.head=newNode
        }else{
            var current=this.head
            while(current.next){
                current=current.next
            }
            //让最后的节点指向新的节点
            current.next=newNode
        }
        this.length+=1
    }
    //toString方法
    toString(){
        //定义变量
        var current = this.head
        var listString=""
        //循环获取每一个的节点
        while(current){
            listString+=current.data.+" "
            current=current.next
        }
        return listString
    }
    //insert方法
    insert(position,data){
        //1，进行越界的判断
        if(position<0 || position>this.length) return false
        //创建一个新的节点
        var newNode=new Node(data)
        //判断插入的节点是否为第一个
        if(position==0){
            newNode.next=this.head//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方法
    get(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方法
    indexOf(data){
        //定义变量
        var current=this.head
        var index=0
        while(current){
            //如果是第一个节点的数据
            if(current.data.=data){
                return index
            }
            current=current.next
            index+=1
        }
        return -1
    }
    //update方法
    update(position,data){
        //进行越界的判断
        if(position<0 || position >=this.length) return null
        var current=this.head
        var index=0
        while(index++<position){
            current=current.next
        }
        current.data=data
        return true
    }
    //removeAt方法
    removeAt(position){
        //越界的判断
        if(position<0 || position>=this.length) return null
        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方法
    remove(data){
        //获取data在表中的位置
        var position=this.indexOf(data)
        reutn this.removeAt(position)
    }
    //isEmpty方法
    isEmpty(){
        return this.length==0
    }
    //size方法
    size(){
        return this.length
    }
}

三，双向链表的结构

四，双向链表的实现

class Node{
    constructor(data){
        this.data=data
        this.prev=null
        this.next=null
    }
}
class DoublyLinkedList{
    constructor(){
        this.head=null
        this.tail=null
        this.length=0
    }
    //追加方法
    append(data){
        //创建一个新的节点
        var newNode=new Node(data)
        //判断是否第一个节点
        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
    }
    //toString方法
    toString(){
        return this.backwardString()
    }
    //forwardString方法
    forwardString(){
        var current =this.tail
        var resultString=""
        //依次向前遍历获取每一个节点
        while(current){
            resultString++current.data+" "
            current=current.prev
        }
        return resultString
    }
    //backwardString方法
    backwardString(){
        //定义变量
        var current =this.head
        var resultString=''
        //依次向后遍历获取每一个节点
        while(current){
            resultString+=current.data+" "
            current=current.next
        }
        return resultString
    }
    //insert方法
    insert(position,data){
        //越界的判断
        if(position<0 ""position>this.length) return false
        //创建一个新的节点
        var newNode=new Node(data)
        //节点为空时，插入第一个节点
        if(position==0){
            this.head.prev=newNode
            newNode.next=this.head
            this.head=newNode
        }else{
        //有数据是插入的是第一个节点
            if(position==0){
                this.head.prev=newNode
                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方法
    get(position){
        //越界的判断
        if(position<0 || position>=this.length) return false
        //获取元素
        var current=this.head
        var index=0
        while(index++<position){
            current=current.next
        }
        return current.data
    }
    //indexOf方法
    indexOf(data){
        var current=this.head
        var index=0
        //查找和data相同的节点
        while(current){
            if(current.data=data){
                return index
            }
            current=current.next
            index+=1
        }
        return -1
    }
    //update方法
    update(position,data){
        //越界的判断
        if(position<0 || position>=this.length) return false
        var current=this.head
        var index=0
        while(index++<position){
            current=current.next
        }
        current.data=data
        return true
    }
    //removeAt方法
    removeAt(position){
        //越界的判断
        if(position<0 || position>=this.length) return false
        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
            }
            this.length-=1
            current.next.prev=current.prev
        }
        this.length-=1
        return current.data
    }
    //remove方法
    remove(data){
        //根据data获取索引
        var index=this.indexOf(data)
        return this.removeAt(index)
    }
    //isEmpty方法
    isEmpty(){
        return this.length==0
    }
    //size方法
    size(){
        return this.length
    }
}