JS实现单链表、单循环链表

链表

　　链表是一种物理存储单元上非线性、非连续性的数据结构（它在数据逻辑上是线性的），它的每个节点由两个域组成：数据域和指针域。数据域中存储实际数据，指针域则存储着指针信息，指向链表中的下一个元素或者上一个元素。正是由于指针的存在，链表的存储在物理单元是非连续性的。

链表的优点和缺点同样明显。和线性表相比，链表在添加和删除节点上的效率更高，因为其只需要修改指针信息即可完成操作，而不像线性表（数组）那样需要移动元素。同样的，链表的长度在理论上也是无限的（在存储器容量范围内），并可以动态变化长度，相比线性表优势很大。 相应的，由于线性表无法随机访问节点，只能通过指针顺着链表进行遍历查询来访问，故其访问数据元素的效率比较低。

JS实现单链表

function LinkedList() {
    let Node = function (ele) {
        this.ele = ele;
        this.next = null;
    }

    let length = 0,
        head = null; //头指针

    //向尾部追加元素
    this.append = function (ele) {
        let node = new Node(ele),
            temp; //临时指针

        if (!head) {
            head = node;
        } else {
            temp = head;
            while (temp.next) {
                temp = temp.next
            }
            temp.next = node;
        }
        length++;
        return true;
    }

    //插入到指定位置
    this.insert = function (position, ele) {
        if (position >= 0 && position < length) {
            let node = new Node(ele),
                temp = head,
                index = 0,
                previous;

            if (position == 0) {
                node.next = temp;
                head = node;
            } else {
                while (index++ < position) {
                    previous = temp;
                    temp = temp.next;
                }
                node.next = temp;
                previous.next = node;
            }
            length++;
            return true;
        } else {
            return false;
        }
    }

    //删除指定位置元素
    this.removeAt = function (position) {
        if (position > -1 && position < length) {
            let temp = head,
                previous,
                index = 0;

            if (position == 0) {
                head = head.next;
            } else {
                while (index++ < position) {
                    previous = temp;
                    temp = temp.next;
                }

                previous.next = temp.next;
            }
            length--;
            return temp.ele;
        } else {
            return null;
        }
    }

    //删除所有值为ele的元素
    this.removeEle = function (ele) {
        let temp = head,
            previous,
            num = 0;
        if (ele == temp.ele) {
            head = head.next;
            length--;
            num++;
        }

        while (temp.next) {
            previous = temp;
            temp = temp.next;
            if (temp.ele == ele) {
                previous.next = temp.next;
                length--;
                num++;
            }
        }
        return num;
    }

    //删除最后一个元素
    this.pop = function () {
        let temp = head,
            previous = temp;
        if (length < 1) {
            return false;
        }
        if (length == 1) {
            head = null;
            length--;
            return temp.ele;
        }
        while (temp.next) {
            previous = temp;
            temp = temp.next;
        }
        previous.next = null;
        length--;
        return temp.ele;
    }

    this.indexOf = function (ele) {
        let temp = head,
            index = 0;

        while (temp) {
            if (temp.ele == ele) {
                return index;
            }
            temp = temp.next;
            index++;
        }
        return -1;

    }

    this.toString = function () {
        let temp = head,
            string = '';

        while (temp) {
            string += temp.ele + ' ';
            temp = temp.next;

        }
        return string;
    }
    this.length = function () {
        return length;
    }
    this.isEmpty = function () {
        return length === 0;
    };
    this.getHead = function () {
        return head.ele;
    }
}

let mylist = new LinkedList();
mylist.append('A');
mylist.append('B');
mylist.append('C');
mylist.append('D');
mylist.append('C');
mylist.append('B');
mylist.append('A');
console.log(mylist.toString());
console.log(mylist.pop());
console.log(mylist.toString());
console.log('移除%d个C', mylist.removeEle('C'));
console.log(mylist.toString());
console.log(mylist.length());
console.log(mylist.getHead());

console.log(mylist.indexOf('C'))

JS实现单循环链表：

在单链表的基础上，将尾节点的指针指向头结点，就构成了一个循环链表。环形链表从任意一个节点开始，都可以遍历整个链表。

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

    var length = 0,
        head   = null;  

    this.append = function(element){
        var node = new Node(element),
            current;  

        if (!head) {
            head = node;
            node.next = head;
        }else{
            current = head;  

            while(current.next !== head){
                current = current.next;
            }  

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

        length++;
        return true;
    };  

    this.insert = function(position, element){
        if(position > -1 && position < length){
            var node = new Node(element),
                index = 0,
                current = head,
                previous;  

            if (position === 0) {  

                node.next = head;
                head = node;  

            }else{  

                while(index++ < position){
                    previous = current;
                    current = current.next;
                }  

                previous.next = node;
                node.next = current;  

            };  

            length++;
            return true;
        }else{
            return false;
        }
    };
  //移除指定位置元素
    this.removeAt = function(position){
        if(position > -1 && position < length){
            var current = head,
                previous,
                index = 0;  

            if (position === 0) {  

                head = current.next;  

            }else{  

                while (index++ < position){
                    previous = current;
                    current = current.next;
                }  

                previous.next = current.next;
            };  

            length--;
            return current.element;
        }else{
            return null;
        }
    };
  //移除指定元素
    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(){
        if(length === 0){
            return false;
        }  

        var current = head,
            previous,
            indexCheck = 0;  

        if(length === 1){
            head = null;
            length--;
            return current.element;
        }  

        while(indexCheck++ < length){
            previous = current;
            current = current.next;
        }
        previous.next = head;
        length--;
        return previous.element;  //返回移除的元素
    };  

    this.indexOf = function(element){
        var current = head,
            index = 0;  

        while(current && index < length){
            if(current.element === element){
                return index;
            }else{
                index++;
                current = current.next;
            }
        }
        return false;
    };  

    this.isEmpty = function(){
        return length === 0;
    };  

    this.size = function(){
        return length;
    };  

    this.toString = function(){
        var current = head,
            string = '',
            indexCheck = 0;  

        while(current && indexCheck < length){
            string += current.element;
            current = current.next;
            indexCheck++;
        }  

        return string;
    };     

}  

let mylist=new CircularLinkedList();

mylist.append('A');

mylist.append('B');

mylist.append('C');

mylist.append('D');

console.log(mylist.toString());

console.log(mylist.remove()); //D

console.log(mylist.toString());