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

build

Browse Source
This commit is contained in:
krahets
2023-04-09 05:12:22 +08:00
parent 01d05cc1f0
commit 37f11aff68
27 changed files with 265 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
chapter_array_and_linkedlist/array.md
View File

@@ -150,7 +150,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```python title="array.py"
def random_access(nums: list[int]) -> int:
""" 随机访问元素 """
"""随机访问元素"""
# 在区间 [0, len(nums)-1] 中随机抽取一个数字
random_index = random.randint(0, len(nums) - 1)
# 获取并返回随机元素
@@ -286,7 +286,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```python title="array.py"
def extend(nums: list[int], enlarge: int) -> list[int]:
""" 扩展数组长度 """
"""扩展数组长度"""
# 初始化一个扩展长度后的数组
res = [0] * (len(nums) + enlarge)
# 将原数组中的所有元素复制到新数组
@@ -441,7 +441,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```python title="array.py"
def insert(nums: list[int], num: int, index: int) -> None:
""" 在数组的索引 index 处插入元素 num """
"""在数组的索引 index 处插入元素 num"""
# 把索引 index 以及之后的所有元素向后移动一位
for i in range(len(nums) - 1, index, -1):
nums[i] = nums[i - 1]
@@ -561,7 +561,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```python title="array.py"
def remove(nums: list[int], index: int) -> None:
""" 删除索引 index 处元素 """
"""删除索引 index 处元素"""
# 把索引 index 之后的所有元素向前移动一位
for i in range(index, len(nums) - 1):
nums[i] = nums[i + 1]
@@ -693,7 +693,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```python title="array.py"
def traverse(nums: list[int]) -> None:
""" 遍历数组 """
"""遍历数组"""
count = 0
# 通过索引遍历数组
for i in range(len(nums)):
@@ -849,7 +849,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```python title="array.py"
def find(nums: list[int], target: int) -> int:
""" 在数组中查找指定元素 """
"""在数组中查找指定元素"""
for i in range(len(nums)):
if nums[i] == target:
return i

14
chapter_array_and_linkedlist/linked_list.md
View File

@@ -4,11 +4,11 @@ comments: true
# 4.2.   链表
内存空间是所有程序的公共资源，排除已被占用的内存空间，空闲内存空间通常散落在内存各处。在上一节中，我们提到存储数组的内存空间必须是连续的，而当我们需要申请一个非常大的数组时，空闲内存中可能没有这么大的连续空间。
内存空间是所有程序的公共资源，排除已被占用的内存空间，空闲内存空间通常散落在内存各处。在上一节中，我们提到存储数组的内存空间必须是连续的，而当我们需要申请一个非常大的数组时，空闲内存中可能没有这么大的连续空间。与数组相比，链表更具灵活性，它可以被存储在非连续的内存空间中。
与数组相比，链表更具灵活性，因为它可以存储在非连续的内存空间。「链表 Linked List」是一种线性数据结构，其每个元素都是一个节点对象，各个节点之间通过指针连接，从当前节点通过指针可以访问到下一个节点。由于指针记录了下个节点的内存地址，因此无需保证内存地址的连续性，从而可以将各个节点分散存储在内存各处。
「链表 Linked List」是一种线性数据结构，其每个元素都是一个节点对象，各个节点之间通过指针连接，从当前节点通过指针可以访问到下一个节点。**由于指针记录了下个节点的内存地址，因此无需保证内存地址的连续性**，从而可以将各个节点分散存储在内存各处。
链表「节点 Node」包含两项数据，一是节点「值 Value」，二是指向下一节点的「指针 Pointer」，或称指向下一节点的「引用 Reference」。
链表「节点 Node」包含两项数据，一是节点「值 Value」，二是指向下一节点的「指针 Pointer」，或称「引用 Reference」。
![链表定义与存储方式](linked_list.assets/linkedlist_definition.png)
@@ -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
@@ -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
@@ -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
@@ -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:

39
chapter_array_and_linkedlist/list.md
View File

@@ -934,35 +934,36 @@ comments: true
```python title="my_list.py"
class MyList:
""" 列表类简易实现 """
"""列表类简易实现"""
def __init__(self):
""" 构造方法 """
self.__capacity: int = 10 # 列表容量
"""构造方法"""
self.__capacity: int = 10 # 列表容量
self.__nums: my_list[int] = [0] * self.__capacity # 数组（存储列表元素）
self.__size: int = 0 # 列表长度（即当前元素数量）
self.__extend_ratio: int = 2 # 每次列表扩容的倍数
self.__size: int = 0 # 列表长度（即当前元素数量）
self.__extend_ratio: int = 2 # 每次列表扩容的倍数
def size(self) -> int:
""" 获取列表长度（即当前元素数量） """
"""获取列表长度（即当前元素数量）"""
return self.__size
def capacity(self) -> int:
""" 获取列表容量 """
"""获取列表容量"""
return self.__capacity
def get(self, index: int) -> int:
""" 访问元素 """
"""访问元素"""
# 索引如果越界则抛出异常，下同
assert index >= 0 and index < self.__size, "索引越界"
return self.__nums[index]
def set(self, num: int, index: int) -> None:
""" 更新元素 """
"""更新元素"""
assert index >= 0 and index < self.__size, "索引越界"
self.__nums[index] = num
def add(self, num: int) -> None:
""" 尾部添加元素 """
"""尾部添加元素"""
# 元素数量超出容量时，触发扩容机制
if self.size() == self.capacity():
self.extend_capacity()
@@ -970,7 +971,7 @@ comments: true
self.__size += 1
def insert(self, num: int, index: int) -> None:
""" 中间插入元素 """
"""中间插入元素"""
assert index >= 0 and index < self.__size, "索引越界"
# 元素数量超出容量时，触发扩容机制
if self.__size == self.capacity():
@@ -983,7 +984,7 @@ comments: true
self.__size += 1
def remove(self, index: int) -> int:
""" 删除元素 """
"""删除元素"""
assert index >= 0 and index < self.__size, "索引越界"
num = self.__nums[index]
# 索引 i 之后的元素都向前移动一位
@@ -995,15 +996,15 @@ comments: true
return num
def extend_capacity(self) -> None:
""" 列表扩容 """
"""列表扩容"""
# 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
self.__nums = self.__nums + [0] * self.capacity() * (self.__extend_ratio - 1)
# 更新列表容量
self.__capacity = len(self.__nums)
def to_array(self) -> list[int]:
""" 返回有效长度的列表 """
return self.__nums[:self.__size]
"""返回有效长度的列表"""
return self.__nums[: self.__size]
```
=== "Go"