JavaScript数据结构与算法(六) 链表的实现

// 链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个
// 元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。下图展
// 示了一个链表的结构：

// 相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。然
// 而，链表需要使用指针，因此实现链表时需要额外注意。数组的另一个细节是可以直接访问任何
// 位置的任何元素，而要想访问链表中间的一个元素，需要从起点（表头）开始迭代列表直到找到
// 所需的元素。

// 链表应用场景 火车车厢、寻宝游戏

TypeScript方式实现源码

class Node {
    element;
    next;
    constructor(element) {
        this.element = element;
        this.next = null;
    }
}
class LinkedList {
    private length = 0;
    head = null;

    constructor() {
    }
    /**
     * 向列表尾部添加一个新的项
     * @param element 
     */
    public append(element) {
        let node = new Node(element), current;

        if (this.head === null) {
            this.head = node;
        } else {
            current = this.head;

            // 循环列表，知道找到最后一项
            while (current.next) {
                current = current.next;
            }

            // 找到最后一项，将其next赋为node，建立链接
            current.next = node;
        }
        this.length++; // 更新列表长度
    }
    /**
     * 向列表的特定位置插入一个新的项
     * @param position 
     * @param element 
     */
    public insert(position, element) {
        // 检查越界值
        if (position >= 0 && position <= length) {
            let node = new Node(element),
                current = this.head,
                previous,
                index = 0;

            if (position === 0) { // 在第一个位置添加
                node.next = current;
                this.head = node;
            } else {
                while (index++ < position) {
                    previous = current;
                    current = current.next;
                }
                node.next = current;
                previous.next = node;
            }
            this.length++; // 更新列表长度
            return true;
        } else {
            return false;
        }
    }
    /**
     * 从列表的特定位置移除一项
     * @param position 
     */
    public removeAt(position) {
        // 检查越界值
        if (position > -1 && position < this.length) {
            let current = this.head,
                previous,
                index = 0;

            // 移除第一项
            if (position === 0) {
                this.head = current.next;
            } else {
                while (index++ < position) {
                    previous = current;
                    current = current.next;
                }
                // 将previous与current的下一项链接起来：跳过current，从而移除它
                previous.next = current.next;
            }
            this.length--;
            return current.element;
        } else {
            return null;
        }
    }
    /**
     * 从列表中移除一项
     * @param element 
     */
    public remove(element) {
        let index = this.indexOf(element);
        return this.removeAt(index);
    }
    /**
     * ：返回元素在列表中的索引。如果列表中没有该元素则返回-1
     * @param element 
     */
    public indexOf(element) {
        let current = this.head,
            index = -1;

        while (current) {
            if (element === current.element) {
                return index;
            }
            index++;
            current = current.next;
        }
        return -1;
    }
    /**
     * 如果链表中不包含任何元素， 返回true， 如果链表长度大于0则返回false
     */
    public isEmpty() {
        return this.length === 0;
    }
    /**
     * 返回链表包含的元素个数。与数组的length属性类似
     */
    public size() {
        return this.length;
    }
    /**
     * 由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值
     */
    public toString() {
        let current = this.head,
            string = '';

        while (current) {
            string += current.element;
            current = current.next;
        }
        return string;
    }
    public getHead() {
        return this.head;
    }
    public print() {
        console.log(this.toString());
    }
}

// 代码解读：
    // 充分利用引用对象特性,将需要管理的数据加入链表的数据结构中,
    // 完全不依赖系统数组的数据结构,所以避免大量删、增数据数组排序的性能损耗。同时也失去了数组下标取数据的优势。
    // 因此优势劣势非常明显,大量改删数据场景选用链表,大量已知下标去更新数据选用数组

// 抽象：
    // 火车车厢可长可短,随时加入或去掉一节车厢仅仅对操作车厢前后一节有改动,当车厢非常长的时候,这个优势尤为明显,
    // 这仅仅是一种应用场景也可以通过火车的例子去理解这种数据结构的设计理念

// 总结：
    // 链表以引用作为媒介,将大量不相干的数据进行一个有序的链接,同时没有复杂的关联关系,仅仅关系操作数据前后关联数据
    // 面对大量增加删除的场景,链表将是比数组更好的选择

JavaScript方式实现源码

var Node = (function () {
    function Node(element) {
        this.element = element;
        this.next = null;
    }
    return Node;
}());
var LinkedList = (function () {
    function LinkedList() {
        this.length = 0;
        this.head = null;
    }
    /**
     * 向列表尾部添加一个新的项
     * @param element
     */
    LinkedList.prototype.append = function (element) {
        var node = new Node(element), current;
        if (this.head === null) {
            this.head = node;
        }
        else {
            current = this.head;
            // 循环列表，知道找到最后一项
            while (current.next) {
                current = current.next;
            }
            // 找到最后一项，将其next赋为node，建立链接
            current.next = node;
        }
        this.length++; // 更新列表长度
    };
    /**
     * 向列表的特定位置插入一个新的项
     * @param position
     * @param element
     */
    LinkedList.prototype.insert = function (position, element) {
        // 检查越界值
        if (position >= 0 && position <= length) {
            var node = new Node(element), current = this.head, previous = void 0, index = 0;
            if (position === 0) {
                node.next = current;
                this.head = node;
            }
            else {
                while (index++ < position) {
                    previous = current;
                    current = current.next;
                }
                node.next = current;
                previous.next = node;
            }
            this.length++; // 更新列表长度
            return true;
        }
        else {
            return false;
        }
    };
    /**
     * 从列表的特定位置移除一项
     * @param position
     */
    LinkedList.prototype.removeAt = function (position) {
        // 检查越界值
        if (position > -1 && position < this.length) {
            var current = this.head, previous = void 0, index = 0;
            // 移除第一项
            if (position === 0) {
                this.head = current.next;
            }
            else {
                while (index++ < position) {
                    previous = current;
                    current = current.next;
                }
                // 将previous与current的下一项链接起来：跳过current，从而移除它
                previous.next = current.next;
            }
            this.length--;
            return current.element;
        }
        else {
            return null;
        }
    };
    /**
     * 从列表中移除一项
     * @param element
     */
    LinkedList.prototype.remove = function (element) {
        var index = this.indexOf(element);
        return this.removeAt(index);
    };
    /**
     * ：返回元素在列表中的索引。如果列表中没有该元素则返回-1
     * @param element
     */
    LinkedList.prototype.indexOf = function (element) {
        var current = this.head, index = -1;
        while (current) {
            if (element === current.element) {
                return index;
            }
            index++;
            current = current.next;
        }
        return -1;
    };
    /**
     * 如果链表中不包含任何元素， 返回true， 如果链表长度大于0则返回false
     */
    LinkedList.prototype.isEmpty = function () {
        return this.length === 0;
    };
    /**
     * 返回链表包含的元素个数。与数组的length属性类似
     */
    LinkedList.prototype.size = function () {
        return this.length;
    };
    /**
     * 由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值
     */
    LinkedList.prototype.toString = function () {
        var current = this.head, string = '';
        while (current) {
            string += current.element;
            current = current.next;
        }
        return string;
    };
    LinkedList.prototype.getHead = function () {
        return this.head;
    };
    LinkedList.prototype.print = function () {
        console.log(this.toString());
    };
    return LinkedList;
}());