CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-14 18:31:08 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-04-09 04:34:58 +08:00
parent adcbab4d4c
commit 01d05cc1f0
26 changed files with 1501 additions and 1247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

262
chapter_array_and_linkedlist/linked_list.md
View File

@@ -6,9 +6,9 @@ comments: true
内存空间是所有程序的公共资源，排除已被占用的内存空间，空闲内存空间通常散落在内存各处。在上一节中，我们提到存储数组的内存空间必须是连续的，而当我们需要申请一个非常大的数组时，空闲内存中可能没有这么大的连续空间。
与数组相比，链表更具灵活性，因为它可以存储在非连续的内存空间。「链表 Linked List」是一种线性数据结构，其每个元素都是一个结点对象，各个结点之间通过指针连接，从当前结点通过指针可以访问到下一个结点。由于指针记录了下个结点的内存地址，因此无需保证内存地址的连续性，从而可以将各个结点分散存储在内存各处。
与数组相比，链表更具灵活性，因为它可以存储在非连续的内存空间。「链表 Linked List」是一种线性数据结构，其每个元素都是一个节点对象，各个节点之间通过指针连接，从当前节点通过指针可以访问到下一个节点。由于指针记录了下个节点的内存地址，因此无需保证内存地址的连续性，从而可以将各个节点分散存储在内存各处。
链表「结点 Node」包含两项数据，一是结点「值 Value」，二是指向下一结点的「指针 Pointer」，或称指向下一结点的「引用 Reference」。
链表「节点 Node」包含两项数据，一是节点「值 Value」，二是指向下一节点的「指针 Pointer」，或称指向下一节点的「引用 Reference」。
![链表定义与存储方式](linked_list.assets/linkedlist_definition.png)
@@ -17,10 +17,10 @@ comments: true
=== "Java"
```java title=""
/* 链表结点类 */
/* 链表节点类 */
class ListNode {
int val; // 结点值
ListNode next; // 指向下一结点的指针（引用）
int val; // 节点值
ListNode next; // 指向下一节点的指针（引用）
ListNode(int x) { val = x; } // 构造函数
}
```
@@ -28,10 +28,10 @@ comments: true
=== "C++"
```cpp title=""
/* 链表结点结构体 */
/* 链表节点结构体 */
struct ListNode {
int val; // 结点值
ListNode *next; // 指向下一结点的指针（引用）
int val; // 节点值
ListNode *next; // 指向下一节点的指针（引用）
ListNode(int x) : val(x), next(nullptr) {} // 构造函数
};
```
@@ -39,20 +39,20 @@ comments: true
=== "Python"
```python title=""
""" 链表结点类 """
""" 链表节点类 """
class ListNode:
def __init__(self, val: int):
self.val: int = val # 结点值
self.next: Optional[ListNode] = None # 指向下一结点的指针（引用）
self.val: int = val # 节点值
self.next: Optional[ListNode] = None # 指向下一节点的指针（引用）
```
=== "Go"
```go title=""
/* 链表结点结构体 */
/* 链表节点结构体 */
type ListNode struct {
Val int // 结点值
Next *ListNode // 指向下一结点的指针（引用）
Val int // 节点值
Next *ListNode // 指向下一节点的指针（引用）
}
// NewListNode 构造函数，创建一个新的链表
@@ -67,13 +67,13 @@ comments: true
=== "JavaScript"
```javascript title=""
/* 链表结点类 */
/* 链表节点类 */
class ListNode {
val;
next;
constructor(val, next) {
this.val = (val === undefined ? 0 : val); // 结点值
this.next = (next === undefined ? null : next); // 指向下一结点的引用
this.val = (val === undefined ? 0 : val); // 节点值
this.next = (next === undefined ? null : next); // 指向下一节点的引用
}
}
```
@@ -81,13 +81,13 @@ comments: true
=== "TypeScript"
```typescript title=""
/* 链表结点类 */
/* 链表节点类 */
class ListNode {
val: number;
next: ListNode | null;
constructor(val?: number, next?: ListNode | null) {
this.val = val === undefined ? 0 : val; // 结点值
this.next = next === undefined ? null : next; // 指向下一结点的引用
this.val = val === undefined ? 0 : val; // 节点值
this.next = next === undefined ? null : next; // 指向下一节点的引用
}
}
```
@@ -95,16 +95,16 @@ comments: true
=== "C"
```c title=""
/* 链表结点结构体 */
/* 链表节点结构体 */
struct ListNode {
int val; // 结点值
struct ListNode *next; // 指向下一结点的指针（引用）
int val; // 节点值
struct ListNode *next; // 指向下一节点的指针（引用）
};
// typedef 作用是为一种数据类型定义一个新名字
typedef struct ListNode ListNode;
/* 构造函数，初始化一个新结点 */
/* 构造函数，初始化一个新节点 */
ListNode *newListNode(int val) {
ListNode *node, *next;
node = (ListNode *) malloc(sizeof(ListNode));
@@ -117,11 +117,11 @@ comments: true
=== "C#"
```csharp title=""
/* 链表结点类 */
/* 链表节点类 */
class ListNode
{
int val; // 结点值
ListNode next; // 指向下一结点的引用
int val; // 节点值
ListNode next; // 指向下一节点的引用
ListNode(int x) => val = x; //构造函数
}
```
@@ -129,10 +129,10 @@ comments: true
=== "Swift"
```swift title=""
/* 链表结点类 */
/* 链表节点类 */
class ListNode {
var val: Int // 结点值
var next: ListNode? // 指向下一结点的指针（引用）
var val: Int // 节点值
var next: ListNode? // 指向下一节点的指针（引用）
init(x: Int) { // 构造函数
val = x
@@ -143,13 +143,13 @@ comments: true
=== "Zig"
```zig title=""
// 链表结点类
// 链表节点类
pub fn ListNode(comptime T: type) type {
return struct {
const Self = @This();
val: T = 0, // 结点值
next: ?*Self = null, // 指向下一结点的指针（引用）
val: T = 0, // 节点值
next: ?*Self = null, // 指向下一节点的指针（引用）
// 构造函数
pub fn init(self: *Self, x: i32) void {
@@ -160,21 +160,21 @@ comments: true
}
```
!!! question "尾结点指向什么？"
!!! question "尾节点指向什么？"
我们将链表的最后一个结点称为「尾结点」，其指向的是“空”，在 Java, C++, Python 中分别记为 `null`, `nullptr`, `None` 。在不引起歧义的前提下，本书都使用 `null` 来表示空。
我们将链表的最后一个节点称为「尾节点」，其指向的是“空”，在 Java, C++, Python 中分别记为 `null`, `nullptr`, `None` 。在不引起歧义的前提下，本书都使用 `null` 来表示空。
!!! question "如何称呼链表？"
在编程语言中，数组整体就是一个变量，例如数组 `nums` ，包含各个元素 `nums[0]` , `nums[1]` 等等。而链表是由多个结点对象组成，我们通常将头结点当作链表的代称，例如头结点 `head` 和链表 `head` 实际上是同义的。
在编程语言中，数组整体就是一个变量，例如数组 `nums` ，包含各个元素 `nums[0]` , `nums[1]` 等等。而链表是由多个节点对象组成，我们通常将头节点当作链表的代称，例如头节点 `head` 和链表 `head` 实际上是同义的。
**链表初始化方法**。建立链表分为两步，第一步是初始化各个结点对象，第二步是构建引用指向关系。完成后，即可以从链表的头结点（即首个结点）出发，通过指针 `next` 依次访问所有结点。
**链表初始化方法**。建立链表分为两步，第一步是初始化各个节点对象，第二步是构建引用指向关系。完成后，即可以从链表的头节点（即首个节点）出发，通过指针 `next` 依次访问所有节点。
=== "Java"
```java title="linked_list.java"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
// 初始化各个节点
ListNode n0 = new ListNode(1);
ListNode n1 = new ListNode(3);
ListNode n2 = new ListNode(2);
@@ -191,7 +191,7 @@ comments: true
```cpp title="linked_list.cpp"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
// 初始化各个节点
ListNode* n0 = new ListNode(1);
ListNode* n1 = new ListNode(3);
ListNode* n2 = new ListNode(2);
@@ -208,7 +208,7 @@ comments: true
```python title="linked_list.py"
""" 初始化链表 1 -> 3 -> 2 -> 5 -> 4 """
# 初始化各个结点
# 初始化各个节点
n0 = ListNode(1)
n1 = ListNode(3)
n2 = ListNode(2)
@@ -225,7 +225,7 @@ comments: true
```go title="linked_list.go"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
// 初始化各个节点
n0 := NewListNode(1)
n1 := NewListNode(3)
n2 := NewListNode(2)
@@ -242,7 +242,7 @@ comments: true
```javascript title="linked_list.js"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
// 初始化各个节点
const n0 = new ListNode(1);
const n1 = new ListNode(3);
const n2 = new ListNode(2);
@@ -259,7 +259,7 @@ comments: true
```typescript title="linked_list.ts"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
// 初始化各个节点
const n0 = new ListNode(1);
const n1 = new ListNode(3);
const n2 = new ListNode(2);
@@ -276,7 +276,7 @@ comments: true
```c title="linked_list.c"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
// 初始化各个节点
ListNode* n0 = newListNode(1);
ListNode* n1 = newListNode(3);
ListNode* n2 = newListNode(2);
@@ -293,7 +293,7 @@ comments: true
```csharp title="linked_list.cs"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
// 初始化各个节点
ListNode n0 = new ListNode(1);
ListNode n1 = new ListNode(3);
ListNode n2 = new ListNode(2);
@@ -310,7 +310,7 @@ comments: true
```swift title="linked_list.swift"
/* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
// 初始化各个结点
// 初始化各个节点
let n0 = ListNode(x: 1)
let n1 = ListNode(x: 3)
let n2 = ListNode(x: 2)
@@ -327,7 +327,7 @@ comments: true
```zig title="linked_list.zig"
// 初始化链表
// 初始化各个结点
// 初始化各个节点
var n0 = inc.ListNode(i32){.val = 1};
var n1 = inc.ListNode(i32){.val = 3};
var n2 = inc.ListNode(i32){.val = 2};
@@ -342,16 +342,16 @@ comments: true
## 4.2.1.   链表优点
**链表中插入与删除结点的操作效率高**。例如，如果我们想在链表中间的两个结点 `A` , `B` 之间插入一个新结点 `P` ，我们只需要改变两个结点指针即可，时间复杂度为 $O(1)$ ；相比之下，数组的插入操作效率要低得多。
**链表中插入与删除节点的操作效率高**。例如，如果我们想在链表中间的两个节点 `A` , `B` 之间插入一个新节点 `P` ，我们只需要改变两个节点指针即可，时间复杂度为 $O(1)$ ；相比之下，数组的插入操作效率要低得多。
![链表插入结点](linked_list.assets/linkedlist_insert_node.png)
![链表插入节点](linked_list.assets/linkedlist_insert_node.png)
<p align="center"> Fig. 链表插入结点 </p>
<p align="center"> Fig. 链表插入节点 </p>
=== "Java"
```java title="linked_list.java"
/* 在链表的结点 n0 之后插入结点 P */
/* 在链表的节点 n0 之后插入节点 P */
void insert(ListNode n0, ListNode P) {
ListNode n1 = n0.next;
P.next = n1;
@@ -362,7 +362,7 @@ comments: true
=== "C++"
```cpp title="linked_list.cpp"
/* 在链表的结点 n0 之后插入结点 P */
/* 在链表的节点 n0 之后插入节点 P */
void insert(ListNode* n0, ListNode* P) {
ListNode* n1 = n0->next;
P->next = n1;
@@ -374,7 +374,7 @@ comments: true
```python title="linked_list.py"
def insert(n0: ListNode, P: ListNode) -> None:
""" 在链表的结点 n0 之后插入结点 P """
""" 在链表的节点 n0 之后插入节点 P """
n1 = n0.next
P.next = n1
n0.next = P
@@ -383,7 +383,7 @@ comments: true
=== "Go"
```go title="linked_list.go"
/* 在链表的结点 n0 之后插入结点 P */
/* 在链表的节点 n0 之后插入节点 P */
func insertNode(n0 *ListNode, P *ListNode) {
n1 := n0.Next
P.Next = n1
@@ -394,7 +394,7 @@ comments: true
=== "JavaScript"
```javascript title="linked_list.js"
/* 在链表的结点 n0 之后插入结点 P */
/* 在链表的节点 n0 之后插入节点 P */
function insert(n0, P) {
const n1 = n0.next;
P.next = n1;
@@ -405,7 +405,7 @@ comments: true
=== "TypeScript"
```typescript title="linked_list.ts"
/* 在链表的结点 n0 之后插入结点 P */
/* 在链表的节点 n0 之后插入节点 P */
function insert(n0: ListNode, P: ListNode): void {
const n1 = n0.next;
P.next = n1;
@@ -422,7 +422,7 @@ comments: true
=== "C#"
```csharp title="linked_list.cs"
/* 在链表的结点 n0 之后插入结点 P */
/* 在链表的节点 n0 之后插入节点 P */
void insert(ListNode n0, ListNode P)
{
ListNode? n1 = n0.next;
@@ -434,7 +434,7 @@ comments: true
=== "Swift"
```swift title="linked_list.swift"
/* 在链表的结点 n0 之后插入结点 P */
/* 在链表的节点 n0 之后插入节点 P */
func insert(n0: ListNode, P: ListNode) {
let n1 = n0.next
P.next = n1
@@ -445,7 +445,7 @@ comments: true
=== "Zig"
```zig title="linked_list.zig"
// 在链表的结点 n0 之后插入结点 P
// 在链表的节点 n0 之后插入节点 P
fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
var n1 = n0.?.next;
P.?.next = n1;
@@ -453,16 +453,16 @@ comments: true
}
```
在链表中删除结点也非常方便，只需改变一个结点的指针即可。如下图所示，尽管在删除操作完成后，结点 `P` 仍然指向 `n1`，但实际上 `P` 已经不再属于此链表，因为遍历此链表时无法访问到 `P`。
在链表中删除节点也非常方便，只需改变一个节点的指针即可。如下图所示，尽管在删除操作完成后，节点 `P` 仍然指向 `n1`，但实际上 `P` 已经不再属于此链表，因为遍历此链表时无法访问到 `P`。
![链表删除结点](linked_list.assets/linkedlist_remove_node.png)
![链表删除节点](linked_list.assets/linkedlist_remove_node.png)
<p align="center"> Fig. 链表删除结点 </p>
<p align="center"> Fig. 链表删除节点 </p>
=== "Java"
```java title="linked_list.java"
/* 删除链表的结点 n0 之后的首个结点 */
/* 删除链表的节点 n0 之后的首个节点 */
void remove(ListNode n0) {
if (n0.next == null)
return;
@@ -476,7 +476,7 @@ comments: true
=== "C++"
```cpp title="linked_list.cpp"
/* 删除链表的结点 n0 之后的首个结点 */
/* 删除链表的节点 n0 之后的首个节点 */
void remove(ListNode* n0) {
if (n0->next == nullptr)
return;
@@ -493,7 +493,7 @@ comments: true
```python title="linked_list.py"
def remove(n0: ListNode) -> None:
""" 删除链表的结点 n0 之后的首个结点 """
""" 删除链表的节点 n0 之后的首个节点 """
if not n0.next:
return
# n0 -> P -> n1
@@ -505,7 +505,7 @@ comments: true
=== "Go"
```go title="linked_list.go"
/* 删除链表的结点 n0 之后的首个结点 */
/* 删除链表的节点 n0 之后的首个节点 */
func removeNode(n0 *ListNode) {
if n0.Next == nil {
return
@@ -520,7 +520,7 @@ comments: true
=== "JavaScript"
```javascript title="linked_list.js"
/* 删除链表的结点 n0 之后的首个结点 */
/* 删除链表的节点 n0 之后的首个节点 */
function remove(n0) {
if (!n0.next)
return;
@@ -534,7 +534,7 @@ comments: true
=== "TypeScript"
```typescript title="linked_list.ts"
/* 删除链表的结点 n0 之后的首个结点 */
/* 删除链表的节点 n0 之后的首个节点 */
function remove(n0: ListNode): void {
if (!n0.next) {
return;
@@ -555,7 +555,7 @@ comments: true
=== "C#"
```csharp title="linked_list.cs"
/* 删除链表的结点 n0 之后的首个结点 */
/* 删除链表的节点 n0 之后的首个节点 */
void remove(ListNode n0)
{
if (n0.next == null)
@@ -570,7 +570,7 @@ comments: true
=== "Swift"
```swift title="linked_list.swift"
/* 删除链表的结点 n0 之后的首个结点 */
/* 删除链表的节点 n0 之后的首个节点 */
func remove(n0: ListNode) {
if n0.next == nil {
return
@@ -586,7 +586,7 @@ comments: true
=== "Zig"
```zig title="linked_list.zig"
// 删除链表的结点 n0 之后的首个结点
// 删除链表的节点 n0 之后的首个节点
fn remove(n0: ?*inc.ListNode(i32)) void {
if (n0.?.next == null) return;
// n0 -> P -> n1
@@ -598,12 +598,12 @@ comments: true
## 4.2.2. &nbsp; 链表缺点
**链表访问结点效率较低**。如上节所述，数组可以在 $O(1)$ 时间下访问任意元素。然而，链表无法直接访问任意结点，这是因为系统需要从头结点出发，逐个向后遍历直至找到目标结点。例如，若要访问链表索引为 `index`（即第 `index + 1` 个）的结点，则需要向后遍历 `index` 轮。
**链表访问节点效率较低**。如上节所述，数组可以在 $O(1)$ 时间下访问任意元素。然而，链表无法直接访问任意节点，这是因为系统需要从头节点出发，逐个向后遍历直至找到目标节点。例如，若要访问链表索引为 `index`（即第 `index + 1` 个）的节点，则需要向后遍历 `index` 轮。
=== "Java"
```java title="linked_list.java"
/* 访问链表中索引为 index 的结点 */
/* 访问链表中索引为 index 的节点 */
ListNode access(ListNode head, int index) {
for (int i = 0; i < index; i++) {
if (head == null)
@@ -617,7 +617,7 @@ comments: true
=== "C++"
```cpp title="linked_list.cpp"
/* 访问链表中索引为 index 的结点 */
/* 访问链表中索引为 index 的节点 */
ListNode* access(ListNode* head, int index) {
for (int i = 0; i < index; i++) {
if (head == nullptr)
@@ -632,7 +632,7 @@ comments: true
```python title="linked_list.py"
def access(head: ListNode, index: int) -> ListNode | None:
""" 访问链表中索引为 index 的结点 """
""" 访问链表中索引为 index 的节点 """
for _ in range(index):
if not head:
return None
@@ -643,7 +643,7 @@ comments: true
=== "Go"
```go title="linked_list.go"
/* 访问链表中索引为 index 的结点 */
/* 访问链表中索引为 index 的节点 */
func access(head *ListNode, index int) *ListNode {
for i := 0; i < index; i++ {
if head == nil {
@@ -658,7 +658,7 @@ comments: true
=== "JavaScript"
```javascript title="linked_list.js"
/* 访问链表中索引为 index 的结点 */
/* 访问链表中索引为 index 的节点 */
function access(head, index) {
for (let i = 0; i < index; i++) {
if (!head) {
@@ -673,7 +673,7 @@ comments: true
=== "TypeScript"
```typescript title="linked_list.ts"
/* 访问链表中索引为 index 的结点 */
/* 访问链表中索引为 index 的节点 */
function access(head: ListNode | null, index: number): ListNode | null {
for (let i = 0; i < index; i++) {
if (!head) {
@@ -694,7 +694,7 @@ comments: true
=== "C#"
```csharp title="linked_list.cs"
/* 访问链表中索引为 index 的结点 */
/* 访问链表中索引为 index 的节点 */
ListNode? access(ListNode head, int index)
{
for (int i = 0; i < index; i++)
@@ -710,7 +710,7 @@ comments: true
=== "Swift"
```swift title="linked_list.swift"
/* 访问链表中索引为 index 的结点 */
/* 访问链表中索引为 index 的节点 */
func access(head: ListNode, index: Int) -> ListNode? {
var head: ListNode? = head
for _ in 0 ..< index {
@@ -726,7 +726,7 @@ comments: true
=== "Zig"
```zig title="linked_list.zig"
// 访问链表中索引为 index 的结点
// 访问链表中索引为 index 的节点
fn access(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
var head = node;
var i: i32 = 0;
@@ -738,16 +738,16 @@ comments: true
}
```
**链表的内存占用较大**。链表以结点为单位，每个结点除了保存值之外，还需额外保存指针（引用）。这意味着在相同数据量的情况下，链表比数组需要占用更多的内存空间。
**链表的内存占用较大**。链表以节点为单位，每个节点除了保存值之外，还需额外保存指针（引用）。这意味着在相同数据量的情况下，链表比数组需要占用更多的内存空间。
## 4.2.3. &nbsp; 链表常用操作
**遍历链表查找**。遍历链表，查找链表内值为 `target` 的结点，输出结点在链表中的索引。
**遍历链表查找**。遍历链表，查找链表内值为 `target` 的节点，输出节点在链表中的索引。
=== "Java"
```java title="linked_list.java"
/* 在链表中查找值为 target 的首个结点 */
/* 在链表中查找值为 target 的首个节点 */
int find(ListNode head, int target) {
int index = 0;
while (head != null) {
@@ -763,7 +763,7 @@ comments: true
=== "C++"
```cpp title="linked_list.cpp"
/* 在链表中查找值为 target 的首个结点 */
/* 在链表中查找值为 target 的首个节点 */
int find(ListNode* head, int target) {
int index = 0;
while (head != nullptr) {
@@ -780,7 +780,7 @@ comments: true
```python title="linked_list.py"
def find(head: ListNode, target: int) -> int:
""" 在链表中查找值为 target 的首个结点 """
""" 在链表中查找值为 target 的首个节点 """
index = 0
while head:
if head.val == target:
@@ -793,7 +793,7 @@ comments: true
=== "Go"
```go title="linked_list.go"
/* 在链表中查找值为 target 的首个结点 */
/* 在链表中查找值为 target 的首个节点 */
func findNode(head *ListNode, target int) int {
index := 0
for head != nil {
@@ -810,7 +810,7 @@ comments: true
=== "JavaScript"
```javascript title="linked_list.js"
/* 在链表中查找值为 target 的首个结点 */
/* 在链表中查找值为 target 的首个节点 */
function find(head, target) {
let index = 0;
while (head !== null) {
@@ -827,7 +827,7 @@ comments: true
=== "TypeScript"
```typescript title="linked_list.ts"
/* 在链表中查找值为 target 的首个结点 */
/* 在链表中查找值为 target 的首个节点 */
function find(head: ListNode | null, target: number): number {
let index = 0;
while (head !== null) {
@@ -850,7 +850,7 @@ comments: true
=== "C#"
```csharp title="linked_list.cs"
/* 在链表中查找值为 target 的首个结点 */
/* 在链表中查找值为 target 的首个节点 */
int find(ListNode head, int target)
{
int index = 0;
@@ -868,7 +868,7 @@ comments: true
=== "Swift"
```swift title="linked_list.swift"
/* 在链表中查找值为 target 的首个结点 */
/* 在链表中查找值为 target 的首个节点 */
func find(head: ListNode, target: Int) -> Int {
var head: ListNode? = head
var index = 0
@@ -886,7 +886,7 @@ comments: true
=== "Zig"
```zig title="linked_list.zig"
// 在链表中查找值为 target 的首个结点
// 在链表中查找值为 target 的首个节点
fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
var head = node;
var index: i32 = 0;
@@ -901,20 +901,20 @@ comments: true
## 4.2.4. &nbsp; 常见链表类型
**单向链表**。即上述介绍的普通链表。单向链表的结点包含值和指向下一结点的指针（引用）两项数据。我们将首个结点称为头结点，将最后一个结点成为尾结点，尾结点指向 `null` 。
**单向链表**。即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的指针（引用）两项数据。我们将首个节点称为头节点，将最后一个节点成为尾节点，尾节点指向 `null` 。
**环形链表**。如果我们令单向链表的尾结点指向头结点（即首尾相接），则得到一个环形链表。在环形链表中，任意结点都可以视作头结点。
**环形链表**。如果我们令单向链表的尾节点指向头节点（即首尾相接），则得到一个环形链表。在环形链表中，任意节点都可以视作头节点。
**双向链表**。与单向链表相比，双向链表记录了两个方向的指针（引用）。双向链表的结点定义同时包含指向后继结点（下一结点）和前驱结点（上一结点）的指针。相较于单向链表，双向链表更具灵活性，可以朝两个方向遍历链表，但相应地也需要占用更多的内存空间。
**双向链表**。与单向链表相比，双向链表记录了两个方向的指针（引用）。双向链表的节点定义同时包含指向后继节点（下一节点）和前驱节点（上一节点）的指针。相较于单向链表，双向链表更具灵活性，可以朝两个方向遍历链表，但相应地也需要占用更多的内存空间。
=== "Java"
```java title=""
/* 双向链表结点类 */
/* 双向链表节点类 */
class ListNode {
int val; // 结点值
ListNode next; // 指向后继结点的指针（引用）
ListNode prev; // 指向前驱结点的指针（引用）
int val; // 节点值
ListNode next; // 指向后继节点的指针（引用）
ListNode prev; // 指向前驱节点的指针（引用）
ListNode(int x) { val = x; } // 构造函数
}
```
@@ -922,11 +922,11 @@ comments: true
=== "C++"
```cpp title=""
/* 双向链表结点结构体 */
/* 双向链表节点结构体 */
struct ListNode {
int val; // 结点值
ListNode *next; // 指向后继结点的指针（引用）
ListNode *prev; // 指向前驱结点的指针（引用）
int val; // 节点值
ListNode *next; // 指向后继节点的指针（引用）
ListNode *prev; // 指向前驱节点的指针（引用）
ListNode(int x) : val(x), next(nullptr), prev(nullptr) {} // 构造函数
};
```
@@ -934,22 +934,22 @@ comments: true
=== "Python"
```python title=""
""" 双向链表结点类 """
""" 双向链表节点类 """
class ListNode:
def __init__(self, val: int):
self.val: int = val # 结点值
self.next: Optional[ListNode] = None # 指向后继结点的指针（引用）
self.prev: Optional[ListNode] = None # 指向前驱结点的指针（引用）
self.val: int = val # 节点值
self.next: Optional[ListNode] = None # 指向后继节点的指针（引用）
self.prev: Optional[ListNode] = None # 指向前驱节点的指针（引用）
```
=== "Go"
```go title=""
/* 双向链表结点结构体 */
/* 双向链表节点结构体 */
type DoublyListNode struct {
Val int // 结点值
Next *DoublyListNode // 指向后继结点的指针（引用）
Prev *DoublyListNode // 指向前驱结点的指针（引用）
Val int // 节点值
Next *DoublyListNode // 指向后继节点的指针（引用）
Prev *DoublyListNode // 指向前驱节点的指针（引用）
}
// NewDoublyListNode 初始化
@@ -965,15 +965,15 @@ comments: true
=== "JavaScript"
```javascript title=""
/* 双向链表结点类 */
/* 双向链表节点类 */
class ListNode {
val;
next;
prev;
constructor(val, next) {
this.val = val === undefined ? 0 : val; // 结点值
this.next = next === undefined ? null : next; // 指向后继结点的指针（引用）
this.prev = prev === undefined ? null : prev; // 指向前驱结点的指针（引用）
this.val = val === undefined ? 0 : val; // 节点值
this.next = next === undefined ? null : next; // 指向后继节点的指针（引用）
this.prev = prev === undefined ? null : prev; // 指向前驱节点的指针（引用）
}
}
```
@@ -981,15 +981,15 @@ comments: true
=== "TypeScript"
```typescript title=""
/* 双向链表结点类 */
/* 双向链表节点类 */
class ListNode {
val: number;
next: ListNode | null;
prev: ListNode | null;
constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {
this.val = val === undefined ? 0 : val; // 结点值
this.next = next === undefined ? null : next; // 指向后继结点的指针（引用）
this.prev = prev === undefined ? null : prev; // 指向前驱结点的指针（引用）
this.val = val === undefined ? 0 : val; // 节点值
this.next = next === undefined ? null : next; // 指向后继节点的指针（引用）
this.prev = prev === undefined ? null : prev; // 指向前驱节点的指针（引用）
}
}
```
@@ -1003,11 +1003,11 @@ comments: true
=== "C#"
```csharp title=""
/* 双向链表结点类 */
/* 双向链表节点类 */
class ListNode {
int val; // 结点值
ListNode next; // 指向后继结点的指针（引用）
ListNode prev; // 指向前驱结点的指针（引用）
int val; // 节点值
ListNode next; // 指向后继节点的指针（引用）
ListNode prev; // 指向前驱节点的指针（引用）
ListNode(int x) => val = x; // 构造函数
}
```
@@ -1015,11 +1015,11 @@ comments: true
=== "Swift"
```swift title=""
/* 双向链表结点类 */
/* 双向链表节点类 */
class ListNode {
var val: Int // 结点值
var next: ListNode? // 指向后继结点的指针（引用）
var prev: ListNode? // 指向前驱结点的指针（引用）
var val: Int // 节点值
var next: ListNode? // 指向后继节点的指针（引用）
var prev: ListNode? // 指向前驱节点的指针（引用）
init(x: Int) { // 构造函数
val = x
@@ -1030,14 +1030,14 @@ comments: true
=== "Zig"
```zig title=""
// 双向链表结点类
// 双向链表节点类
pub fn ListNode(comptime T: type) type {
return struct {
const Self = @This();
val: T = 0, // 结点值
next: ?*Self = null, // 指向后继结点的指针（引用）
prev: ?*Self = null, // 指向前驱结点的指针（引用）
val: T = 0, // 节点值
next: ?*Self = null, // 指向后继节点的指针（引用）
prev: ?*Self = null, // 指向前驱节点的指针（引用）
// 构造函数
pub fn init(self: *Self, x: i32) void {

4
chapter_array_and_linkedlist/summary.md
View File

@@ -6,7 +6,7 @@ comments: true
- 数组和链表是两种基本数据结构，分别代表数据在计算机内存中的连续空间存储和离散空间存储方式。两者的优缺点呈现出互补的特性。
- 数组支持随机访问、占用内存较少；但插入和删除元素效率低，且初始化后长度不可变。
- 链表通过更改指针实现高效的结点插入与删除，且可以灵活调整长度；但结点访问效率低、占用内存较多。常见的链表类型包括单向链表、循环链表、双向链表。
- 链表通过更改指针实现高效的节点插入与删除，且可以灵活调整长度；但节点访问效率低、占用内存较多。常见的链表类型包括单向链表、循环链表、双向链表。
- 动态数组，又称列表，是基于数组实现的一种数据结构。它保留了数组的优势，同时可以灵活调整长度。列表的出现极大地提高了数组的易用性，但可能导致部分内存空间浪费。
- 下表总结并对比了数组与链表的各项特性。
@@ -23,7 +23,7 @@ comments: true
!!! note "缓存局部性"
在计算机中，数据读写速度排序是“硬盘 < 内存 < CPU 缓存”。当我们访问数组元素时，计算机不仅会加载它，还会缓存其周围的其它数据，从而借助高速缓存来提升后续操作的执行速度。链表则不然，计算机只能挨个地缓存各个结点，这样的多次“搬运”降低了整体效率。
在计算机中，数据读写速度排序是“硬盘 < 内存 < CPU 缓存”。当我们访问数组元素时，计算机不仅会加载它，还会缓存其周围的其它数据，从而借助高速缓存来提升后续操作的执行速度。链表则不然，计算机只能挨个地缓存各个节点，这样的多次“搬运”降低了整体效率。
- 下表对比了数组与链表在各种操作上的效率。