• 链表存储有序的元素鸠合，不同于数组，链表中的元素在内存中并非一连安排，每一个元素有一个存取元素自身的节点和一个指向下一个元素的援用构成。

长处：增加或许移除元素的时刻不须要挪动其他元素。只须要找到到场的节点，断开并插进去一个元素（修正援用）

function LinkedList() {
    let Node = function (element) {// 辅佐类，包括一个element属性即详细的值，以及一个next属性即指向下一个节点的援用
        this.element = element;
        this.next = null;
    };
    let length = 0;
    let head = null;
    /**
     * 向列表尾部增加一个新的项
     * @param element
     */
    this.append = function (element) {
        let node = new Node(element), current;
        if (head === null) {
            head = node;
        } else {
            current = head;
            // 轮回列表找到末了一项
            while (current.next) {
                current = current.next
            }
            // 将末了一项的援用指向新元素（将末了一项的next指向node，建立新衔接）
            current.next = node;
        }
        length++;// 更新列表的长度
    };
    /**
     * 向列表的特定位置插进去一个新的项
     * @param position
     * @param element
     */
    this.insert = function (position, element) {
        if (position > -1 && position < length) {
            let node = new Node(element);
            let current = head, previous, index = 0;
            if (position === 0) {
                head = node;
                node.next = current
            } else {
                while (index++ < position) {
                    previous = current;
                    current = current.next
                }
                previous.next = node;
                node.next = current
            }
            length++;
            return true
        } else {
            return false
        }
    };
    /**
     * 从列表的特定位置移出一项
     * @param position
     */
    this.removeAt = function (position) {
        // 搜检越界值
        if (position > -1 && position < length) {// 考证该位置是不是有用
            // current是对要移出元素的援用
            // previous是对要移出的元素前一个元素的援用
            let current = head, index = 0, previous;
            // 移出第一项
            if (position === 0) {
                head = current.next;
            } else {
                while (index++ < position) {
                    previous = current;
                    current = current.next
                }
                // 将previous与current的下一项链接起来：如许跳过current，从而完成移出，渣滓网络
                previous.next = current.next
            }
            length--;
            return current.element
        } else {
            return null
        }
    };
    /**
     * 从列表移出一项
     * @param element
     */
    this.remove = function (element) {
        
    };
    /**
     * 返回元素在列表中的索引
     * @param element
     */
    this.indexOf = function (element) {
        let current = head, index = 0;
        while(current){
            if(element === current.element){// 剖断前提须要优化，关于运用范例要剖断值相称
                return index;
            }
            index++;
            current = current.next
        }
        return -1
    };
    this.isEmpty = function () {
    };
    this.size = function () {
    };
    this.getHead = function () {
    };
    /**
     * 因为运用Node辅佐类，所以要重写继续自默许对象的toString要领
     */
    this.toString = function () {
        let current = head, string = '';
        while (current) {
            string += current.element + (current.next ? 'n' : '');
            current = current.next
        }
        return string
    };
    this.print = function () {
    }
}

• 双向链表
• 轮回链表