fuhouyin/hello-algo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update the chapter of stack and queue.

Browse Source
This commit is contained in:
Yudong Jin 2022-12-20 21:33:14 +08:00
parent e79b800bb2
commit 7283bbaf6f
14 changed files with 79 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
codes/cpp/chapter_stack_and_queue/array_queue.cpp
View File

@ -59,7 +59,6 @@ public:
/* 访问队首元素 */
int peek() {
// 删除头结点
if (empty())
throw out_of_range("队列为空");
return nums[front];

1
codes/java/chapter_stack_and_queue/array_queue.java
View File

@ -58,7 +58,6 @@ class ArrayQueue {
/* 访问队首元素 */
public int peek() {
// 删除头结点
if (isEmpty())
throw new EmptyStackException();
return nums[front];

10
codes/javascript/chapter_stack_and_queue/array_queue.js
View File

@ -7,13 +7,12 @@
/* 基于环形数组实现的队列 */
class ArrayQueue {
#queue; // 用于存储队列元素的数组
#front = 0; // 头指针，指向队首
#rear = 0; // 尾指针，指向队尾 + 1
#CAPACITY = 1e3; // 默认初始容量
#queue; // 用于存储队列元素的数组
#front = 0; // 头指针，指向队首
#rear = 0; // 尾指针，指向队尾 + 1
constructor(capacity) {
this.#queue = new Array(capacity ?? this.CAPACITY);
this.#queue = new Array(capacity);
}
/* 获取队列的容量 */
@ -52,7 +51,6 @@ class ArrayQueue {
/* 访问队首元素 */
peek() {
// 删除头结点
if (this.empty())
throw new Error("队列为空");
return this.#queue[this.#front];

10
codes/javascript/chapter_stack_and_queue/array_stack.js
View File

@ -11,6 +11,7 @@ class ArrayStack {
constructor() {
this.stack = [];
}
/* 获取栈的长度 */
get size() {
return this.stack.length;
@ -28,19 +29,22 @@ class ArrayStack {
/* 出栈 */
pop() {
if (this.empty()) throw "栈为空";
if (this.empty())
throw new Error("栈为空");
return this.stack.pop();
}
/* 访问栈顶元素 */
top() {
if (this.empty()) throw "栈为空";
if (this.empty())
throw new Error("栈为空");
return this.stack[this.stack.length - 1];
}
/* 访问索引 index 处元素 */
get(index) {
if (index >= this.size) throw "索引越界";
if (index >= this.size)
throw new Error("索引越界");
return this.stack[index];
}

9
codes/javascript/chapter_stack_and_queue/linkedlist_queue.js
View File

@ -8,8 +8,8 @@ const ListNode = require("../include/ListNode");
/* 基于链表实现的队列 */
class LinkedListQueue {
#front;
#rear; // 头结点 #front ，尾结点 #rear
#front; // 头结点 #front
#rear; // 尾结点 #rear
#queSize = 0;
constructor() {
@ -46,9 +46,6 @@ class LinkedListQueue {
/* 出队 */
poll() {
const num = this.peek();
if (!this.#front) {
throw new Error("队列为空")
}
// 删除头结点
this.#front = this.#front.next;
this.#queSize--;
@ -75,6 +72,8 @@ class LinkedListQueue {
}
/* Driver Code */
/* 初始化队列 */
const queue = new LinkedListQueue();

3
codes/javascript/chapter_stack_and_queue/queue.js
View File

@ -8,7 +8,6 @@
/* Driver Code */
/* 初始化队列 */
// JavaScript 没有内置的队列，可以把 Array 当作队列来使用
// 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
const queue = [];
/* 元素入队 */
@ -22,7 +21,7 @@ queue.push(4);
const peek = queue[0];
/* 元素出队 */
// shift() 方法的时间复杂度为 O(n)
// 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
const poll = queue.shift();
/* 获取队列的长度 */

2
codes/javascript/chapter_stack_and_queue/stack.js
View File

@ -4,6 +4,8 @@
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
*/
/* Driver Code */
/* 初始化栈 */
// Javascript 没有内置的栈类，可以把 Array 当作栈来使用
const stack = [];

2
codes/python/chapter_stack_and_queue/array_queue.py
View File

@ -42,7 +42,6 @@ class ArrayQueue:
""" 出队 """
def poll(self):
# 删除头结点
num = self.peek()
# 队头指针向后移动一位，若越过尾部则返回到数组头部
self.__front = (self.__front + 1) % self.capacity()
@ -50,7 +49,6 @@ class ArrayQueue:
""" 访问队首元素 """
def peek(self):
# 删除头结点
if self.is_empty():
print("队列为空")
return False

11
codes/typescript/chapter_stack_and_queue/array_queue.ts
View File

@ -34,10 +34,8 @@ class ArrayQueue {
/* 入队 */
offer(num: number): void {
if (this.size == this.capacity) {
console.log("队列已满");
return;
}
if (this.size == this.capacity)
throw new Error("队列已满");
// 尾结点后添加 num
this.queue[this.rear] = num;
// 尾指针向后移动一位，越过尾部后返回到数组头部
@ -54,16 +52,15 @@ class ArrayQueue {
/* 访问队首元素 */
peek(): number {
// 删除头结点
if (this.empty())
throw new Error("The queue is empty!");
throw new Error("队列为空");
return this.queue[this.front];
}
/* 访问指定索引元素 */
get(index: number): number {
if (index >= this.size)
throw new Error("Index out of bounds!");
throw new Error("索引越界");
return this.queue[(this.front + index) % this.capacity];
}

9
codes/typescript/chapter_stack_and_queue/array_stack.ts
View File

@ -29,19 +29,22 @@ class ArrayStack {
/* 出栈 */
pop(): number | undefined {
if (this.empty()) throw new Error('栈为空');
if (this.empty())
throw new Error('栈为空');
return this.stack.pop();
}
/* 访问栈顶元素 */
top(): number | undefined {
if (this.empty()) throw new Error('栈为空');
if (this.empty())
throw new Error('栈为空');
return this.stack[this.stack.length - 1];
}
/* 访问索引 index 处元素 */
get(index: number): number | undefined {
if (index >= this.size) throw new Error('索引越界');
if (index >= this.size)
throw new Error('索引越界');
return this.stack[index];
}

11
codes/typescript/chapter_stack_and_queue/linkedlist_queue.ts
View File

@ -8,8 +8,8 @@ import ListNode from "../module/ListNode"
/* 基于链表实现的队列 */
class LinkedListQueue {
private front: ListNode | null;
private rear: ListNode | null; // 头结点 front ，尾结点 rear
private front: ListNode | null; // 头结点 front
private rear: ListNode | null; // 尾结点 rear
private queSize: number = 0;
constructor() {
@ -46,9 +46,8 @@ class LinkedListQueue {
/* 出队 */
poll(): number {
const num = this.peek();
if (!this.front) {
throw new Error("No element in queue!")
}
if (!this.front)
throw new Error("队列为空")
// 删除头结点
this.front = this.front.next;
this.queSize--;
@ -58,7 +57,7 @@ class LinkedListQueue {
/* 访问队首元素 */
peek(): number {
if (this.size === 0)
throw new Error("No element in queue!");
throw new Error("队列为空");
return this.front!.val;
}

3
codes/typescript/chapter_stack_and_queue/queue.ts
View File

@ -6,7 +6,6 @@
/* 初始化队列 */
// TypeScript 没有内置的队列，可以把 Array 当作队列来使用
// 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
const queue: number[] = [];
/* 元素入队 */
@ -20,7 +19,7 @@ queue.push(4);
const peek = queue[0];
/* 元素出队 */
// O(n)
// 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
const poll = queue.shift();
/* 获取队列的长度 */

165
docs/chapter_stack_and_queue/queue.md
View File

@ -145,7 +145,6 @@ comments: true
```js title="queue.js"
/* 初始化队列 */
// JavaScript 没有内置的队列，可以把 Array 当作队列来使用
// 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
const queue = [];
/* 元素入队 */
@ -159,7 +158,7 @@ comments: true
const peek = queue[0];
/* 元素出队 */
// O(n)
// 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
const poll = queue.shift();
/* 获取队列的长度 */
@ -174,7 +173,6 @@ comments: true
```typescript title="queue.ts"
/* 初始化队列 */
// TypeScript 没有内置的队列，可以把 Array 当作队列来使用
// 注意：由于是数组，所以 shift() 的时间复杂度是 O(n)
const queue: number[] = [];
/* 元素入队 */
@ -188,7 +186,7 @@ comments: true
const peek = queue[0];
/* 元素出队 */
// O(n)
// 底层是数组，因此 shift() 方法的时间复杂度为 O(n)
const poll = queue.shift();
/* 获取队列的长度 */
@ -382,19 +380,16 @@ comments: true
// 使用内置包 list 来实现队列
data *list.List
}
// NewLinkedListQueue 初始化链表
func NewLinkedListQueue() *LinkedListQueue {
return &LinkedListQueue{
data: list.New(),
}
}
// Offer 入队
func (s *LinkedListQueue) Offer(value any) {
s.data.PushBack(value)
}
// Poll 出队
func (s *LinkedListQueue) Poll() any {
if s.IsEmpty() {
@ -404,7 +399,6 @@ comments: true
s.data.Remove(e)
return e.Value
}
// Peek 访问队首元素
func (s *LinkedListQueue) Peek() any {
if s.IsEmpty() {
@ -413,12 +407,10 @@ comments: true
e := s.data.Front()
return e.Value
}
// Size 获取队列的长度
func (s *LinkedListQueue) Size() int {
return s.data.Len()
}
// IsEmpty 判断队列是否为空
func (s *LinkedListQueue) IsEmpty() bool {
return s.data.Len() == 0
@ -428,26 +420,23 @@ comments: true
=== "JavaScript"
```js title="linkedlist_queue.js"
/* 基于链表实现的队列 */
class LinkedListQueue {
#front;
#rear; // 头结点 #front ，尾结点 #rear
#front; // 头结点 #front
#rear; // 尾结点 #rear
#queSize = 0;
constructor() {
this.#front = null;
this.#rear = null;
}
/* 获取队列的长度 */
get size() {
return this.#queSize;
}
/* 判断队列是否为空 */
isEmpty() {
return this.size === 0;
}
/* 入队 */
offer(num) {
// 尾结点后添加 num
@ -463,36 +452,20 @@ comments: true
}
this.#queSize++;
}
/* 出队 */
poll() {
const num = this.peek();
if (!this.#front) {
throw new Error("No element in queue!")
}
// 删除头结点
this.#front = this.#front.next;
this.#queSize--;
return num;
}
/* 访问队首元素 */
peek() {
if (this.size === 0)
throw new Error("No element in queue!");
throw new Error("队列为空");
return this.#front.val;
}
/* 将链表转化为 Array 并返回 */
toArray() {
let node = this.#front;
const res = new Array(this.size);
for (let i = 0; i < res.length; i++) {
res[i] = node.val;
node = node.next;
}
return res;
}
}
```
@ -501,25 +474,21 @@ comments: true
```typescript title="linkedlist_queue.ts"
/* 基于链表实现的队列 */
class LinkedListQueue {
private front: ListNode | null;
private rear: ListNode | null; // 头结点 front ，尾结点 rear
private front: ListNode | null; // 头结点 front
private rear: ListNode | null; // 尾结点 rear
private queSize: number = 0;
constructor() {
this.front = null;
this.rear = null;
}
/* 获取队列的长度 */
get size(): number {
return this.queSize;
}
/* 判断队列是否为空 */
isEmpty(): boolean {
return this.size === 0;
}
/* 入队 */
offer(num: number): void {
// 尾结点后添加 num
@ -535,36 +504,22 @@ comments: true
}
this.queSize++;
}
/* 出队 */
poll(): number {
const num = this.peek();
if (!this.front) {
throw new Error("No element in queue!")
}
if (!this.front)
throw new Error("队列为空")
// 删除头结点
this.front = this.front.next;
this.queSize--;
return num;
}
/* 访问队首元素 */
peek(): number {
if (this.size === 0)
throw new Error("No element in queue!");
throw new Error("队列为空");
return this.front!.val;
}
/* 将链表转化为 Array 并返回 */
toArray(): number[] {
let node = this.front;
const res = new Array<number>(this.size);
for (let i = 0; i < res.length; i++) {
res[i] = node!.val;
node = node!.next;
}
return res;
}
}
```
@ -637,7 +592,6 @@ comments: true
}
/* 访问队首元素 */
public int peek() {
// 删除头结点
if (isEmpty())
throw new EmptyStackException();
return nums[front];
@ -701,7 +655,6 @@ comments: true
}
/* 访问队首元素 */
int peek() {
// 删除头结点
if (empty())
throw out_of_range("队列为空");
return nums[front];
@ -750,7 +703,6 @@ comments: true
""" 出队 """
def poll(self):
# 删除头结点
num = self.peek()
# 队头指针向后移动一位，若越过尾部则返回到数组头部
self.__front = (self.__front + 1) % self.capacity()
@ -758,7 +710,6 @@ comments: true
""" 访问队首元素 """
def peek(self):
# 删除头结点
if self.is_empty():
print("队列为空")
return False
@ -791,7 +742,6 @@ comments: true
front int // 头指针，指向队首
rear int // 尾指针，指向队尾 + 1
}
// NewArrayQueue 基于环形数组实现的队列
func NewArrayQueue(capacity int) *ArrayQueue {
return &ArrayQueue{
@ -801,18 +751,15 @@ comments: true
rear: 0,
}
}
// Size 获取队列的长度
func (q *ArrayQueue) Size() int {
size := (q.capacity + q.rear - q.front) % q.capacity
return size
}
// IsEmpty 判断队列是否为空
func (q *ArrayQueue) IsEmpty() bool {
return q.rear-q.front == 0
}
// Offer 入队
func (q *ArrayQueue) Offer(v int) {
// 当 rear == capacity 表示队列已满
@ -824,7 +771,6 @@ comments: true
// 尾指针向后移动一位，越过尾部后返回到数组头部
q.rear = (q.rear + 1) % q.capacity
}
// Poll 出队
func (q *ArrayQueue) Poll() any {
if q.IsEmpty() {
@ -835,7 +781,6 @@ comments: true
q.front = (q.front + 1) % q.capacity
return v
}
// Peek 访问队首元素
func (q *ArrayQueue) Peek() any {
if q.IsEmpty() {
@ -851,76 +796,52 @@ comments: true
```js title="array_queue.js"
/* 基于环形数组实现的队列 */
class ArrayQueue {
queue; // 用于存储队列元素的数组
front = 0; // 头指针，指向队首
rear = 0; // 尾指针，指向队尾 + 1
CAPACITY = 1e5;
#queue; // 用于存储队列元素的数组
#front = 0; // 头指针，指向队首
#rear = 0; // 尾指针，指向队尾 + 1
constructor(capacity) {
this.queue = new Array(capacity ?? this.CAPACITY);
this.#queue = new Array(capacity);
}
/* 获取队列的容量 */
get capacity() {
return this.queue.length;
return this.#queue.length;
}
/* 获取队列的长度 */
get size() {
// 由于将数组看作为环形，可能 rear < front ，因此需要取余数
return (this.capacity + this.rear - this.front) % this.capacity;
return (this.capacity + this.#rear - this.#front) % this.capacity;
}
/* 判断队列是否为空 */
empty() {
return this.rear - this.front == 0;
return this.#rear - this.#front == 0;
}
/* 入队 */
offer(num) {
if (this.size == this.capacity) {
console.log("队列已满");
return;
}
if (this.size == this.capacity)
throw new Error("队列已满");
// 尾结点后添加 num
this.queue[this.rear] = num;
this.#queue[this.#rear] = num;
// 尾指针向后移动一位，越过尾部后返回到数组头部
this.rear = (this.rear + 1) % this.capacity;
this.#rear = (this.#rear + 1) % this.capacity;
}
/* 出队 */
poll() {
const num = this.peek();
// 队头指针向后移动一位，若越过尾部则返回到数组头部
this.front = (this.front + 1) % this.capacity;
this.#front = (this.#front + 1) % this.capacity;
return num;
}
/* 访问队首元素 */
peek() {
// 删除头结点
if (this.empty())
throw new Error("The queue is empty!");
return this.queue[this.front];
throw new Error("队列为空");
return this.#queue[this.#front];
}
/* 访问指定索引元素 */
get(index) {
if (index >= this.size)
throw new Error("Index out of bounds!");
return this.queue[(this.front + index) % this.capacity];
}
/* 返回 Array */
toArray() {
const siz = this.size;
const cap = this.capacity;
// 仅转换有效长度范围内的列表元素
const arr = new Array(siz);
for (let i = 0, j = this.front; i < siz; i++, j++) {
arr[i] = this.queue[j % cap];
}
return arr;
throw new Error("索引越界");
return this.#queue[(this.#front + index) % this.capacity];
}
}
```
@ -928,46 +849,37 @@ comments: true
=== "TypeScript"
```typescript title="array_queue.ts"
/* 基于环形数组实现的队列 */
class ArrayQueue {
private queue: number[]; // 用于存储队列元素的数组
private front: number = 0; // 头指针，指向队首
private rear: number = 0; // 尾指针，指向队尾 + 1
private CAPACITY: number = 1e5;
constructor(capacity?: number) {
this.queue = new Array<number>(capacity ?? this.CAPACITY);
}
/* 获取队列的容量 */
get capacity(): number {
return this.queue.length;
}
/* 获取队列的长度 */
get size(): number {
// 由于将数组看作为环形，可能 rear < front ，因此需要取余数
return (this.capacity + this.rear - this.front) % this.capacity;
}
/* 判断队列是否为空 */
empty(): boolean {
return this.rear - this.front == 0;
}
/* 入队 */
offer(num: number): void {
if (this.size == this.capacity) {
console.log("队列已满");
return;
}
if (this.size == this.capacity)
throw new Error("队列已满");
// 尾结点后添加 num
this.queue[this.rear] = num;
// 尾指针向后移动一位，越过尾部后返回到数组头部
this.rear = (this.rear + 1) % this.capacity;
}
/* 出队 */
poll(): number {
const num = this.peek();
@ -975,33 +887,18 @@ comments: true
this.front = (this.front + 1) % this.capacity;
return num;
}
/* 访问队首元素 */
peek(): number {
// 删除头结点
if (this.empty())
throw new Error("The queue is empty!");
throw new Error("队列为空");
return this.queue[this.front];
}
/* 访问指定索引元素 */
get(index: number): number {
if (index >= this.size)
throw new Error("Index out of bounds!");
throw new Error("索引越界");
return this.queue[(this.front + index) % this.capacity];
}
/* 返回 Array */
toArray(): number[] {
const siz = this.size;
const cap = this.capacity;
// 仅转换有效长度范围内的列表元素
const arr = new Array(siz);
for (let i = 0, j = this.front; i < siz; i++, j++) {
arr[i] = this.queue[j % cap];
}
return arr;
}
}
```

24
docs/chapter_stack_and_queue/stack.md
View File

@ -350,19 +350,16 @@ comments: true
// 使用内置包 list 来实现栈
data *list.List
}
// NewLinkedListStack 初始化链表
func NewLinkedListStack() *LinkedListStack {
return &LinkedListStack{
data: list.New(),
}
}
// Push 入栈
func (s *LinkedListStack) Push(value int) {
s.data.PushBack(value)
}
// Pop 出栈
func (s *LinkedListStack) Pop() any {
if s.IsEmpty() {
@ -372,7 +369,6 @@ comments: true
s.data.Remove(e)
return e.Value
}
// Peek 访问栈顶元素
func (s *LinkedListStack) Peek() any {
if s.IsEmpty() {
@ -381,12 +377,10 @@ comments: true
e := s.data.Back()
return e.Value
}
// Size 获取栈的长度
func (s *LinkedListStack) Size() int {
return s.data.Len()
}
// IsEmpty 判断栈是否为空
func (s *LinkedListStack) IsEmpty() bool {
return s.data.Len() == 0
@ -613,17 +607,20 @@ comments: true
}
/* 出栈 */
pop() {
if (this.empty()) throw "栈为空";
if (this.empty())
throw new Error("栈为空");
return this.stack.pop();
}
/* 访问栈顶元素 */
top() {
if (this.empty()) throw "栈为空";
if (this.empty())
throw new Error("栈为空");
return this.stack[this.stack.length - 1];
}
/* 访问索引 index 处元素 */
get(index) {
if (index >= this.size) throw "索引越界";
if (index >= this.size)
throw new Error("索引越界");
return this.stack[index];
}
};
@ -652,17 +649,20 @@ comments: true
}
/* 出栈 */
pop(): number | undefined {
if (empty()) throw new Error('栈为空');
if (this.empty())
throw new Error('栈为空');
return this.stack.pop();
}
/* 访问栈顶元素 */
top(): number | undefined {
if (empty()) throw new Error('栈为空');
if (this.empty())
throw new Error('栈为空');
return this.stack[this.stack.length - 1];
}
/* 访问索引 index 处元素 */
get(index: number): number | undefined {
if (index >= size()) throw new Error('索引越界');
if (index >= this.size)
throw new Error('索引越界');
return this.stack[index];
}
};