JS LinkedList 链表

基本概念

• 线性表：顺序表（list,linear list），基本数据结构，存储的每个数据称为一个元素，各个元素及其索引是一一对应的关系，线性表有两种存储方式：顺序存储方式和链式存储方式。

• 数组（array）：数组是线性表的顺序存储方式，数组的内存是连续分配的，并且是静态分配的，即在使用数组前需分配固定大小的空间，可通过索引直接得到数组中的元素，即获取数组中元素的时间复杂度为O(1)。

• 链表（linked-list）：链表是线性表的链式存储方式。链表的内存是不连续的，前一个元素存储地址的下一个地址中存储的不一定是下一个元素。链表通过一个指向下一个 元素地址的引用将链表中的元素串起来。

  
  
  

  线性表

数组缺陷

数组（列表）是一种简单的存储数据序列的数据结构，要存储多个元素，数组（列表）可能是最常用的数据结构。

• 数组的缺点：数组的大小是固定的，从数组的起点或中间插入或移除项的成本很高，因为需要移动元素。
• JS数组的问题：被实现成了对象，与其他语言如C++或Java的数相比，效率很低。

数据结构

链表存储有序的元素集合，不同于数组，链表中的元素在内存中并不是连续放置的。

链表

链表中每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称为指针或链接）组成。

链表

相对于传统的数组，链表的好处在于，添加或移除元素的时候不需要移动其他元素。然后，链表需要使用指针，因此实现链表时需额外注意。

链表

数组的另一个细节是可以直接访问任何位置的任何元素，而想要访问链表中间的一个元素，需要从起点（表头）开始迭代列表直到找到所需的元素。

除了对数据的随机访问，链表几乎可以用任何可以使用一维数组的情况中，如果需要随机访问，数组仍然是更好的选择。

定义链表

链表是由一组节点组成的集合，每个节点都使用一个对象的引用指向它的后继。指向另一个节点的引用叫做链。

链表

链表

• 数组元素靠他们的位置进行引用，链表则是靠相互之间的关系进行引用。
• 链表的尾元素指向一个null节点
• 链表最前面有一个特殊节点叫做头节点

有头结点的链表

链表中插入一个节点的效率很高，向链表中插入一个节点，需要修改它前面的节点（前驱），使其指向新加入的节点，而新加入的节点则指向原来前驱指向的节点。

向链表中插入元素

从链表中删除元素，将带删除元素的前驱节点指向待删除元素的后继节点，同时将待删除元素指向为null，元素就删除成功了。

从链表中删除元素

创建链表

/*节点类*/
function Node(element){
    this.element = element;//保存节点上的数据
    this.next = null;//保存指向下一个节点的链接
}
/*查找给定元素的节点*/
function find(element){
    var current = this.head;
    while(current.element != element){
        current = current.next;
    }
    return current;
}
function previous(item){
    var node = this.head;
    while(!(node.next==null) && (node.next.element!=item)){
        node = node.next;
    }
    return node;
}
function remove(item){
    var node = this.previous(item);
    if(!(node.next==null)){
        node.next = node.next.next;
    }
}
/*在某节点后插入元素*/
function insert(item, element){
    var current = this.find(item);
    var node = new Node(element);

    node.next = current.next;
    current.next = node;
}

function display(){
    var node = this.head;
    while(!(node.next==null)){
        print(node.next.element);
        node = node.next;
    }
}
/*链表类*/
function Llist(){
    this.head = new Node('head');
    //遍历链表查找指定数据
    this.find = find;
    //插入新节点：节点后插入
    this.insert = insert;
    //获取某节点之前的节点
    this.previous = previous;
    //从链表中删除一个节点
    this.remove = remove;

    this.display = display;
}

var ll = new Llist();
ll.insert('head','conway');
ll.insert('conway','russellville');
ll.insert('russellville','alma');
ll.display();//conway russellville alma
ll.remove('russellville');
ll.display();//conway alma

实现链表

链表类(LinkedList)需要一个节点辅助类(Node)，节点类(Node)表示要加入列表的项目。

• element 元素属性即要添加到列表的值
• next 用于指向列表中下一个节点项的指针

function LinkedList(){
    /*辅助节点类*/
    var Node = function(element){
        this.element = element;//链表的值
        this.next = null;//指向下一个节点的指针
    };
    var length = 0;//链表节点的数量，私有属性。
    var head = null;//头节点

    /*链表实现的方法*/
    this.append = function(element){};
    this.insert = function(position,element){};
    this.remove = function(element){};
    this.indexOf = function(element){};
    this.removeAt = function(position){};
    this.isEmpty = function(){};
    this.size = function(){};
    this.toString = function(){};
}

向链表尾部追加元素

链表最后一个节点的下一个元素（next）始终是null

场景

• 列表为空则添加的是第一个元素
• 列表不为空向其追加元素

/*向链表尾部追加元素*/
this.append = function(element){
    var node = new Node(element);
    //列表中第一个节点
    if(head === null){
        head =node;
    }else{
        var current = head;
        //循环列表直到找到最后一项
        while(current.next){
            current = current.next;
        }
        //找到最后一项将其next赋给node以建立链接
        current.next =  node;
    }
};

var ll = new LinkedList();
ll.append(15);
ll.append(10);

向为空的链表添加一个元素

向不为空的链表追加元素

从链表中移除元素

场景

• 移除第一个元素
• 移除第一个以外的任一元素

方法

• removeAt() 根据给定位置移除一个元素
• remove() 根据元素的值移除元素

/*根据给定位置移除某一元素*/
this.removeAt = function(position){
    //检查越界值
    if(position>-1 && position<length){
        var current = head;
        //判断是否为首项
        if(position===0){
            head = current.next;
        }else{
            var index = 0;
            var previous;
            while(index++ < position){
                previous = current;
                current = current.next;
            }
            //将previous和current的下一项链接起来，跳过current从而移除它。
            previous.next = current.next;
        }
        length--;
        return current.element;
    }else{
        return null;
    }
};

从链表中移除第一个元素

从链表中移除最后一个元素

从链表中移除中间某一元素

在任意位置插入元素

场景

• 在链表的起点添加元素，即第一个位置。
• 在链表中间或尾部添加元素

/*在任意位置插入一个元素*/
this.insert = function(position,element){
    //检查越界值
    if(position>=0 && position<=length){
        var node = new Node(element);
        var current = head;
        //在首位添加
        if(position==0){
            node.next = current;
            head = node;
        }else{
            var index = 0;
            var previous;
            while(index++ < position){
                previous = current;
                current = current.next;
            }
            node.next = current;
            previous.next = node;
        }
        length++;//更新链表长度
        return true;
    }else{
        return false;
    }
};

在列表起点添加元素

在列表尾部添加元素

在列表中间添加元素

其他辅助方法

this.isEmpty = function(){
    return length===0;
};
this.size = function(){
    return length;
};
this.getHead = function(){
    return head;
};
/*接收元素的值获取元素所在位置，若无则返回-1.*/
this.indexOf = function(element){
    var index = -1;
    var current = head;
    while(current){
        if(element === current.element){
            return index;
        }
        index++;
        current = current.next;
    }
    return -1;
};
this.remove = function(element){
    var index = this.indexOf(element);
    return this.removeAt(index);
};
/*将链表对象转换成一个字符串*/
this.toString = function(){
    var string = '';
    var current = head;
    while(current){
        string = current.element;
        current = current.next;
    }
    return string;
};