链表--单向链表的基本方法

首先，我们来思考，为什么要使用链表？

相对于数组来说：
优点： 通过索引(数组下标)可以很快地访问数组元素；
缺点：插入/删除元素需要对数组进行调整, 效率低；
而链表：
优点：插入/删除速度很快，而且不用对整个链表进行调整；
缺点：只能进行顺序访问，不能随机访问（像数组一样用下标）；

所以，链表在一些需要快速插入／删除，而不太关心或者不需要随机访问的情况下使用。

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

单向链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始，接下来，我们便来看看单向链表的一些基本方法：

1、在使用链表时，我们第一步是要创建节点，因此，我们需要创建Node类：

Node类包含了两个属性，element保存节点上的数据，next指向下一个节点。

function Node(element) {
    this.element = element;
    this.next = null;
}

2、创建LinkedList类

在这个类中，定义了查找、删除、插入、遍历等多种方法。该链表也有一个属性，那就是使用Node对象保存链表的头结点。

function LList() {
     this.head = new Node("head");
     this.find = find;
     this.insert = insert;
     this.remove = remove;
     this.display = display;
}

3、查找最后的节点

这个应该是不难理解的，将buffer定义为头结点，如果它的下一个节点不为空，那么就将下一个节点赋值给当前节点，即buffer=buffer.next，如此循环，直到它的下一个节点为空。下一个节点为空，说明它的后面已经没有节点了，那么，此时的buffer就是最后一个节点。

this.findLast=function () {
     var buffer= this.head;
     while(buffer.next!=null){
           buffer=buffer.next;
      }
     return buffer;
}

4、插入节点

在链表中插入节点，如果没有什么特殊的要求，一般是插在链表末尾的。因此，我们需要先创建一个新的节点，通过之前定义的findLast（）方法，找到链表中的最后节点，让链表中的最后节点的下一个节点指向我们新创建的节点。

this.insert=function (data) {
    //1,创建新的节点
    var buffer = new Node(data);
    //2,获得最后的节点
    var last = this.findLast();
    //3,把最后节点的next指向新节点
    last.next=buffer;
}

5、查找节点

首先，将buffer定义为头结点，如果buffer不为空，那么就需要比较buffer里面的元素即buffer.element是否和我所需要查找的data是否相等，如果相等，很明显，此时的buffer就是我要找的数据，返回buffer；如果不相等，我就需要查找下一个值，因此，把buffer的下一个节点赋值给buffer，继续比较buffer.element是否和data相等。

举个简单的例子，链表中的数据有：head   1     2     3      4

现在我要找数据3，buffer为头结点并且不为空，然后判断buffer节点的元素是否和3相等，很明显，此时的它们是不相等的，那么就需要将buffer的下一个节点即1赋值给buffer，此时，再来判断它和3是否相等，以此循环，直到出现和3相等的数据，返回buffer。当然，如果没有这个数据，就没有返回值。

 this.find=function (data) {
            var buffer= this.head;
            while(buffer!=null){
                if(buffer.element==data){
                    return buffer;
                }
                buffer=buffer.next;
            }
            return buffer;
        }

6、查找当前节点的前一个节点

同上面的查找方法类似，不同之处在于，下面的这个方法是查找当前节点的前一个节点，那么，循环条件就要做出相应的改变。buffer的下一个节点不能为空，试想，若是下一个节点为空，我怎么查找它的前一个节点呢，我查这个节点还有意义吗？

比如说，链表中有：head    1     2     3      4

现在我需要查找3的前一个节点，很显然，我们最后输出的结果应该是2，对吧？

首先，这个数据是满足循环条件的：

buffer的下一个节点是1并且不为空，1和我们要找的数据3不相等，所以，我需要把buffer的下一个节点1赋值给buffer，即buffer=buffer.next，buffer节点为1； 

buffer的下一个节点是2并且不为空，2和我们要找的数据3不相等，所以，把buffer的下一个节点2赋值给buffer，buffer节点为2；

buffer的下一个节点是3并且不为空，3和我们要找的数据3相等，所以节点等于buffer，此时buffer为2，返回节点，得到结果。

this.findPrevious=function (data) {
            var buffer= this.head;
            var node=null;
            while(buffer!=null&&buffer.next!=null){
                if(buffer.next.element==data){
                    node=buffer;
                    return node;
                }
                buffer=buffer.next;
            }
            return node;
        }

7、删除当前节点

这个就很简单了，要删除一个节点，我们无非就是想把当前节点去掉，让当前节点的前一个节点和它的后一个节点连接起来，对吧？所以，只需要获得当前节点的前一个节点和它的后一个节点，让前一个的节点的下一个节点指向当前节点的后一个节点就OK啦，即preNode.next=nextNode。

this.remove=function (data) {
            let nextNode =this.find(data).next;
            let preNode = this.findPrevious(data);
            preNode.next=nextNode;
        }

8、在after之后插入节点

在指定位置插入节点，其中，element表示要插入的节点，after表示在当前位置的后面插入节点。

还是这个例子好了，链表中的数据：head    1      2      3      4

现在，我想在3之后插入一个节点5，是不是表示我的element=5，after=3，我最后得到的结果应该是：head    1    2    3    5    4

其实，主要就是找到after的节点位置，即我们这里的3的位置，然后让5的下一个节点指向3的下一个节点，3的下一个节点指向5的节点。

this.insertAfter=function (element,after) {
            //1,创建当前的节点
            let node = new Node(element);
            //2，获得after节点
            let afterNode= this.find(after);
            //3, afterNode的后面节点和当前节点链接在一起
            node.next=afterNode.next;
            //4，把当前节点连在afterNode节点后面
            afterNode.next=node;
        }

9、在before之前插入节点

这个就和上面的在after之后插入节点很相似了，这里就不再多说了。

this.insertBefore=function (element,before) {
            //创建当前的节点
            let node = new Node(element);
            //获得before节点的前一个节点
            let preNode= this.findPrevious(before);
            //把before节点连到新节点的后面
            node.next=preNode.next;
            //把preNode节点和新节点连到一起
            preNode.next=node;
        }

10、当前节点向前移动n个节点

currElement表示的是当前节点，n表示向前移动多少个节点。

buffer表示的是当前节点的前一个节点，至于循环条件，我们对n只是要求其大于0，那么，它就有可能使得先前移动的节点大于了我当前节点前面节点的个数，这个时候，第二个条件preNode.element！='head'就显现出它的价值了，我根本就不会进循环好吗？在之前，我把buffer赋值给了preNode，所以它现在的值就是我当前节点的前一个节点。

算了，我们还是来说个实例，链表中的数据：head    1    2     3     4       5

现在我要将4往前移动2个节点，即currElement=4，n=2，最后的结果应该是：head    1    4    2    3    5，接下来一起来看看是怎么实现的？

当前节点currentNode为4，buffer是当前节点的前一个节点，当前节点是4，那么它的前一个节点，很显然是3，preNode此时的值也为3；

当前的preNode的元素是3，不等于head，且此时的n=2>0，满足循环条件，这个时候preNode就开始发生变化了，此时它的值为preNode的前一个节点，即3的前一个节点2，proNode=2，n=1；

当前的preNode已经变为2，同样满足while循环，将preNode的前一个节点赋值给proNode，即2的前一个节点1，proNode为1，n=0；

现在，我们的条件已经不再满足while循环了，我们最终得到的preNode是1。当currentNode往前移动n个节点后，需要将它的前一个节点和后一个节点连接起来。所以，在这里，我们需要将3和5连接起来，即buffer.next=currentNode.next，然后，就该考虑4的位置了，之前我们获得的preNode其实就是currentNode的前一个节点。所以，我们需要让currentNode的下一个节点等于proNode的下一节点，即currentNode.next=preNode.next，也就是4的下一个节点等于原本1指向的下一个节点。preNode的下一个节点指向的当然就是当前节点啦，即1的下一个节点就是当前节点4，到此，一切就都完美了！

this.advance=function (currElement,n){
            var currentNode = this.find(currElement);//4
            var buffer = this.findPrevious(currElement);//3
            var preNode = buffer;
            while(preNode.element!='head'&&n>0){
                preNode = this.findPrevious(preNode.element);
                n--;
            }
            buffer.next=currentNode.next;//3和5连接
            currentNode.next=preNode.next;
            preNode.next=currentNode;
        }

11、当前节点向后移动n个节点

嘿嘿，这个又是和上面差不多的啦，重复的地方相信就不用多说了，我们来看看不同点，最明显的就是之前的那个是向前移动的，这个是向后移动的，对吧？

好了，开个玩笑，说正事，向后移动首先要注意的第一点是循环条件的不同，我往前移动，最前面的是head头结点，当我当前节点等于头结点时，我就不能继续往前移动了；那我往后移动，移动到哪里就不能移动了呢？是不是移动到最后一个节点就不能继续移动了，那么，如何判断我是不是移动到最后一个节点呢？是不是只要我节点的下一个节点为空，就说明我当前节点是最后一个节点，很显然，就是这样的。如果到了最后一个节点，我就已经没有循环的必要了，本来就是最后一个了，还能移到哪去？

this.back=function (currElement,n){
            //获得当前节点
            var currentNode = this.find(currElement);
            //假设当前节点为最后节点
            var lastNode = currentNode;
            //在n>0的条件下，下一个节点为空的时候停下来
            while(lastNode.next!=null&&n>0){
                lastNode = lastNode.next;
                n--;
            }
            //currentNode节点和lastNode相等，说明currentNode本身就是最后的节点
            if(currentNode==lastNode){
                return;
            }
            //当前节点的前一个节点和当前节点的后一个节点连接在一起
            var currentPre=this.findPrevious(currElement);
            currentPre.next = currentNode.next;
            //把当前节点连在lastNode节点后面
            currentNode.next=lastNode.next;
            lastNode.next=currentNode;
        }

12、遍历链表

其实，这个方法主要就是将链表里的数据遍历出来。

this.forEach=function (call) {
            var buffer= this.head;
            while(buffer!=null){
                call(buffer);
                buffer=buffer.next;
            }
        }