摘要：鏈表鏈表存儲有序的元素集合，但不同于數組，鏈表中的元素在內存中并不是連續放置的。相對于傳統的數組，鏈表的一個好處在于，添加或者刪除元素的時候不需要移動其他元素。

鏈表存儲有序的元素集合，但不同于數組，鏈表中的元素在內存中并不是連續放置的。每個元素由一個存儲元素本事的節點和一個指向下一個元素的引用組成。相對于傳統的數組，鏈表的一個好處在于，添加或者刪除元素的時候不需要移動其他元素。
使用鏈表結構可以克服數組需要預先知道數據大小的缺點(C語言的數組需要預先定義長度)，鏈表結構可以充分利用計算機內存空間，實現靈活的內存動態管理。

數組和鏈表的一個不同在于數組可以直接訪問任何位置的元素，而想要訪問鏈表中的一個元素，需要從起點開始迭代列表。

鏈表又包括：單向鏈表 和 雙向鏈表；

鏈表中最簡單的形式就是單向鏈表，鏈表中的節點都包含兩個部分，第一部分儲存著自身信息，第二部分則儲存有指向下一節點的指針。最后一個節點則指向NULL，如圖所示:

讓我們來簡單實現一個單向鏈表類，并包含如下功能：

append(element): 添加元素到鏈表尾部

insert(position,element): 向單向鏈表中某個位置插入元素

indexOf(element): 尋找某個元素在單向鏈表中的位置

remove(element): 移除給定的元素

removeAt(position): 移除單向鏈表中某個位置的元素

getHead(): 獲取單向鏈表的頭部

isEmpty(): 檢查單向鏈表是否為空，為空則返回true

toString(): 將鏈表所有內容以字符串輸出

size(): 返回單向鏈表長度

代碼如下：

 function LinkedList() {
    /**
     * 單向鏈表節點的構造函數
     * 
     * @param {any} element 要傳入鏈表的節點
     */
    var Node = function (element) {
        this.element = element;
        this.next = null;
    }
    // 單向鏈表的長度
    var length = 0;
    // 單向鏈表的頭節點，初始化為null
    var head = null;


    /**
     * 添加元素到鏈表尾部
     * 
     * @param {any} element 要傳入鏈表的節點
     */
    this.append = function(element) {
        var node = new Node(element),
            current;

        if (head === null) {
            head = node
        } else {
            current = head;
            // 當next為null時,退出循環
            while (current.next) {
                current = current.next;
            }
            current.next = node;
        }
        length++;
    }

    /**
     * 向單向鏈表中某個位置插入元素
     * 
     * @param {any} position 位置
     * @param {any} element 要傳入鏈表的節點
     */
    this.insert = function (position, element) {
        var node = new Node(element),
            current = head,
            previous,
            index;
        // 驗證邊界
        if (position < 0 || position >= length) {
            return false;
        }
        // 在鏈表頭部插入
        if (position === 0) {
            node.next = current；
            head = node；
        } else {
            // 在鏈表除頭部之外的地方插入（中間 or 末尾）
            while (index++ < position) {
                previous = current
                current = current.next
            }
            // 在前一個節點和當前節點中間插入
            node.next = current;
            previous.next = node;
        }
        length++;
        return true;
    }

    
    /**
     * 尋找某個元素在單向鏈表中的位置
     * 
     * @param {any} element 要尋找的節點
     * @returns {Number} 返回值>=0則代表找到相應位置
     */
    this.indexOf = function (element) {
        var index = 0,
            current = head;

        while (current) {
            if (element === current.element) {
                return index
            }
            index++;
            current = current.next;
        }
        // 如果鏈表中不存該元素，返回-1
        return -1;
    }

    /**
     * 移除單向鏈表中某個位置的元素
     * 
     * @param {any} position 要移除的位置
     */
    this.removeAt = function (position) {
        var index = 0,
            previous,
            current = head;
        if (position < 0 || position >= length) {
            return null;
        }

        if (position === 0) {
            head = head.next;
        } else {
            while (index++ < position) {
                previous = current;
                current = current.next;
            }
            previous.next = current.next;
        }
        length--;
        return current.element;
    }

    /**
     * 移除給定的元素
     * 
     * @param {any} element 要移除的節點
     * @returns 
     */
    this.remove = function (element) {
        var index = this.indexOf(element);
        return this.removeAt(index)
    }

    /**
     * 獲取單向鏈表的頭部
     * 
     */
    this.getHead = function () {
        return head.element
    }

    /**
     * 檢查單向鏈表是否為空
     * 
     * @returns 為空則返回true
     */
    this.isEmpty = function () {
        return length === 0
    }
    
    /**
     * 返回單向鏈表長度
     * 
     * @returns {Number}
     */
    this.size = function () {
        return length;
    }

    /**
     *  將鏈表所有內容以字符串輸出
     * 
     * @returns {String}
     */
    this.toString = function () {
        var str = "",
            current = head;
        while(current) {
            str += current.element;
            current = current.next;
        }
        return str;
    }
}