链表

链表

链表存储有序的元素集合,链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素额引用组成。
相对于传统的数组,链表的一个好处在于,添加或移除元素的时候不需要移动其他元素。 数组的另一个细节是可以直接访问任何位置的任何元素，而想要访问链表中间的元素需要从表头开始迭代列表直到找到所需元素。

/**
	创建一个包含以下方法的链表类
		append(element) : 向链表尾部添加新项
       	insert(position,element) : 向列表的特定位置插入一个新的项
        removeAt(position) : 从链表特定的位置移除一项
       	remove(element) : 从链表中移除一项
        indexOf(element) : 返回元素在列表中的索引,如果列表中没有该元素则返回-1
        isEmpty() : 如果链表中不含任何元素则返回true,否则返回false
       	size() : 返回链表中包含的元素的个数
        toString() : 输出链表中每个节点的内容
**/
function LinkList() {
    let Node = function (element) {
        this.element = element;
        this.next = null;
    }
    let length = 0;
    let head = null;

    this.append = function (element) {
        let newNode = new Node(element);
        if (head === null) {
            head = newNode;
        } else {
            let current = head;
            while (current.next) {
                current = current.next;
            }
            current.next = newNode;
        }
        length++;
    };

    this.insert = function (position, element) {
        let newNode = new Node(element),
            current = head,
            index = 0,
            previous = null;
        if (position >= 0 && position <= length) {
            if (position == 0) {
                newNode.next = current;
                head = newNode;
            } else {
                while (index++ < position) {
                    previous = current;
                    current = current.next;
                }
                newNode.next = current;
                previous.next = newNode;
            }
            length++;
            return true;
        }
        return false;
    }

    this.removeAt = function (position) {
        let current = head,
            index = 0,
            previous = null;
        if (position >= 0 && position <= length) {
            if (position == 0) {
                head = current.next;
            } else {
                while (index++ < position) {
                    previous = current;
                    current = current.next;
                }
                previous.next = current.next;
            }
            length--;
            return current.element;
        }
        return null;
    };

    this.indexOf = function (element) {
        let index = 0,
            current = head;
        while (current && current.element !== element) {
            index++;
            current = current.next;
        }
        if (index > length - 1) {
            return -1;
        }
        return index;
    };

    this.remove = function (element) {
        let index = this.indexOf(element);
        return this.removeAt(index, element);
    };

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

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

    this.toString = function () {
        let eleArr = [],
            current = head;
        while (current) {
            eleArr.push(current.element);
            current = current.next;
        }
        return eleArr.toString();
    }
}

let linkList = new LinkList();
linkList.append('Jack');
linkList.append('Nancy');
linkList.insert(1, 'Rose');
linkList.append('Cindy');
console.log('toString:', linkList.toString());      //toString: Jack,Rose,Nancy,Cindy
linkList.removeAt(1);
console.log('toString:', linkList.toString());      //toString: Jack,Nancy,Cindy
console.log('size:', linkList.size());              //size: 3
console.log('indexOf:', linkList.indexOf('Nancy')); //indexOf: 1
linkList.remove('Nancy');
console.log('toString:', linkList.toString());      //toString: Jack,Cindy
console.log('size:', linkList.size());              //size: 2

双向链表

双向链表与普通链表的区别在于，在链表中，一个节点只有链向下一个节点的链接，而在双向链表中，链接是双向的，一个链向下一个元素，一个链向上一个元素。

function DoubleLinkedList() {
    let Node = function (element) {
        this.element = element;
        this.next = null;
        this.prev = null;
    }
    let length = 0;
    let head = null;
    let tail = null;

    this.insert = function (position, element) {
        let newNode = new Node(element),
            current = head,
            index = 0,
            previous = null;

        if (position >= 0 && position <= length) {
            if (position === 0) {
                if (!head) {
                    head = newNode;
                    tail = newNode;
                } else {
                    newNode.next = current;
                    current.prev = newNode;
                    head = newNode;
                }
            } else if (position === length) {
                current = tail;
                current.next = newNode;
                newNode.prev = current;
                tail = newNode;
            } else {
                while (index++ < position) {
                    previous = current;
                    current = current.next;
                }
                previous.next = newNode;
                newNode.next = current;

                current.prev = newNode;
                newNode.prev = previous;
            }
            length++;
            return true;
        }
        return false;
    }
    this.removeAt = function (position) {
        let previous = null,
            current = head,
            index = 0;
        if (position >= 0 && position < length) {
            if (position === 0) {
                head = current.next;
                //如果只有一项,更新tail
                if (length === 1) {
                    tail = null;
                } else {
                    head.prev = null;
                }
            } else if (position === length - 1) {
                current = tail;
                tail = current.prev;
                tail.next = null;
            } else {
                while (index++ < position) {
                    previous = current;
                    current = current.next;
                }
                previous.next = current.next;
                current.next.prev = previous;
            }
            length--;
            return current.element;
        }
        return null;
    }
    this.toString = function () {
        let eleArr = [],
            current = head;
        while (current) {
            eleArr.push(current.element);
            current = current.next;
        }
        return eleArr.toString();
    }
}

let dbLinkedList = new DoubleLinkedList();
dbLinkedList.insert(0, 'a');
dbLinkedList.insert(1, 'b');
dbLinkedList.insert(1, 'c');
console.log(dbLinkedList.toString());   //a,c,b
console.log(dbLinkedList.removeAt(1));  //c
console.log(dbLinkedList.toString());   //a,b

循环链表

循环链表可以有单向引用，也可以像双向链表一样有双向引用。循环链表的最后一个元素指向下一个元素的指针(tail.next)不是null，而是指向第一个元素。