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

build

Browse Source
This commit is contained in:
krahets
2023-03-12 18:46:03 +08:00
parent 209d82a8cc
commit f6b9a75c8f
23 changed files with 406 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
chapter_stack_and_queue/deque.md
View File

@@ -89,7 +89,7 @@ comments: true
```python title="deque.py"
""" 初始化双向队列 """
deque = deque()
deque: Deque[int] = collections.deque()
""" 元素入队 """
deque.append(2) # 添加至队尾
@@ -99,18 +99,18 @@ comments: true
deque.appendleft(1)
""" 访问元素 """
front = deque[0] # 队首元素
rear = deque[-1] # 队尾元素
front: int = deque[0] # 队首元素
rear: int = deque[-1] # 队尾元素
""" 元素出队 """
pop_front = deque.popleft() # 队首元素出队
pop_rear = deque.pop() # 队尾元素出队
pop_front: int = deque.popleft() # 队首元素出队
pop_rear: int = deque.pop() # 队尾元素出队
""" 获取双向队列的长度 """
size = len(deque)
size: int = len(deque)
""" 判断双向队列是否为空 """
is_empty = len(deque) == 0
is_empty: bool = len(deque) == 0
```
=== "Go"
@@ -590,28 +590,29 @@ comments: true
```python title="linkedlist_deque.py"
class ListNode:
""" 双向链表结点 """
def __init__(self, val):
def __init__(self, val: int) -> None:
""" 构造方法 """
self.val = val
self.next = None # 后继结点引用（指针）
self.prev = None # 前驱结点引用（指针）
self.val: int = val
self.next: Optional[ListNode] = None # 后继结点引用（指针）
self.prev: Optional[ListNode] = None # 前驱结点引用（指针）
class LinkedListDeque:
""" 基于双向链表实现的双向队列 """
def __init__(self):
def __init__(self) -> None:
""" 构造方法 """
self.front, self.rear = None, None # 头结点 front ，尾结点 rear
self.__size = 0 # 双向队列的长度
self.front: Optional[ListNode] = None # 头结点 front
self.rear: Optional[ListNode] = None # 尾结点 rear
self.__size: int = 0 # 双向队列的长度
def size(self):
def size(self) -> int:
""" 获取双向队列的长度 """
return self.__size
def is_empty(self):
def is_empty(self) -> bool:
""" 判断双向队列是否为空 """
return self.size() == 0
def push(self, num, is_front):
def push(self, num: int, is_front: bool) -> None:
""" 入队操作 """
node = ListNode(num)
# 若链表为空，则令 front, rear 都指向 node
@@ -631,33 +632,33 @@ comments: true
self.rear = node # 更新尾结点
self.__size += 1 # 更新队列长度
def push_first(self, num):
def push_first(self, num: int) -> None:
""" 队首入队 """
self.push(num, True)
def push_last(self, num):
def push_last(self, num: int) -> None:
""" 队尾入队 """
self.push(num, False)
def poll(self, is_front):
def poll(self, is_front: bool) -> int:
""" 出队操作 """
# 若队列为空，直接返回 None
if self.is_empty():
return None
# 队首出队操作
if is_front:
val = self.front.val # 暂存头结点值
val: int = self.front.val # 暂存头结点值
# 删除头结点
fnext = self.front.next
fnext: Optional[ListNode] = self.front.next
if fnext != None:
fnext.prev = None
self.front.next = None
self.front = fnext # 更新头结点
# 队尾出队操作
else:
val = self.rear.val # 暂存尾结点值
val: int = self.rear.val # 暂存尾结点值
# 删除尾结点
rprev = self.rear.prev
rprev: Optional[ListNode] = self.rear.prev
if rprev != None:
rprev.next = None
self.rear.prev = None
@@ -665,26 +666,26 @@ comments: true
self.__size -= 1 # 更新队列长度
return val
def poll_first(self):
def poll_first(self) -> int:
""" 队首出队 """
return self.poll(True)
def poll_last(self):
def poll_last(self) -> int:
""" 队尾出队 """
return self.poll(False)
def peek_first(self):
def peek_first(self) -> int:
""" 访问队首元素 """
return None if self.is_empty() else self.front.val
def peek_last(self):
def peek_last(self) -> int:
""" 访问队尾元素 """
return None if self.is_empty() else self.rear.val
def to_array(self):
def to_array(self) -> List[int]:
""" 返回数组用于打印 """
node = self.front
res = [0] * self.size()
node: Optional[ListNode] = self.front
res: List[int] = [0] * self.size()
for i in range(self.size()):
res[i] = node.val
node = node.next
@@ -1594,86 +1595,87 @@ comments: true
```python title="array_deque.py"
class ArrayDeque:
""" 基于环形数组实现的双向队列 """
def __init__(self, capacity):
""" 构造方法 """
self.nums = [0] * capacity
self.front = 0
self.que_size = 0
def capacity(self):
def __init__(self, capacity: int) -> None:
""" 构造方法 """
self.__nums: List[int] = [0] * capacity
self.__front: int = 0
self.__size: int = 0
def capacity(self) -> int:
""" 获取双向队列的容量 """
return len(self.nums)
return len(self.__nums)
def size(self):
def size(self) -> int:
""" 获取双向队列的长度 """
return self.que_size
return self.__size
def is_empty(self):
def is_empty(self) -> bool:
""" 判断双向队列是否为空 """
return self.que_size == 0
return self.__size == 0
def index(self, i):
def index(self, i: int) -> int:
""" 计算环形数组索引 """
# 通过取余操作实现数组首尾相连
# 当 i 越过数组尾部后，回到头部
# 当 i 越过数组头部后，回到尾部
return (i + self.capacity()) % self.capacity()
def push_first(self, num):
def push_first(self, num: int) -> None:
""" 队首入队 """
if self.que_size == self.capacity():
if self.__size == self.capacity():
print("双向队列已满")
return
# 队首指针向左移动一位
# 通过取余操作，实现 front 越过数组头部后回到尾部
self.front = self.index(self.front-1)
self.__front = self.index(self.__front - 1)
# 将 num 添加至队首
self.nums[self.front] = num
self.que_size += 1
self.__nums[self.__front] = num
self.__size += 1
def push_last(self, num):
def push_last(self, num: int) -> None:
""" 队尾入队 """
if self.que_size == self.capacity():
if self.__size == self.capacity():
print("双向队列已满")
return
# 计算尾指针，指向队尾索引 + 1
rear = self.index(self.front + self.que_size)
rear = self.index(self.__front + self.__size)
# 将 num 添加至队尾
self.nums[rear] = num
self.que_size += 1
self.__nums[rear] = num
self.__size += 1
def poll_first(self):
def poll_first(self) -> int:
""" 队首出队 """
num = self.peek_first()
# 队首指针向后移动一位
self.front = self.index(self.front+1)
self.que_size -= 1
self.__front = self.index(self.__front + 1)
self.__size -= 1
return num
def poll_last(self):
def poll_last(self) -> int:
""" 队尾出队 """
num = self.peek_last()
self.que_size -= 1
self.__size -= 1
return num
def peek_first(self):
def peek_first(self) -> int:
""" 访问队首元素 """
assert not self.is_empty(), "双向队列为空"
return self.nums[self.front]
return self.__nums[self.__front]
def peek_last(self):
def peek_last(self) -> int:
""" 访问队尾元素 """
assert not self.is_empty(), "双向队列为空"
# 计算尾元素索引
last = self.index(self.front + self.que_size - 1)
return self.nums[last]
last = self.index(self.__front + self.__size - 1)
return self.__nums[last]
def to_array(self):
def to_array(self) -> List[int]:
""" 返回数组用于打印 """
# 仅转换有效长度范围内的列表元素
res = []
for i in range(self.que_size):
res.append(self.nums[self.index(self.front+i)])
for i in range(self.__size):
res.append(self.__nums[self.index(self.__front + i)])
return res
```

58
chapter_stack_and_queue/queue.md
View File

@@ -86,7 +86,7 @@ comments: true
""" 初始化队列 """
# 在 Python 中，我们一般将双向队列类 deque 看作队列使用
# 虽然 queue.Queue() 是纯正的队列类，但不太好用，因此不建议
que = collections.deque()
que: Deque[int] = collections.deque()
""" 元素入队 """
que.append(1)
@@ -96,16 +96,16 @@ comments: true
que.append(4)
""" 访问队首元素 """
front = que[0];
front: int = que[0];
""" 元素出队 """
pop = que.popleft()
pop: int = que.popleft()
""" 获取队列的长度 """
size = len(que)
size: int = len(que)
""" 判断队列是否为空 """
is_empty = len(que) == 0
is_empty: bool = len(que) == 0
```
=== "Go"
@@ -431,19 +431,19 @@ comments: true
""" 基于链表实现的队列 """
def __init__(self):
""" 构造方法 """
self.__front = None # 头结点 front
self.__rear = None # 尾结点 rear
self.__size = 0
self.__front: Optional[ListNode] = None # 头结点 front
self.__rear: Optional[ListNode] = None # 尾结点 rear
self.__size: int = 0
def size(self):
def size(self) -> int:
""" 获取队列的长度 """
return self.__size
def is_empty(self):
def is_empty(self) -> bool:
""" 判断队列是否为空 """
return not self.__front
def push(self, num):
def push(self, num: int) -> None:
""" 入队 """
# 尾结点后添加 num
node = ListNode(num)
@@ -457,7 +457,7 @@ comments: true
self.__rear = node
self.__size += 1
def poll(self):
def poll(self) -> int:
""" 出队 """
num = self.peek()
# 删除头结点
@@ -465,14 +465,14 @@ comments: true
self.__size -= 1
return num
def peek(self):
def peek(self) -> int:
""" 访问队首元素 """
if self.size() == 0:
print("队列为空")
return False
return self.__front.val
def to_list(self):
def to_list(self) -> List[int]:
""" 转化为列表用于打印 """
queue = []
temp = self.__front
@@ -1104,51 +1104,51 @@ comments: true
```python title="array_queue.py"
class ArrayQueue:
""" 基于环形数组实现的队列 """
def __init__(self, size):
def __init__(self, size: int) -> None:
""" 构造方法 """
self.__nums = [0] * size # 用于存储队列元素的数组
self.__front = 0 # 队首指针，指向队首元素
self.__size = 0 # 队列长度
self.__nums: List[int] = [0] * size # 用于存储队列元素的数组
self.__front: int = 0 # 队首指针，指向队首元素
self.__size: int = 0 # 队列长度
def capacity(self):
def capacity(self) -> int:
""" 获取队列的容量 """
return len(self.__nums)
def size(self):
def size(self) -> int:
""" 获取队列的长度 """
return self.__size
def is_empty(self):
def is_empty(self) -> bool:
""" 判断队列是否为空 """
return self.__size == 0
def push(self, num):
def push(self, num: int) -> None:
""" 入队 """
assert self.__size < self.capacity(), "队列已满"
# 计算尾指针，指向队尾索引 + 1
# 通过取余操作，实现 rear 越过数组尾部后回到头部
rear = (self.__front + self.__size) % self.capacity()
rear: int = (self.__front + self.__size) % self.capacity()
# 将 num 添加至队尾
self.__nums[rear] = num
self.__size += 1
def poll(self):
def poll(self) -> int:
""" 出队 """
num = self.peek()
num: int = self.peek()
# 队首指针向后移动一位，若越过尾部则返回到数组头部
self.__front = (self.__front + 1) % self.capacity()
self.__size -= 1
return num
def peek(self):
def peek(self) -> int:
""" 访问队首元素 """
assert not self.is_empty(), "队列为空"
return self.__nums[self.__front]
def to_list(self):
def to_list(self) -> List[int]:
""" 返回列表用于打印 """
res = [0] * self.size()
j = self.__front
res: List[int] = [0] * self.size()
j: int = self.__front
for i in range(self.size()):
res[i] = self.__nums[(j % self.capacity())]
j += 1

46
chapter_stack_and_queue/stack.md
View File

@@ -87,7 +87,7 @@ comments: true
```python title="stack.py"
""" 初始化栈 """
# Python 没有内置的栈类，可以把 List 当作栈来使用
stack = []
stack: List[int] = []
""" 元素入栈 """
stack.append(1)
@@ -97,16 +97,16 @@ comments: true
stack.append(4)
""" 访问栈顶元素 """
peek = stack[-1]
peek: int = stack[-1]
""" 元素出栈 """
pop = stack.pop()
pop: int = stack.pop()
""" 获取栈的长度 """
size = len(stack)
size: int = len(stack)
""" 判断是否为空 """
is_empty = len(stack) == 0
is_empty: bool = len(stack) == 0
```
=== "Go"
@@ -411,40 +411,40 @@ comments: true
""" 基于链表实现的栈 """
def __init__(self):
""" 构造方法 """
self.__peek = None
self.__size = 0
self.__peek: Optional[ListNode] = None
self.__size: int = 0
def size(self):
def size(self) -> int:
""" 获取栈的长度 """
return self.__size
def is_empty(self):
def is_empty(self) -> bool:
""" 判断栈是否为空 """
return not self.__peek
def push(self, val):
def push(self, val: int) -> None:
""" 入栈 """
node = ListNode(val)
node.next = self.__peek
self.__peek = node
self.__size += 1
def pop(self):
def pop(self) -> int:
""" 出栈 """
num = self.peek()
num: int = self.peek()
self.__peek = self.__peek.next
self.__size -= 1
return num
def peek(self):
def peek(self) -> int:
""" 访问栈顶元素 """
# 判空处理
if not self.__peek: return None
return self.__peek.val
def to_list(self):
def to_list(self) -> List[int]:
""" 转化为列表用于打印 """
arr = []
arr: List[int] = []
node = self.__peek
while node:
arr.append(node.val)
@@ -951,33 +951,33 @@ comments: true
```python title="array_stack.py"
class ArrayStack:
""" 基于数组实现的栈 """
def __init__(self):
def __init__(self) -> None:
""" 构造方法 """
self.__stack = []
self.__stack: List[int] = []
def size(self):
def size(self) -> int:
""" 获取栈的长度 """
return len(self.__stack)
def is_empty(self):
def is_empty(self) -> bool:
""" 判断栈是否为空 """
return self.__stack == []
def push(self, item):
def push(self, item: int) -> None:
""" 入栈 """
self.__stack.append(item)
def pop(self):
def pop(self) -> int:
""" 出栈 """
assert not self.is_empty(), "栈为空"
return self.__stack.pop()
def peek(self):
def peek(self) -> int:
""" 访问栈顶元素 """
assert not self.is_empty(), "栈为空"
return self.__stack[-1]
def to_list(self):
def to_list(self) -> List[int]:
""" 返回列表用于打印 """
return self.__stack
```