【译】JavaScript数据结构（3）：单向链表与双向链表

时间 2019-11-07

标签 javascript 数据结构单向链表双向栏目 JavaScript 繁體版

原文原文链接

翻译：疯狂的技术宅
英文：https://code.tutsplus.com/art...
说明：本文翻译自系列文章《Data Structures With JavaScript》，总共为四篇，原做者是在美国硅谷工做的工程师 Cho S. Kim 。这是本系列的第三篇。javascript

说明：本专栏文章首发于公众号：jingchengyideng 。java

计算机科学中最多见的两种数据结构是单链表和双链表。node

在我学习这些数据结构的时候，曾经问个人同伴在生活中有没有相似的概念。我所听到的例子是购物清单和火车。可是我最终明白了，这些类比是不许确的，购物清单更相似队列，火车则更像是一个数组。数组

随着时间的推移，我终于发现了一个可以准确类比单链表和双向链表的例子：寻宝游戏。若是你对寻宝游戏和链表之间的关系感到好奇，请继续往下读。数据结构

单链表

在计算机科学中，单链表是一种数据结构，保存了一系列连接的节点。每一个节点中包含数据和一个可指向另外一个节点的指针。ide

单链列表的节点很是相似于寻宝游戏中的步骤。每一个步骤都包含一条消息（例如“您已到达法国”）和指向下一步骤的指针（例如“访问这些经纬度坐标”）。当咱们开始对这些单独的步骤进行排序并造成一系列步骤时，就是在玩一个寻宝游戏。函数

如今咱们对单链表有了一个基本的概念，接下来讨论单链表的操做工具

单链表的操做

由于单链表包含节点，这二者的构造函数能够是两个独立的构造函数，因此咱们须要些构造函数：Node 和 SinglyList学习

Node

data 存储数据this
next 指向链表中下一个节点的指针

SinglyList

_length 用于表示链表中的节点数量
head 分配一个节点做为链表的头
add(value) 向链表中添加一个节点
searchNodeAt(position) 找到在列表中指定位置 n 上的节点
remove(position) 删除指定位置的节点

单链表的实现

在实现时，咱们首先定义一个名为Node的构造函数，而后定义一个名为SinglyList的构造函数。

Node 的每一个实例都应该可以存储数据而且可以指向另一个节点。要实现此功能，咱们将分别建立两个属性：data和next。

function Node(data) {
    this.data = data;
    this.next = null;
}

下一步咱们定义SinglyList:

function SinglyList() {
    this._length = 0;
    this.head = null;
}

SinglyList 的每一个实例有两个属性：_length和head。前者保存链表中的节点数，后者指向链表的头部，链表前面的节点。因为新建立的singlylist实例不包含任何节点，因此head的默认值是null，_length的默认值是 0。

单链表的方法

咱们须要定义能够从链表中添加、查找和删除节点的方法。先从添加节点开始。

方法1/3: `add(value)`

太棒了，如今咱们来实现将节点添加到链表的功能。

SinglyList.prototype.add = function(value) {
    var node = new Node(value),
        currentNode = this.head;
 
    // 1st use-case: an empty list 
    if (!currentNode) {
        this.head = node;
        this._length++;
         
        return node;
    }
 
    // 2nd use-case: a non-empty list
    while (currentNode.next) {
        currentNode = currentNode.next;
    }
 
    currentNode.next = node;
 
    this._length++;
     
    return node;
};

把节点添加到链表会涉及不少步骤。先从方法开始。咱们使用add(value)的参数来建立一个节点的新实例，该节点被分配给名为node的变量。咱们还声明了一个名为currentNode的变量，并将其初始化为链表的_head。若是链表中尚未节点，那么head的值为null。

实现了这一点以后，咱们将处理两种状况。

第一种状况考虑将节点添加到空的链表中，若是head没有指向任何节点的话，那么将该node指定为链表的头，同时链表的长度加一，并返回node。

第二种状况考虑将节点添加到飞空链表。咱们进入while循环，在每次循环中，判断currentNode.next是否指向下一个节点。（第一次循环时，CurrentNode指向链表的头部。）

若是答案是否认的，咱们会把currentnode.next指向新添加的节点，并返回node。

若是答案是确定的，就进入while循环。在循环体中，咱们将currentNode从新赋值给currentNode.next。重复这个过程，直到currentNode.next再也不指向任何。换句话说，currentNode指向链表中的最后一个节点。

while循环结束后，使currentnode.next指向新添加的节点，同时_length加1，最后返回node。

方法2/3: `searchNodeAt(position)`

如今咱们能够将节点添加到链表中了，可是尚未办法找到特定位置的节点。下面添加这个功能。建立一个名为searchNodeAt(position) 的方法，它接受一个名为 position 的参数。这个参数是个整数，用来表示链表中的位置n。

SinglyList.prototype.searchNodeAt = function(position) {
    var currentNode = this.head,
        length = this._length,
        count = 1,
        message = {failure: 'Failure: non-existent node in this list.'};
 
    // 1st use-case: an invalid position 
    if (length === 0 || position < 1 || position > length) {
        throw new Error(message.failure);
    }
 
    // 2nd use-case: a valid position 
    while (count < position) {
        currentNode = currentNode.next;
        count++;
    }
 
    return currentNode;
};

在if中检查第一种状况：参数非法。

若是传给searchNodeAt(position)的索引是有效的，那么咱们执行第二种状况 —— while循环。在while的每次循环中，指向头的currentNode被从新指向链表中的下一个节点。

这个循环不断执行，一直到count等于position。

方法3/3: `remove(position)`

最后一个方法是remove(position)。

SinglyList.prototype.remove = function(position) {
    var currentNode = this.head,
        length = this._length,
        count = 0,
        message = {failure: 'Failure: non-existent node in this list.'},
        beforeNodeToDelete = null,
        nodeToDelete = null,
        deletedNode = null;
 
    // 1st use-case: an invalid position
    if (position < 0 || position > length) {
        throw new Error(message.failure);
    }
 
    // 2nd use-case: the first node is removed
    if (position === 1) {
        this.head = currentNode.next;
        deletedNode = currentNode;
        currentNode = null;
        this._length--;
         
        return deletedNode;
    }
 
    // 3rd use-case: any other node is removed
    while (count < position) {
        beforeNodeToDelete = currentNode;
        nodeToDelete = currentNode.next;
        count++;
    }
 
    beforeNodeToDelete.next = nodeToDelete.next;
    deletedNode = nodeToDelete;
    nodeToDelete = null;
    this._length--;
 
    return deletedNode;
};

咱们要实现的remove(position)涉及三种状况：

无效的位置做为参数传递。
第一个位置（链表的的`head）做为参数的传递。
一个合法的位置（不是第一个位置）做为参数的传递。

前两种状况是最简单的处理。关于第一种状况，若是链表为空或传入的位置不存在，则会抛出错误。

第二种状况处理链表中第一个节点的删除，这也是头节点。若是是这种状况，就执行下面的逻辑：

头被从新赋值给currentNode.next。
deletedNode指向currentNode。
currentNode被从新赋值为null。
将的链表的长度减1。
返回deletedNode。

第三种状况是最难理解的。其复杂性在于咱们要在每一次循环中操做两个节点的必要性。在每次循环中，须要处理要删除的节点和它前面的节点。当循环到要被删除的位置的节点时，循环终止。

在这一点上，咱们涉及到三个节点：
beforeNodeToDelete, nodeToDelete, 和 deletedNode。删除nodeToDelete以前，必须先把它的next的值赋给beforeNodeToDelete的next，若是不清楚这一步骤的目的，能够提醒本身有一个节点负责连接其先后的其余节点，只须要删除这个节点，就能够把链表断开。

接下来，咱们将deletedNode赋值给nodeToDelete。而后咱们将nodeToDelete的值设置为null，将列表的长度减1，最后返回deletedNode。

单向链表的完整实现

如下是单向链表的完整实现：

function Node(data) {
    this.data = data;
    this.next = null;
}
 
function SinglyList() {
    this._length = 0;
    this.head = null;
}
 
SinglyList.prototype.add = function(value) {
    var node = new Node(value),
        currentNode = this.head;
 
    // 1st use-case: an empty list
    if (!currentNode) {
        this.head = node;
        this._length++;
 
        return node;
    }
 
    // 2nd use-case: a non-empty list
    while (currentNode.next) {
        currentNode = currentNode.next;
    }
 
    currentNode.next = node;
 
    this._length++;
     
    return node;
};
 
SinglyList.prototype.searchNodeAt = function(position) {
    var currentNode = this.head,
        length = this._length,
        count = 1,
        message = {failure: 'Failure: non-existent node in this list.'};
 
    // 1st use-case: an invalid position
    if (length === 0 || position < 1 || position > length) {
        throw new Error(message.failure);
    }
 
    // 2nd use-case: a valid position
    while (count < position) {
        currentNode = currentNode.next;
        count++;
    }
 
    return currentNode;
};
 
SinglyList.prototype.remove = function(position) {
    var currentNode = this.head,
        length = this._length,
        count = 0,
        message = {failure: 'Failure: non-existent node in this list.'},
        beforeNodeToDelete = null,
        nodeToDelete = null,
        deletedNode = null;
 
    // 1st use-case: an invalid position
    if (position < 0 || position > length) {
        throw new Error(message.failure);
    }
 
    // 2nd use-case: the first node is removed
    if (position === 1) {
        this.head = currentNode.next;
        deletedNode = currentNode;
        currentNode = null;
        this._length--;
         
        return deletedNode;
    }
 
    // 3rd use-case: any other node is removed
    while (count < position) {
        beforeNodeToDelete = currentNode;
        nodeToDelete = currentNode.next;
        count++;
    }
 
    beforeNodeToDelete.next = nodeToDelete.next;
    deletedNode = nodeToDelete;
    nodeToDelete = null;
    this._length--;
 
    return deletedNode;
};

从单链表到双链表

咱们已经完整的实现了单链表，这真是极好的。如今能够在一个占用费连续的空间的链表结构中，进行添加、删除和查找节点的操做了。

然而如今全部的操做都是从链表的起始位置开始，并运行到链表的结尾。换句话说，它们是单向的。

可能在某些状况下咱们但愿操做是双向的。若是你考虑了这种可能性，那么你刚才就是描述了一个双向链表。

双向链表

双向链表具备单链表的全部功能，并将其扩展为在链表中能够进行双向遍历。换句话说，咱们可从链表中第一个节点遍历到到最后一个节点；也能够从最后一个节点遍历到第一个节点。

在本节中，咱们将重点关注双向链表和单链列表之间的差别。

双向链表的操做

咱们的链表将包括两个构造函数：Node和DoublyList。看看他们是怎样运做的。

Node

data 存储数据。
next 指向链表中下一个节点的指针。
previous 指向链表中前一个节点的指针。

DoublyList

_length 保存链表中节点的个数
head 指定一个节点做为链表的头节点
tail 指定一个节点做为链表的尾节点
add(value) 向链表中添加一个节点
searchNodeAt(position) 找到在列表中指定位置 n 上的节点
remove(position) 删除链表中指定位置上的节点

双向链表的实现

如今开始写代码！

在实现中，将会建立一个名为Node的构造函数：

function Node(value) {
    this.data = value;
    this.previous = null;
    this.next = null;
}

想要实现双向链表的双向遍历，咱们须要指向链表两个方向的属性。这些属性被命名为previous和next。

接下来，咱们须要实现DoublyList并添加三个属性：_length，head和tail。

与单链表不一样，双向链表包含对链表开头和结尾节点的引用。因为DoublyList刚被实例化时并不包含任何节点，因此head和tail的默认值都被设置为null。

function DoublyList() {
    this._length = 0;
    this.head = null;
    this.tail = null;
}

双向链表的方法

接下来咱们讨论如下方法：add(value), remove(position), 和 searchNodeAt(position)。全部这些方法都用于单链表; 然而，它们必须备重写为能够双向遍历。

方法1/3 `add(value)`

DoublyList.prototype.add = function(value) {
    var node = new Node(value);
 
    if (this._length) {
        this.tail.next = node;
        node.previous = this.tail;
        this.tail = node;
    } else {
        this.head = node;
        this.tail = node;
    }
 
    this._length++;
     
    return node;
};

在这个方法中，存在两种可能。首先，若是链表是空的，则给它的head 和tail分配节点。其次，若是链表中已经存在节点，则查找链表的尾部并把心节点分配给tail.next；一样，咱们须要配置新的尾部以供进行双向遍历。换句话说，咱们须要把tail.previous设置为原来的尾部。

方法2/3 `searchNodeAt(position)`

searchNodeAt(position)的实现与单链表相同。若是你忘记了如何实现它，请经过下面的代码回忆：

DoublyList.prototype.searchNodeAt = function(position) {
    var currentNode = this.head,
        length = this._length,
        count = 1,
        message = {failure: 'Failure: non-existent node in this list.'};
 
    // 1st use-case: an invalid position 
    if (length === 0 || position < 1 || position > length) {
        throw new Error(message.failure);
    }
 
    // 2nd use-case: a valid position 
    while (count < position) {
        currentNode = currentNode.next;
        count++;
    }
 
    return currentNode;
};

方法3/3 `remove(position)`

理解这个方法是最具挑战性的。我先写出代码，而后再解释它。

DoublyList.prototype.remove = function(position) {
    var currentNode = this.head,
        length = this._length,
        count = 1,
        message = {failure: 'Failure: non-existent node in this list.'},
        beforeNodeToDelete = null,
        nodeToDelete = null,
        deletedNode = null;
 
    // 1st use-case: an invalid position
    if (length === 0 || position < 1 || position > length) {
        throw new Error(message.failure);
    }
 
    // 2nd use-case: the first node is removed
    if (position === 1) {
        this.head = currentNode.next;
 
        // 2nd use-case: there is a second node
        if (!this.head) {
            this.head.previous = null;
        // 2nd use-case: there is no second node
        } else {
            this.tail = null;
        }
 
    // 3rd use-case: the last node is removed
    } else if (position === this._length) {
        this.tail = this.tail.previous;
        this.tail.next = null;
    // 4th use-case: a middle node is removed
    } else {
        while (count < position) {
            currentNode = currentNode.next;
            count++;
        }
 
        beforeNodeToDelete = currentNode.previous;
        nodeToDelete = currentNode;
        afterNodeToDelete = currentNode.next;
 
        beforeNodeToDelete.next = afterNodeToDelete;
        afterNodeToDelete.previous = beforeNodeToDelete;
        deletedNode = nodeToDelete;
        nodeToDelete = null;
    }
 
    this._length--;
 
    return message.success;
};

remove(position) 处理如下四种状况：

若是remove(position)的参数传递的位置存在, 将会抛出一个错误。
若是remove(position)的参数传递的位置是链表的第一个节点（head），将把head赋值给deletedNode ，而后把head从新分配到链表中的下一个节点。此时，咱们必须考虑链表中否存在多个节点。若是答案为否，头部将被分配为null，以后进入if-else语句的if部分。在if的代码中，还必须将tail设置为null —— 换句话说，咱们返回到一个空的双向链表的初始状态。若是删除列表中的第一个节点，而且链表中存在多个节点，那么咱们输入if-else语句的else部分。在这种状况下，咱们必须正确地将head的previous属性设置为null —— 在链表的头前面是没有节点的。
若是remove(position)的参数传递的位置是链表的尾部，首先把tail赋值给deletedNode，而后tail被从新赋值为尾部以前的那个节点，最后新尾部后面没有其余节点，须要将其next值设置为null。
这里发生了不少事情，因此我将重点关注逻辑，而不是每一行代码。一旦CurrentNode指向的节点是将要被remove(position)删除的节点时，就退出while循环。这时咱们把nodeToDelete以后的节点从新赋值给beforeNodeToDelete.next。相应的，
把nodeToDelete以前的节点从新赋值给afterNodeToDelete.previous。——换句话说，咱们把指向已删除节点的指针，改成指向正确的节点。最后，把nodeToDelete 赋值为null。

最后，把链表的长度减1，返回deletedNode。

双向链表的完整实现

function Node(value) {
    this.data = value;
    this.previous = null;
    this.next = null;
}
 
function DoublyList() {
    this._length = 0;
    this.head = null;
    this.tail = null;
}
 
DoublyList.prototype.add = function(value) {
    var node = new Node(value);
 
    if (this._length) {
        this.tail.next = node;
        node.previous = this.tail;
        this.tail = node;
    } else {
        this.head = node;
        this.tail = node;
    }
 
    this._length++;
 
    return node;
};
 
DoublyList.prototype.searchNodeAt = function(position) {
    var currentNode = this.head,
        length = this._length,
        count = 1,
        message = {failure: 'Failure: non-existent node in this list.'};
 
    // 1st use-case: an invalid position
    if (length === 0 || position < 1 || position > length) {
        throw new Error(message.failure);
    }
 
    // 2nd use-case: a valid position
    while (count < position) {
        currentNode = currentNode.next;
        count++;
    }
 
    return currentNode;
};
 
DoublyList.prototype.remove = function(position) {
    var currentNode = this.head,
        length = this._length,
        count = 1,
        message = {failure: 'Failure: non-existent node in this list.'},
        beforeNodeToDelete = null,
        nodeToDelete = null,
        deletedNode = null;
 
    // 1st use-case: an invalid position
    if (length === 0 || position < 1 || position > length) {
        throw new Error(message.failure);
    }
 
    // 2nd use-case: the first node is removed
    if (position === 1) {
        this.head = currentNode.next;
 
        // 2nd use-case: there is a second node
        if (!this.head) {
            this.head.previous = null;
        // 2nd use-case: there is no second node
        } else {
            this.tail = null;
        }
 
    // 3rd use-case: the last node is removed
    } else if (position === this._length) {
        this.tail = this.tail.previous;
        this.tail.next = null;
    // 4th use-case: a middle node is removed
    } else {
        while (count < position) {
            currentNode = currentNode.next;
            count++;
        }
 
        beforeNodeToDelete = currentNode.previous;
        nodeToDelete = currentNode;
        afterNodeToDelete = currentNode.next;
 
        beforeNodeToDelete.next = afterNodeToDelete;
        afterNodeToDelete.previous = beforeNodeToDelete;
        deletedNode = nodeToDelete;
        nodeToDelete = null;
    }
 
    this._length--;
 
    return message.success;
};

总结

本文中已经介绍了不少信息。若是其中任何地方看起来使人困惑，就再读一遍并查看代码。若是它最终对你有所帮助，我会感到自豪。你刚刚揭开了一个单链表和双向链表的秘密，能够把这些数据结构添加到本身的编码工具弹药库中！

欢迎扫描二维码关注公众号，天天推送我翻译的技术文章。

【译】JavaScript数据结构（3）：单向链表与双向链表

单链表

单链表的操做

Node

SinglyList

单链表的实现

单链表的方法

方法1/3: add(value)

方法2/3: searchNodeAt(position)

方法3/3: remove(position)

单向链表的完整实现

从单链表到双链表

双向链表

双向链表的操做

Node

DoublyList

双向链表的实现

双向链表的方法

方法1/3 add(value)

方法2/3 searchNodeAt(position)

方法3/3 remove(position)

双向链表的完整实现

总结

方法1/3: `add(value)`

方法2/3: `searchNodeAt(position)`

方法3/3: `remove(position)`

方法1/3 `add(value)`

方法2/3 `searchNodeAt(position)`

方法3/3 `remove(position)`