javascript数据结构与算法----单向链表

数组

链表

封装链表类的常见方法：

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

（1）实现append方法

• 当前添加的元素是第一个元素，此时需要将head指向当前创建的元素

• 当前添加的元素不是第一个元素，循环找出当前链表的最后一个元素，将最后一个元素的next指向当前创建的元素

• 公共部分，改变length属性，创建新元素

  function LinkedList(){
       // 节点类
       function Node(data){
           this.data = data
           this.next = null
       }
       // 
       this.head = null
       this.length = 0
       // 链表的相关操作  
        LinkedList.prototype.append=(data)=>{
            // 创建一个节点
            var newNode = new Node(data)
            if(this.head == null){
                // 当添加的节点是链表的第一个元素
                this.head = newNode
            }else{
                // 从head开始向下寻找
                var current = this.head 
                while(current.next){
                    current = current.next
                }
                // 找到最后一个节点以后，将这个元素的next指向新创建的节点
                current.next = newNode
            }
            this.length +=1
        }
   }
  

（2）实现toString方法

LinkedList.prototype.toString = function(){
    // 定义变量
    var current = this.head
    var listString = ''
    while(current){
        listString+=current.data+' '
        current = current.next
    }
    return listString
}

测试代码

（3）实现insert方法
插入元素的情况分析
当插入的位置信息为position为0 的位置
当插入的位置为某一个大于0的位置（注意，这里的position和index索引的取的方式一样，从第一个节点开始计算，head不计算在内）（这种情况下的话是包含插入的位置为length的情况）

LinkedList.prototype.insert = function(position,data){
    // return false：插入失败
    // position的界限判断，>0，<= length
    if(position<0 || position>this.length) return false
    // 创建节点
    var newNode = new Node(data)
    if(position==0){
        // 先将原本head指针赋值当前新创建的节点
        // 因为原本head的指针指向第一个元素，现在进行指针赋值过后，新创建的节点的指针就指向原来的第一个元素
        newNode.next =this.head 
        // 再将当前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

    }
    // 最后更新length属性
    this.length +=1
        
}

（4）实现get方法

LinkedList.prototype.get = function(position){
    // 越界判断,为什么不能取等号，是因为最后一个节点的是length-1
    if(position<0 || position>=this.length) return false
    // 获取对应data
    var current = this.head
    var index= 0
     // 循环更新current，直到找到当前传入的position则退出循环
    while(index++ < position){
        current = current.next
    }
    return current.data
}

（5）实现indexof方法

LinkedList.prototype.indexOf = function(data){
    var current = this.head
    var index = 0
    while(current){
        // 如果找到，则返回index
        if(current.data == data){
            return index
        }
        // 如果没有找到，更新当前的current和index
        current = current.next
        index +=1
    }
    return -1
}

（6）实现update方法

 LinkedList.prototype.update = function(position,newData){
     // 越界判断
     if(position<0 ||position>=this.length) return false
         // 查找正确的节点信息
     var current = this.head
     var index=0
     while(index++ < position){
         current = current.next
     }
     current.data = newData
     return true
 }

（7）实现removeAt()方法

LinkedList.prototype.removeAt = function(position){
    // 越界判断
    if(position<0 ||position>=this.length) return null

    // 判断是否删除的是第一个节点
    if(position == 0){
        this.head = this.head.next

    }else{
        var current = this.head
        // 前一个节点默认为null
        var pre = null
        var index = 0
        while(index++ <position){
            pre = current
            current = current.next
        }
        pre.next = current.next
    }

    this.length -= 1
    return true
}

（8）实现remove()方法

LinkedList.prototype.remove = function(data){
    // 获取data在链表中的位置
    var position = this.indexOf(data)
    // 根据位置删除节点
    return this.removeAt(position)
    
}

（9）实现isEmpty ()，size ()方法

 LinkedList.prototype.isEmpty = function(){
     // 获取data在链表中的位置
     return this.length == 0
 }
 LinkedList.prototype.size = function(){
     // 获取data在链表中的位置
     return this.length
 }