js实现数据结构--单链表

单链表的概念：

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用(也称指针或链接)组成。下图展示了一个单链表的结构图：

单链表的特点：

1. 每个元素除了由元素本身的节点还有指向下一个元素的指针构成
2. 从链表中添加或者删除元素不需要移动其他的元素
3. 访问链表中间的一个元素，需要从表头开始迭代列表直到找到所需的元素

生活中单链表的案例：

生活中的单链表很典型也很常见。例如寻宝游戏，你有一条线索，这条线索是指向寻找下一条线索的地点的指针，你可以顺着这条链接去下一个地方，得到另一条指向下一处的线索，如果想得到列表中间的线索的唯一办法就是从起点(第一条线索)顺着列表寻找。另一个案例就是火车，还有其他的案例这里就不一一列举了。

js定义单链表以及一些基本方法：

首先创建一个类似于类的结构定义单链表，声明一些基本的属性，代码如下：

//定义单链表
    function LinkedList() {
        let Node = function (element) {
            this.element =element;
            this.next = null;
        }
        let length = 0;
        let head = null;

同时在该类中定义并声明单链表的一些基本方法，代码如下：

 //向列表尾部添加一个新的项
        this.appendNode =  function (element) {
            let node = new Node(element);
            let current;//current变量是对列表中第一个元素的引用
            if (head === null){
                head = node;
            } else {
                current = head;
                //循环列表，直到找到最后一项
                while (current.next){
                    current = current.next;
                }
                //找到最后一项，将其next赋为node，建立链接
                current.next = node;
            }
            length++;//更新列表的长度
        } ;


        //向列表的特定位置插入一个新的项
        this.insertNode =  function (pos,ele) {
            if(pos > -1 && pos <= length){
                let node = new Node(ele),
                    index = 0,
                    current = head,//current变量是对列表中第一个元素的引用
                    previous;
                if (pos === 0) {//在列表的起点添加元素
                    node.next = head;
                    head = node;
                }else{//在列表的中间或者尾部添加一个元素
                    while(index++ < pos){
                        //循环访问列表，找到目标位置
                        previous = current;
                        current = current.next;
                    }
                    //找到位置后,current就是对想要插入新元素的位置之后一个元素的引用
                    //previous是对想要插入新元素的位置之前一个元素的引用
                    previous.next = node;
                    node.next = current;
                };
                length++;
                return true;
            }else{
                return false;
            }
        };


        //移除列表某位置的元素
        this.removeAt =  function (pos){
            //检查越界值
            if (pos >-1 && pos < length){
                let current = head,
                    //current 是对列表中第一个元素的引用
                    previous, index = 0;
                //第一种情况，移除第一项
                if (pos === 0){
                    head = current.next;
                } else {
                    while (index++ <pos){
                        previous = current;
                        current = current.next;
                    }
                    //将previous与current的下一项链接起来，跳过current，从而移除它
                    previous.next = current.next;
                }
                length--;
                return current.element;
            } else {
                return null;
            }

        } ;


       //返回某个元素在列表中的索引，指定元素下标从-1开始
        this.indexOf =function (ele){
            let current = head ,
                index = -1;
            while (current){
                if (ele === current.element){
                     return index;
                }
                index++;
                current = current.next;
            }
            return -1;
        };


        //从列表中移除某个元素
        this.remove =  function (element) {
            var current = head,
                previous,
                indexCheck = 0;
            while (current && indexCheck < length) {
                if (current.element === element) {
                    if (indexCheck == 0) {
                        head = current.next;
                        length--;
                        return true;
                    } else {
                        previous.next = current.next;
                        length--;
                        return true;
                    }
                } else {
                    previous = current;
                    current = current.next;
                    indexCheck++;
                }
            }
            return false;
        }


        //另一种移除指定位置的元素的方法
         this.remove = function (element){
           let index = this.indexOf(element);
               return this.removeAt(index);
        }



        //判断列表是否为空，没有元素
        this.isEmpty = function  () {
            return length === 0;
        } ;


        //返回链表包含的元素个数
        this.size =  function  () {
            return length;
        };


        //输出链表元素的值
        this.toString =  function  (){
            let current = head,
                string = '',
                indexCheck = 0;
            while (current && indexCheck < length){
                string += current.element +((current.next ? '-':''));
                current = current.next;
                indexCheck++;
            }
            return string;
        }
        //反转单链表
        this.reverse = function () {
            var headNode = this.head;
            if (headNode === null || headNode.next === null) {
                return;
            }
            var p = headNode, q = p.next;
            while (q) {
                var r = q.next;
                q.next = p;
                p = q;
                q = r;
            }
            headNode = p;
        }
}

使用单链表：

首先定义一个单链表，并向链表添加两个元素，代码如下：

 let list = new LinkedList();
    //向链表的尾部添加两个元素
    list.appendNode(15);
    list.appendNode(10);

调用声明的方法，查看结果，代码如下：

console.log("链表目前所有的元素构成的字符串为："+list.toString());//输出15-10
console.log("链表中的元素个数是："+ list.size());//输出2
console.log(list.isEmpty());//判断链表是否为空，false

调用其他的方法，如查看元素索引，在指定位置插入元素，移除元素，代码如下：

console.log('元素10在链表中的索引是：'+list.indexOf(10));//输出0
list.appendNode(20);
//向链表的index为1的位置添加一个元素
console.log(list.insertNode(1,'33'));//输出true
//删除链表某个位置的元素
console.log(list.removeAt(0));//输出15
//删除某个特定的元素
console.log(list.remove(10));//输出true