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

build

Browse Source
This commit is contained in:
krahets
2023-03-03 02:46:12 +08:00
parent 122805bdc9
commit cf9d102ed5
24 changed files with 320 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

161
chapter_stack_and_queue/deque.md
View File

@@ -590,30 +590,31 @@ comments: true
=== "Python"
```python title="linkedlist_deque.py"
""" 双向链表结点 """
class ListNode:
""" 双向链表结点 """
def __init__(self, val):
""" 构造方法 """
self.val = val
self.next = None # 后继结点引用（指针）
self.prev = None # 前驱结点引用（指针）
""" 基于双向链表实现的双向队列 """
class LinkedListDeque:
""" 构造方法 """
""" 基于双向链表实现的双向队列 """
def __init__(self):
""" 构造方法 """
self.front, self.rear = None, None # 头结点 front ，尾结点 rear
self.__size = 0 # 双向队列的长度
""" 获取双向队列的长度 """
def size(self):
""" 获取双向队列的长度 """
return self.__size
""" 判断双向队列是否为空 """
def is_empty(self):
""" 判断双向队列是否为空 """
return self.size() == 0
""" 入队操作 """
def push(self, num, is_front):
""" 入队操作 """
node = ListNode(num)
# 若链表为空，则令 front, rear 都指向 node
if self.is_empty():
@@ -632,16 +633,16 @@ comments: true
self.rear = node # 更新尾结点
self.__size += 1 # 更新队列长度
""" 队首入队 """
def push_first(self, num):
""" 队首入队 """
self.push(num, True)
""" 队尾入队 """
def push_last(self, num):
""" 队尾入队 """
self.push(num, False)
""" 出队操作 """
def poll(self, is_front):
""" 出队操作 """
# 若队列为空，直接返回 None
if self.is_empty():
return None
@@ -666,24 +667,24 @@ comments: true
self.__size -= 1 # 更新队列长度
return val
""" 队首出队 """
def poll_first(self):
""" 队首出队 """
return self.poll(True)
""" 队尾出队 """
def poll_last(self):
""" 队尾出队 """
return self.poll(False)
""" 访问队首元素 """
def peek_first(self):
""" 访问队首元素 """
return None if self.is_empty() else self.front.val
""" 访问队尾元素 """
def peek_last(self):
""" 访问队尾元素 """
return None if self.is_empty() else self.rear.val
""" 返回数组用于打印 """
def to_array(self):
""" 返回数组用于打印 """
node = self.front
res = [0] * self.size()
for i in range(self.size()):
@@ -790,106 +791,106 @@ comments: true
/* 基于双向链表实现的双向队列 */
class LinkedListDeque {
front; // 头结点 front
rear; // 尾结点 rear
len; // 双向队列的长度
#front; // 头结点 front
#rear; // 尾结点 rear
#queSize; // 双向队列的长度
constructor() {
this.front = null;
this.rear = null;
this.len = 0;
this.#front = null;
this.#rear = null;
this.#queSize = 0;
}
/* 队尾入队操作 */
pushLast(val) {
const node = new ListNode(val);
// 若链表为空，则令 front, rear 都指向 node
if (this.len === 0) {
this.front = node;
this.rear = node;
if (this.#queSize === 0) {
this.#front = node;
this.#rear = node;
} else {
// 将 node 添加至链表尾部
this.rear.next = node;
node.prev = this.rear;
this.rear = node; // 更新尾结点
this.#rear.next = node;
node.prev = this.#rear;
this.#rear = node; // 更新尾结点
}
this.len++;
this.#queSize++;
}
/* 队首入队操作 */
pushFirst(val) {
const node = new ListNode(val);
// 若链表为空，则令 front, rear 都指向 node
if (this.len === 0) {
this.front = node;
this.rear = node;
if (this.#queSize === 0) {
this.#front = node;
this.#rear = node;
} else {
// 将 node 添加至链表头部
this.front.prev = node;
node.next = this.front;
this.front = node; // 更新头结点
this.#front.prev = node;
node.next = this.#front;
this.#front = node; // 更新头结点
}
this.len++;
this.#queSize++;
}
/* 队尾出队操作 */
pollLast() {
if (this.len === 0) {
if (this.#queSize === 0) {
return null;
}
const value = this.rear.val; // 存储尾结点值
const value = this.#rear.val; // 存储尾结点值
// 删除尾结点
let temp = this.rear.prev;
let temp = this.#rear.prev;
if (temp !== null) {
temp.next = null;
this.rear.prev = null;
this.#rear.prev = null;
}
this.rear = temp; // 更新尾结点
this.len--;
this.#rear = temp; // 更新尾结点
this.#queSize--;
return value;
}
/* 队首出队操作 */
pollFirst() {
if (this.len === 0) {
if (this.#queSize === 0) {
return null;
}
const value = this.front.val; // 存储尾结点值
const value = this.#front.val; // 存储尾结点值
// 删除头结点
let temp = this.front.next;
let temp = this.#front.next;
if (temp !== null) {
temp.prev = null;
this.front.next = null;
this.#front.next = null;
}
this.front = temp; // 更新头结点
this.len--;
this.#front = temp; // 更新头结点
this.#queSize--;
return value;
}
/* 访问队尾元素 */
peekLast() {
return this.len === 0 ? null : this.rear.val;
return this.#queSize === 0 ? null : this.#rear.val;
}
/* 访问队首元素 */
peekFirst() {
return this.len === 0 ? null : this.front.val;
return this.#queSize === 0 ? null : this.#front.val;
}
/* 获取双向队列的长度 */
size() {
return this.len;
return this.#queSize;
}
/* 判断双向队列是否为空 */
isEmpty() {
return this.len === 0;
return this.#queSize === 0;
}
/* 打印双向队列 */
print() {
const arr = [];
let temp = this.front;
let temp = this.#front;
while (temp !== null) {
arr.push(temp.val);
temp = temp.next;
@@ -917,21 +918,21 @@ comments: true
/* 基于双向链表实现的双向队列 */
class LinkedListDeque {
front: ListNode; // 头结点 front
rear: ListNode; // 尾结点 rear
len: number; // 双向队列的长度
private front: ListNode; // 头结点 front
private rear: ListNode; // 尾结点 rear
private queSize: number; // 双向队列的长度
constructor() {
this.front = null;
this.rear = null;
this.len = 0;
this.queSize = 0;
}
/* 队尾入队操作 */
pushLast(val: number): void {
const node: ListNode = new ListNode(val);
// 若链表为空，则令 front, rear 都指向 node
if (this.len === 0) {
if (this.queSize === 0) {
this.front = node;
this.rear = node;
} else {
@@ -940,14 +941,14 @@ comments: true
node.prev = this.rear;
this.rear = node; // 更新尾结点
}
this.len++;
this.queSize++;
}
/* 队首入队操作 */
pushFirst(val: number): void {
const node: ListNode = new ListNode(val);
// 若链表为空，则令 front, rear 都指向 node
if (this.len === 0) {
if (this.queSize === 0) {
this.front = node;
this.rear = node;
} else {
@@ -956,12 +957,12 @@ comments: true
node.next = this.front;
this.front = node; // 更新头结点
}
this.len++;
this.queSize++;
}
/* 队尾出队操作 */
pollLast(): number {
if (this.len === 0) {
if (this.queSize === 0) {
return null;
}
const value: number = this.rear.val; // 存储尾结点值
@@ -972,13 +973,13 @@ comments: true
this.rear.prev = null;
}
this.rear = temp; // 更新尾结点
this.len--;
this.queSize--;
return value;
}
/* 队首出队操作 */
pollFirst(): number {
if (this.len === 0) {
if (this.queSize === 0) {
return null;
}
const value: number = this.front.val; // 存储尾结点值
@@ -989,28 +990,28 @@ comments: true
this.front.next = null;
}
this.front = temp; // 更新头结点
this.len--;
this.queSize--;
return value;
}
/* 访问队尾元素 */
peekLast(): number {
return this.len === 0 ? null : this.rear.val;
return this.queSize === 0 ? null : this.rear.val;
}
/* 访问队首元素 */
peekFirst(): number {
return this.len === 0 ? null : this.front.val;
return this.queSize === 0 ? null : this.front.val;
}
/* 获取双向队列的长度 */
size(): number {
return this.len;
return this.queSize;
}
/* 判断双向队列是否为空 */
isEmpty(): boolean {
return this.len === 0;
return this.queSize === 0;
}
/* 打印双向队列 */
@@ -1593,35 +1594,35 @@ comments: true
=== "Python"
```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):
""" 获取双向队列的容量 """
return len(self.nums)
""" 获取双向队列的长度 """
def size(self):
""" 获取双向队列的长度 """
return self.que_size
""" 判断双向队列是否为空 """
def is_empty(self):
""" 判断双向队列是否为空 """
return self.que_size == 0
""" 计算环形数组索引 """
def index(self, i):
""" 计算环形数组索引 """
# 通过取余操作实现数组首尾相连
# 当 i 越过数组尾部后，回到头部
# 当 i 越过数组头部后，回到尾部
return (i + self.capacity()) % self.capacity()
""" 队首入队 """
def push_first(self, num):
""" 队首入队 """
if self.que_size == self.capacity():
print("双向队列已满")
return
@@ -1632,8 +1633,8 @@ comments: true
self.nums[self.front] = num
self.que_size += 1
""" 队尾入队 """
def push_last(self, num):
""" 队尾入队 """
if self.que_size == self.capacity():
print("双向队列已满")
return
@@ -1643,34 +1644,34 @@ comments: true
self.nums[rear] = num
self.que_size += 1
""" 队首出队 """
def poll_first(self):
""" 队首出队 """
num = self.peek_first()
# 队首指针向后移动一位
self.front = self.index(self.front+1)
self.que_size -= 1
return num
""" 队尾出队 """
def poll_last(self):
""" 队尾出队 """
num = self.peek_last()
self.que_size -= 1
return num
""" 访问队首元素 """
def peek_first(self):
""" 访问队首元素 """
assert not self.is_empty(), "双向队列为空"
return self.nums[self.front]
""" 访问队尾元素 """
def peek_last(self):
""" 访问队尾元素 """
assert not self.is_empty(), "双向队列为空"
# 计算尾元素索引
last = self.index(self.front + self.que_size - 1)
return self.nums[last]
""" 返回数组用于打印 """
def to_array(self):
""" 返回数组用于打印 """
# 仅转换有效长度范围内的列表元素
res = []
for i in range(self.que_size):

40
chapter_stack_and_queue/queue.md
View File

@@ -429,23 +429,24 @@ comments: true
=== "Python"
```python title="linkedlist_queue.py"
""" 基于链表实现的队列 """
class LinkedListQueue:
""" 基于链表实现的队列 """
def __init__(self):
""" 构造方法 """
self.__front = None # 头结点 front
self.__rear = None # 尾结点 rear
self.__size = 0
""" 获取队列的长度 """
def size(self):
""" 获取队列的长度 """
return self.__size
""" 判断队列是否为空 """
def is_empty(self):
""" 判断队列是否为空 """
return not self.__front
""" 入队 """
def push(self, num):
""" 入队 """
# 尾结点后添加 num
node = ListNode(num)
# 如果队列为空，则令头、尾结点都指向该结点
@@ -458,23 +459,23 @@ comments: true
self.__rear = node
self.__size += 1
""" 出队 """
def poll(self):
""" 出队 """
num = self.peek()
# 删除头结点
self.__front = self.__front.next
self.__size -= 1
return num
""" 访问队首元素 """
def peek(self):
""" 访问队首元素 """
if self.size() == 0:
print("队列为空")
return False
return self.__front.val
""" 转化为列表用于打印 """
def to_list(self):
""" 转化为列表用于打印 """
queue = []
temp = self.__front
while temp:
@@ -614,7 +615,7 @@ comments: true
/* 基于链表实现的队列 */
class LinkedListQueue {
private front: ListNode | null; // 头结点 front
private rear: ListNode | null; // 尾结点 rear
private rear: ListNode | null; // 尾结点 rear
private queSize: number = 0;
constructor() {
@@ -651,8 +652,7 @@ comments: true
/* 出队 */
poll(): number {
const num = this.peek();
if (!this.front)
throw new Error("队列为空")
if (!this.front) throw new Error('队列为空');
// 删除头结点
this.front = this.front.next;
this.queSize--;
@@ -661,8 +661,7 @@ comments: true
/* 访问队首元素 */
peek(): number {
if (this.size === 0)
throw new Error("队列为空");
if (this.size === 0) throw new Error('队列为空');
return this.front!.val;
}
@@ -1105,27 +1104,28 @@ comments: true
=== "Python"
```python title="array_queue.py"
""" 基于环形数组实现的队列 """
class ArrayQueue:
""" 基于环形数组实现的队列 """
def __init__(self, size):
""" 构造方法 """
self.__nums = [0] * size # 用于存储队列元素的数组
self.__front = 0 # 队首指针，指向队首元素
self.__size = 0 # 队列长度
""" 获取队列的容量 """
def capacity(self):
""" 获取队列的容量 """
return len(self.__nums)
""" 获取队列的长度 """
def size(self):
""" 获取队列的长度 """
return self.__size
""" 判断队列是否为空 """
def is_empty(self):
""" 判断队列是否为空 """
return self.__size == 0
""" 入队 """
def push(self, num):
""" 入队 """
assert self.__size < self.capacity(), "队列已满"
# 计算尾指针，指向队尾索引 + 1
# 通过取余操作，实现 rear 越过数组尾部后回到头部
@@ -1134,21 +1134,21 @@ comments: true
self.__nums[rear] = num
self.__size += 1
""" 出队 """
def poll(self):
""" 出队 """
num = self.peek()
# 队首指针向后移动一位，若越过尾部则返回到数组头部
self.__front = (self.__front + 1) % self.capacity()
self.__size -= 1
return num
""" 访问队首元素 """
def peek(self):
""" 访问队首元素 """
assert not self.is_empty(), "队列为空"
return self.__nums[self.__front]
""" 返回列表用于打印 """
def to_list(self):
""" 返回列表用于打印 """
res = [0] * self.size()
j = self.__front
for i in range(self.size()):

56
chapter_stack_and_queue/stack.md
View File

@@ -410,42 +410,43 @@ comments: true
=== "Python"
```python title="linkedlist_stack.py"
""" 基于链表实现的栈 """
class LinkedListStack:
""" 基于链表实现的栈 """
def __init__(self):
""" 构造方法 """
self.__peek = None
self.__size = 0
""" 获取栈的长度 """
def size(self):
""" 获取栈的长度 """
return self.__size
""" 判断栈是否为空 """
def is_empty(self):
""" 判断栈是否为空 """
return not self.__peek
""" 入栈 """
def push(self, val):
""" 入栈 """
node = ListNode(val)
node.next = self.__peek
self.__peek = node
self.__size += 1
""" 出栈 """
def pop(self):
""" 出栈 """
num = self.peek()
self.__peek = self.__peek.next
self.__size -= 1
return num
""" 访问栈顶元素 """
def peek(self):
""" 访问栈顶元素 """
# 判空处理
if not self.__peek: return None
return self.__peek.val
""" 转化为列表用于打印 """
def to_list(self):
""" 转化为列表用于打印 """
arr = []
node = self.__peek
while node:
@@ -574,8 +575,8 @@ comments: true
```typescript title="linkedlist_stack.ts"
/* 基于链表实现的栈 */
class LinkedListStack {
private stackPeek: ListNode | null; // 将头结点作为栈顶
private stkSize: number = 0; // 栈的长度
private stackPeek: ListNode | null; // 将头结点作为栈顶
private stkSize: number = 0; // 栈的长度
constructor() {
this.stackPeek = null;
@@ -602,8 +603,7 @@ comments: true
/* 出栈 */
pop(): number {
const num = this.peek();
if (!this.stackPeek)
throw new Error("栈为空");
if (!this.stackPeek) throw new Error('栈为空');
this.stackPeek = this.stackPeek.next;
this.stkSize--;
return num;
@@ -611,8 +611,7 @@ comments: true
/* 访问栈顶元素 */
peek(): number {
if (!this.stackPeek)
throw new Error("栈为空");
if (!this.stackPeek) throw new Error('栈为空');
return this.stackPeek.val;
}
@@ -953,35 +952,36 @@ comments: true
=== "Python"
```python title="array_stack.py"
""" 基于数组实现的栈 """
class ArrayStack:
""" 基于数组实现的栈 """
def __init__(self):
""" 构造方法 """
self.__stack = []
""" 获取栈的长度 """
def size(self):
""" 获取栈的长度 """
return len(self.__stack)
""" 判断栈是否为空 """
def is_empty(self):
""" 判断栈是否为空 """
return self.__stack == []
""" 入栈 """
def push(self, item):
""" 入栈 """
self.__stack.append(item)
""" 出栈 """
def pop(self):
""" 出栈 """
assert not self.is_empty(), "栈为空"
return self.__stack.pop()
""" 访问栈顶元素 """
def peek(self):
""" 访问栈顶元素 """
assert not self.is_empty(), "栈为空"
return self.__stack[-1]
""" 返回列表用于打印 """
def to_list(self):
""" 返回列表用于打印 """
return self.__stack
```
@@ -1044,43 +1044,43 @@ comments: true
```javascript title="array_stack.js"
/* 基于数组实现的栈 */
class ArrayStack {
stack;
#stack;
constructor() {
this.stack = [];
this.#stack = [];
}
/* 获取栈的长度 */
get size() {
return this.stack.length;
return this.#stack.length;
}
/* 判断栈是否为空 */
empty() {
return this.stack.length === 0;
return this.#stack.length === 0;
}
/* 入栈 */
push(num) {
this.stack.push(num);
this.#stack.push(num);
}
/* 出栈 */
pop() {
if (this.empty())
throw new Error("栈为空");
return this.stack.pop();
return this.#stack.pop();
}
/* 访问栈顶元素 */
top() {
if (this.empty())
throw new Error("栈为空");
return this.stack[this.stack.length - 1];
return this.#stack[this.#stack.length - 1];
}
/* 返回 Array */
toArray() {
return this.stack;
return this.#stack;
}
};
```