当前位置：首页 > 编程日记 > 正文

如何在JavaScript中实现链接列表

编程日记 2024-06-24 00:00:00

If you are learning data structures, a linked list is one data structure you should know. If you do not really understand it or how it is implemented in JavaScript, this article is here to help you.

如果您正在学习数据结构，则链表是您应该知道的一种数据结构。如果您不太了解它或如何在JavaScript中实现它，本文将为您提供帮助。

In this article, we will discuss what a linked list is, how it is different from an array, and how to implement it in JavaScript. Let's get started.

在本文中，我们将讨论什么是链表，链表与数组的不同之处以及如何在JavaScript中实现。让我们开始吧。

什么是链表？ (What is a Linked List?)

A linked list is a linear data structure similar to an array. However, unlike arrays, elements are not stored in a particular memory location or index. Rather each element is a separate object that contains a pointer or a link to the next object in that list.

链表是类似于数组的线性数据结构。但是，与数组不同，元素不存储在特定的存储位置或索引中。而是每个元素都是一个单独的对象，其中包含一个指针或指向该列表中下一个对象的链接。

Each element (commonly called nodes) contains two items: the data stored and a link to the next node. The data can be any valid data type. You can see this illustrated in the diagram below.

每个元素(通常称为节点)包含两项：存储的数据和到下一个节点的链接。数据可以是任何有效的数据类型。您可以在下图中看到这一点。

The entry point to a linked list is called the head. The head is a reference to the first node in the linked list. The last node on the list points to null. If a list is empty, the head is a null reference.

链接列表的入口称为头。头是对链表中第一个节点的引用。列表上的最后一个节点指向null。如果列表为空，则标头为空引用。

In JavaScript, a linked list looks like this:

在JavaScript中，链接列表如下所示：

const list = {head: {value: 6next: {value: 10                                             next: {value: 12next: {value: 3next: null	}}}}}
};

链表的优点 (An advantage of Linked Lists)

Nodes can easily be removed or added from a linked list without reorganizing the entire data structure. This is one advantage it has over arrays.
可以轻松地从链接列表中删除或添加节点，而无需重新组织整个数据结构。这是它比数组具有的优势之一。

链表的缺点 (Disadvantages of Linked Lists)

Search operations are slow in linked lists. Unlike arrays, random access of data elements is not allowed. Nodes are accessed sequentially starting from the first node.
链接列表中的搜索操作很慢。与数组不同，不允许随机访问数据元素。从第一个节点开始依次访问节点。
It uses more memory than arrays because of the storage of the pointers.
由于指针的存储，它比数组使用更多的内存。

链接列表的类型 (Types of Linked Lists)

There are three types of linked lists:

链接列表有三种类型：

Singly Linked Lists: Each node contains only one pointer to the next node. This is what we have been talking about so far.
单链接列表 ：每个节点仅包含一个指向下一个节点的指针。到目前为止，这就是我们一直在谈论的内容。
Doubly Linked Lists: Each node contains two pointers, a pointer to the next node and a pointer to the previous node.
双链表 ：每个节点包含两个指针，一个指向下一个节点的指针和一个指向上一个节点的指针。
Circular Linked Lists: Circular linked lists are a variation of a linked list in which the last node points to the first node or any other node before it, thereby forming a loop.
循环链表 ：循环链表是链表的一种变体，其中最后一个节点指向第一个节点或它之前的任何其他节点，从而形成一个循环。

在JavaScript中实现列表节点 (Implementing a List Node in JavaScript)

As stated earlier, a list node contains two items: the data and the pointer to the next node. We can implement a list node in JavaScript as follows:

如前所述，列表节点包含两项：数据和指向下一个节点的指针。我们可以在JavaScript中实现列表节点，如下所示：

class ListNode {constructor(data) {this.data = datathis.next = null                }
}

在JavaScript中实现链接列表 (Implementing a Linked List in JavaScript)

The code below shows the implementation of a linked list class with a constructor. Notice that if the head node is not passed, the head is initialised to null.

下面的代码显示了使用构造函数的链表类的实现。请注意，如果未传递头节点，则头将初始化为null。

class LinkedList {constructor(head = null) {this.head = head}
}

全部放在一起 (Putting it all together)

Let's create a linked list with the class we just created. First, we create two list nodes, node1 and node2 and a pointer from node 1 to node 2.

让我们用刚刚创建的类创建一个链表。首先，我们创建了两个列表中的节点， node1和node2和节点1到节点2的指针。

let node1 = new ListNode(2)
let node2 = new ListNode(5)
node1.next = node2

Next, we'll create a Linked list with the node1.

接下来，我们将使用node1创建一个链接列表。

let list = new LinkedList(node1)

Let's try to access the nodes in the list we just created.

让我们尝试访问刚刚创建的列表中的节点。

console.log(list.head.next.data) //returns 5

一些LinkedList方法 (Some LinkedList methods)

Next up, we will implement four helper methods for the linked list. They are:

接下来，我们将为链接列表实现四种帮助方法。他们是：

size()
尺寸()
clear()
明确()
getLast()
getLast()
getFirst()
getFirst()

1. size() (1. size())

This method returns the number of nodes present in the linked list.

此方法返回链表中存在的节点数。

size() {let count = 0; let node = this.head;while (node) {count++;node = node.next}return count;
}

2. clear() (2. clear())

This method empties out the list.

此方法清空列表。

clear() {this.head = null;
}

3. getLast() (3. getLast())

This method returns the last node of the linked list.

此方法返回链表的最后一个节点。

getLast() {let lastNode = this.head;if (lastNode) {while (lastNode.next) {lastNode = lastNode.next}}return lastNode
}

4. getFirst() (4. getFirst())

This method returns the first node of the linked list.

此方法返回链表的第一个节点。

getFirst() {return this.head;
}

摘要 (Summary)

In this article, we discussed what a linked list is and how it can be implemented in JavaScript. We also discussed the different types of linked lists as well as their overall advantages and disadvantages.

在本文中，我们讨论了什么是链表以及如何在JavaScript中实现链表。我们还讨论了链表的不同类型及其整体优缺点。

I hope you enjoyed reading it.

希望您喜欢阅读。

Want to get notified when I publish a new article? Click here.

想要在我发表新文章时得到通知吗？ 请点击这里。

翻译自: https://www.freecodecamp.org/news/implementing-a-linked-list-in-javascript/

https://www.dkcj.cn/info/12039.html