yetao
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
pull/944/head
krahets 2 years ago
parent 37f11aff68
commit 2289822dfd
13 changed files with 59 additions and 58 deletions
Show Stats Download Patch File Download Diff File

4
chapter_array_and_linkedlist/array.md
Unescape View File

@ -35,7 +35,7 @@ comments: true
=== "Python" === "Python"
```python title="array.py" ```python title="array.py"
""" 初始化数组 """ # 初始化数组
arr: List[int] = [0] * 5 # [ 0, 0, 0, 0, 0 ] arr: List[int] = [0] * 5 # [ 0, 0, 0, 0, 0 ]
nums: List[int] = [1, 3, 2, 5, 4] nums: List[int] = [1, 3, 2, 5, 4]
``` ```
@ -527,7 +527,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
} }
``` ```
删除元素也是类似，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。值得注意的是，删除元素后，原先末尾的元素变得“无意义”了，我们无需特意去修改它。 删除元素也类似，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。值得注意的是，删除元素后，原先末尾的元素变得“无意义”了，我们无需特意去修改它。
![数组删除元素](array.assets/array_remove_element.png) ![数组删除元素](array.assets/array_remove_element.png)

6
chapter_array_and_linkedlist/linked_list.md
Unescape View File

@ -39,8 +39,8 @@ comments: true
=== "Python" === "Python"
```python title="" ```python title=""
""" 链表节点类 """
class ListNode: class ListNode:
"""链表节点类"""
def __init__(self, val: int): def __init__(self, val: int):
self.val: int = val # 节点值 self.val: int = val # 节点值
self.next: Optional[ListNode] = None # 指向下一节点的指针（引用） self.next: Optional[ListNode] = None # 指向下一节点的指针（引用）
@ -207,7 +207,7 @@ comments: true
=== "Python" === "Python"
```python title="linked_list.py" ```python title="linked_list.py"
""" 初始化链表 1 -> 3 -> 2 -> 5 -> 4 """ # 初始化链表 1 -> 3 -> 2 -> 5 -> 4
# 初始化各个节点 # 初始化各个节点
n0 = ListNode(1) n0 = ListNode(1)
n1 = ListNode(3) n1 = ListNode(3)
@ -934,8 +934,8 @@ comments: true
=== "Python" === "Python"
```python title="" ```python title=""
""" 双向链表节点类 """
class ListNode: class ListNode:
"""双向链表节点类"""
def __init__(self, val: int): def __init__(self, val: int):
self.val: int = val # 节点值 self.val: int = val # 节点值
self.next: Optional[ListNode] = None # 指向后继节点的指针（引用） self.next: Optional[ListNode] = None # 指向后继节点的指针（引用）

22
chapter_array_and_linkedlist/list.md
Unescape View File

@ -37,7 +37,7 @@ comments: true
=== "Python" === "Python"
```python title="list.py" ```python title="list.py"
""" 初始化列表 """ # 初始化列表
# 无初始值 # 无初始值
list1: List[int] = [] list1: List[int] = []
# 有初始值 # 有初始值
@ -135,10 +135,10 @@ comments: true
=== "Python" === "Python"
```python title="list.py" ```python title="list.py"
""" 访问元素 """ # 访问元素
num: int = list[1] # 访问索引 1 处的元素 num: int = list[1] # 访问索引 1 处的元素
""" 更新元素 """ # 更新元素
list[1] = 0 # 将索引 1 处的元素更新为 0 list[1] = 0 # 将索引 1 处的元素更新为 0
``` ```
@ -253,20 +253,20 @@ comments: true
=== "Python" === "Python"
```python title="list.py" ```python title="list.py"
""" 清空列表 """ # 清空列表
list.clear() list.clear()
""" 尾部添加元素 """ # 尾部添加元素
list.append(1) list.append(1)
list.append(3) list.append(3)
list.append(2) list.append(2)
list.append(5) list.append(5)
list.append(4) list.append(4)
""" 中间插入元素 """ # 中间插入元素
list.insert(3, 6) # 在索引 3 处插入数字 6 list.insert(3, 6) # 在索引 3 处插入数字 6
""" 删除元素 """ # 删除元素
list.pop(3) # 删除索引 3 处的元素 list.pop(3) # 删除索引 3 处的元素
``` ```
@ -433,12 +433,12 @@ comments: true
=== "Python" === "Python"
```python title="list.py" ```python title="list.py"
""" 通过索引遍历列表 """ # 通过索引遍历列表
count: int = 0 count: int = 0
for i in range(len(list)): for i in range(len(list)):
count += 1 count += 1
""" 直接遍历列表元素 """ # 直接遍历列表元素
count: int = 0 count: int = 0
for n in list: for n in list:
count += 1 count += 1
@ -571,7 +571,7 @@ comments: true
=== "Python" === "Python"
```python title="list.py" ```python title="list.py"
""" 拼接两个列表 """ # 拼接两个列表
list1: List[int] = [6, 8, 7, 10, 9] list1: List[int] = [6, 8, 7, 10, 9]
list += list1 # 将列表 list1 拼接到 list 之后 list += list1 # 将列表 list1 拼接到 list 之后
``` ```
@ -651,7 +651,7 @@ comments: true
=== "Python" === "Python"
```python title="list.py" ```python title="list.py"
""" 排序列表 """ # 排序列表
list.sort() # 排序后，列表元素从小到大排列 list.sort() # 排序后，列表元素从小到大排列
``` ```

8
chapter_computational_complexity/space_complexity.md
Unescape View File

@ -81,14 +81,14 @@ comments: true
=== "Python" === "Python"
```python title="" ```python title=""
""" 类 """
class Node: class Node:
"""类"""
def __init__(self, x: int): def __init__(self, x: int):
self.val: int = x # 节点值 self.val: int = x # 节点值
self.next: Optional[Node] = None # 指向下一节点的指针（引用） self.next: Optional[Node] = None # 指向下一节点的指针（引用）
""" 函数 """
def function() -> int: def function() -> int:
"""函数"""
# do something... # do something...
return 0 return 0
@ -419,13 +419,13 @@ comments: true
# do something # do something
return 0 return 0
""" 循环 O(1) """
def loop(n: int) -> None: def loop(n: int) -> None:
"""循环 O(1)"""
for _ in range(n): for _ in range(n):
function() function()
""" 递归 O(n) """
def recur(n: int) -> int: def recur(n: int) -> int:
"""递归 O(n)"""
if n == 1: return if n == 1: return
return recur(n - 1) return recur(n - 1)
``` ```

2
chapter_data_structure/data_and_memory.md
Unescape View File

@ -138,7 +138,7 @@ $$
=== "Python" === "Python"
```python title="" ```python title=""
""" Python 的 list 可以自由存储各种基本数据类型和对象 """ # Python 的 list 可以自由存储各种基本数据类型和对象
list = [0, 0.0, 'a', False] list = [0, 0.0, 'a', False]
``` ```

10
chapter_hashing/hash_map.md
Unescape View File

@ -86,10 +86,10 @@ comments: true
=== "Python" === "Python"
```python title="hash_map.py" ```python title="hash_map.py"
""" 初始化哈希表 """ # 初始化哈希表
mapp: Dict = {} mapp: Dict = {}
""" 添加操作 """ # 添加操作
# 在哈希表中添加键值对 (key, value) # 在哈希表中添加键值对 (key, value)
mapp[12836] = "小哈" mapp[12836] = "小哈"
mapp[15937] = "小啰" mapp[15937] = "小啰"
@ -97,11 +97,11 @@ comments: true
mapp[13276] = "小法" mapp[13276] = "小法"
mapp[10583] = "小鸭" mapp[10583] = "小鸭"
""" 查询操作 """ # 查询操作
# 向哈希表输入键 key ，得到值 value # 向哈希表输入键 key ，得到值 value
name: str = mapp[15937] name: str = mapp[15937]
""" 删除操作 """ # 删除操作
# 在哈希表中删除键值对 (key, value) # 在哈希表中删除键值对 (key, value)
mapp.pop(10583) mapp.pop(10583)
``` ```
@ -277,7 +277,7 @@ comments: true
=== "Python" === "Python"
```python title="hash_map.py" ```python title="hash_map.py"
""" 遍历哈希表 """ # 遍历哈希表
# 遍历键值对 key->value # 遍历键值对 key->value
for key, value in mapp.items(): for key, value in mapp.items():
print(key, "->", value) print(key, "->", value)

13
chapter_heap/heap.md
Unescape View File

@ -131,17 +131,18 @@ comments: true
# Python 的 heapq 模块默认实现小顶堆 # Python 的 heapq 模块默认实现小顶堆
# 考虑将“元素取负”后再入堆，这样就可以将大小关系颠倒，从而实现大顶堆 # 考虑将“元素取负”后再入堆，这样就可以将大小关系颠倒，从而实现大顶堆
# 在本示例中，flag = 1 时对应小顶堆，flag = -1 时对应大顶堆 # 在本示例中，flag = 1 时对应小顶堆，flag = -1 时对应大顶堆
""" 元素入堆 """
# 元素入堆
heapq.heappush(max_heap, flag * 1) heapq.heappush(max_heap, flag * 1)
heapq.heappush(max_heap, flag * 3) heapq.heappush(max_heap, flag * 3)
heapq.heappush(max_heap, flag * 2) heapq.heappush(max_heap, flag * 2)
heapq.heappush(max_heap, flag * 5) heapq.heappush(max_heap, flag * 5)
heapq.heappush(max_heap, flag * 4) heapq.heappush(max_heap, flag * 4)
""" 获取堆顶元素 """ # 获取堆顶元素
peek: int = flag * max_heap[0] # 5 peek: int = flag * max_heap[0] # 5
""" 堆顶元素出堆 """ # 堆顶元素出堆
# 出堆元素会形成一个从大到小的序列 # 出堆元素会形成一个从大到小的序列
val = flag * heapq.heappop(max_heap) # 5 val = flag * heapq.heappop(max_heap) # 5
val = flag * heapq.heappop(max_heap) # 4 val = flag * heapq.heappop(max_heap) # 4
@ -149,13 +150,13 @@ comments: true
val = flag * heapq.heappop(max_heap) # 2 val = flag * heapq.heappop(max_heap) # 2
val = flag * heapq.heappop(max_heap) # 1 val = flag * heapq.heappop(max_heap) # 1
""" 获取堆大小 """ # 获取堆大小
size: int = len(max_heap) size: int = len(max_heap)
""" 判断堆是否为空 """ # 判断堆是否为空
is_empty: bool = not max_heap is_empty: bool = not max_heap
""" 输入列表并建堆 """ # 输入列表并建堆
min_heap: List[int] = [1, 3, 2, 5, 4] min_heap: List[int] = [1, 3, 2, 5, 4]
heapq.heapify(min_heap) heapq.heapify(min_heap)
``` ```

2
chapter_preface/suggestions.md
Unescape View File

@ -61,7 +61,7 @@ comments: true
=== "Python" === "Python"
```python title="" ```python title=""
""" 标题注释，用于标注函数、类、测试样例等 """ """标题注释，用于标注函数、类、测试样例等"""
# 内容注释，用于详解代码 # 内容注释，用于详解代码

12
chapter_stack_and_queue/deque.md
Unescape View File

@ -88,28 +88,28 @@ comments: true
=== "Python" === "Python"
```python title="deque.py" ```python title="deque.py"
""" 初始化双向队列 """ # 初始化双向队列
deque: Deque[int] = collections.deque() deque: Deque[int] = collections.deque()
""" 元素入队 """ # 元素入队
deque.append(2) # 添加至队尾 deque.append(2) # 添加至队尾
deque.append(5) deque.append(5)
deque.append(4) deque.append(4)
deque.appendleft(3) # 添加至队首 deque.appendleft(3) # 添加至队首
deque.appendleft(1) deque.appendleft(1)
""" 访问元素 """ # 访问元素
front: int = deque[0] # 队首元素 front: int = deque[0] # 队首元素
rear: int = deque[-1] # 队尾元素 rear: int = deque[-1] # 队尾元素
""" 元素出队 """ # 元素出队
pop_front: int = deque.popleft() # 队首元素出队 pop_front: int = deque.popleft() # 队首元素出队
pop_rear: int = deque.pop() # 队尾元素出队 pop_rear: int = deque.pop() # 队尾元素出队
""" 获取双向队列的长度 """ # 获取双向队列的长度
size: int = len(deque) size: int = len(deque)
""" 判断双向队列是否为空 """ # 判断双向队列是否为空
is_empty: bool = len(deque) == 0 is_empty: bool = len(deque) == 0
``` ```

14
chapter_stack_and_queue/queue.md
Unescape View File

@ -4,7 +4,7 @@ comments: true
# 5.2.   队列 # 5.2.   队列
「队列 Queue」是一种遵循「先入先出 first in, first out」数据操作规则的线性数据结构。顾名思义，队列模拟的是排队现象，即外面的人不断加入队列尾部，而处于队列头部的人不断地离开。 「队列 Queue」是一种遵循先入先出（first in, first out）数据操作规则的线性数据结构。顾名思义，队列模拟的是排队现象，即外面的人不断加入队列尾部，而处于队列头部的人不断地离开。
我们将队列头部称为「队首」，队列尾部称为「队尾」，将把元素加入队尾的操作称为「入队」，删除队首元素的操作称为「出队」。 我们将队列头部称为「队首」，队列尾部称为「队尾」，将把元素加入队尾的操作称为「入队」，删除队首元素的操作称为「出队」。
@ -83,28 +83,28 @@ comments: true
=== "Python" === "Python"
```python title="queue.py" ```python title="queue.py"
""" 初始化队列 """ # 初始化队列
# 在 Python 中，我们一般将双向队列类 deque 看作队列使用 # 在 Python 中，我们一般将双向队列类 deque 看作队列使用
# 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议 # 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
que: Deque[int] = collections.deque() que: Deque[int] = collections.deque()
""" 元素入队 """ # 元素入队
que.append(1) que.append(1)
que.append(3) que.append(3)
que.append(2) que.append(2)
que.append(5) que.append(5)
que.append(4) que.append(4)
""" 访问队首元素 """ # 访问队首元素
front: int = que[0]; front: int = que[0];
""" 元素出队 """ # 元素出队
pop: int = que.popleft() pop: int = que.popleft()
""" 获取队列的长度 """ # 获取队列的长度
size: int = len(que) size: int = len(que)
""" 判断队列是否为空 """ # 判断队列是否为空
is_empty: bool = len(que) == 0 is_empty: bool = len(que) == 0
``` ```

14
chapter_stack_and_queue/stack.md
Unescape View File

@ -4,7 +4,7 @@ comments: true
# 5.1.   栈 # 5.1.   栈
「栈 Stack」是一种遵循「先入后出 first in, last out」数据操作规则的线性数据结构。我们可以将栈类比为放在桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。 「栈 Stack」是一种遵循先入后出（first in, last out）数据操作规则的线性数据结构。我们可以将栈类比为放在桌面上的一摞盘子，如果需要拿出底部的盘子，则需要先将上面的盘子依次取出。
“盘子”是一种形象比喻，我们将盘子替换为任意一种元素（例如整数、字符、对象等），就得到了栈数据结构。 “盘子”是一种形象比喻，我们将盘子替换为任意一种元素（例如整数、字符、对象等），就得到了栈数据结构。
@ -85,27 +85,27 @@ comments: true
=== "Python" === "Python"
```python title="stack.py" ```python title="stack.py"
""" 初始化栈 """ # 初始化栈
# Python 没有内置的栈类，可以把 List 当作栈来使用 # Python 没有内置的栈类，可以把 List 当作栈来使用
stack: List[int] = [] stack: List[int] = []
""" 元素入栈 """ # 元素入栈
stack.append(1) stack.append(1)
stack.append(3) stack.append(3)
stack.append(2) stack.append(2)
stack.append(5) stack.append(5)
stack.append(4) stack.append(4)
""" 访问栈顶元素 """ # 访问栈顶元素
peek: int = stack[-1] peek: int = stack[-1]
""" 元素出栈 """ # 元素出栈
pop: int = stack.pop() pop: int = stack.pop()
""" 获取栈的长度 """ # 获取栈的长度
size: int = len(stack) size: int = len(stack)
""" 判断是否为空 """ # 判断是否为空
is_empty: bool = len(stack) == 0 is_empty: bool = len(stack) == 0
``` ```

2
chapter_tree/avl_tree.md
Unescape View File

@ -60,8 +60,8 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
=== "Python" === "Python"
```python title="" ```python title=""
""" AVL 树节点类 """
class TreeNode: class TreeNode:
"""AVL 树节点类"""
def __init__(self, val: int): def __init__(self, val: int):
self.val: int = val # 节点值 self.val: int = val # 节点值
self.height: int = 0 # 节点高度 self.height: int = 0 # 节点高度

8
chapter_tree/binary_tree.md
Unescape View File

@ -33,8 +33,8 @@ comments: true
=== "Python" === "Python"
```python title="" ```python title=""
""" 二叉树节点类 """
class TreeNode: class TreeNode:
"""二叉树节点类"""
def __init__(self, val: int): def __init__(self, val: int):
self.val: int = val # 节点值 self.val: int = val # 节点值
self.left: Optional[TreeNode] = None # 左子节点指针 self.left: Optional[TreeNode] = None # 左子节点指针
@ -196,7 +196,7 @@ comments: true
=== "Python" === "Python"
```python title="binary_tree.py" ```python title="binary_tree.py"
""" 初始化二叉树 """ # 初始化二叉树
# 初始化节点 # 初始化节点
n1 = TreeNode(val=1) n1 = TreeNode(val=1)
n2 = TreeNode(val=2) n2 = TreeNode(val=2)
@ -338,7 +338,7 @@ comments: true
=== "Python" === "Python"
```python title="binary_tree.py" ```python title="binary_tree.py"
""" 插入与删除节点 """ # 插入与删除节点
p = TreeNode(0) p = TreeNode(0)
# 在 n1 -> n2 中间插入节点 P # 在 n1 -> n2 中间插入节点 P
n1.left = p n1.left = p
@ -526,7 +526,7 @@ comments: true
=== "Python" === "Python"
```python title="" ```python title=""
""" 二叉树的数组表示 """ # 二叉树的数组表示
# 直接使用 None 来表示空位 # 直接使用 None 来表示空位
tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15] tree = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
``` ```

Write Preview
Loading…
Cancel
Save