JavaScript的数据结构与算法（三） —— 单向链表

链表

链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本事的节点和一个指向下一个元素的引用组成。相对于传统的数组，链表的一个好处在于，添加或者删除元素的时候不需要移动其他元素。
使用链表结构可以克服数组需要预先知道数据大小的缺点(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;
    }
}