xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-25 14:26:29 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

Unify the function naming of

Browse source 
queue from `offer()` to `push()`
This commit is contained in:
Yudong Jin 2023-02-02 01:43:01 +08:00
parent a0ee691475
commit 7d14c9440e
29 changed files with 184 additions and 189 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
.gitignore vendored
View file

@ -4,15 +4,10 @@
# Editor # Editor
.vscode/ .vscode/
.idea/ .idea/
cmake-build-debug/
hello-algo.iml hello-algo.iml
*.dSYM/
# mkdocs files # mkdocs files
site/ site/
.cache/ .cache/
codes/scripts codes/scripts
docs/overrides/ docs/overrides/
# python files
__pycache__

14
codes/c/chapter_stack_and_queue/array_queue.c
View file

@ -54,7 +54,7 @@ int peek(ArrayQueue *queue) {
} }
/* 入队 */ /* 入队 */
void offer(ArrayQueue *queue, int num) { void push(ArrayQueue *queue, int num) {
if (size(queue) == capacity(queue)) { if (size(queue) == capacity(queue)) {
printf("队列已满\r\n"); printf("队列已满\r\n");
return; return;
@ -93,11 +93,11 @@ int main() {
ArrayQueue *queue = newArrayQueue(capacity); ArrayQueue *queue = newArrayQueue(capacity);
/* 元素入队 */ /* 元素入队 */
offer(queue, 1); push(queue, 1);
offer(queue, 3); push(queue, 3);
offer(queue, 2); push(queue, 2);
offer(queue, 5); push(queue, 5);
offer(queue, 4); push(queue, 4);
printf("队列 queue = "); printf("队列 queue = ");
printArrayQueue(queue); printArrayQueue(queue);
@ -120,7 +120,7 @@ int main() {
/* 测试环形数组 */ /* 测试环形数组 */
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
offer(queue, i); push(queue, i);
poll(queue); poll(queue);
printf("第 %d 轮入队 + 出队后 queue = ", i); printf("第 %d 轮入队 + 出队后 queue = ", i);
printArrayQueue(queue); printArrayQueue(queue);

14
codes/cpp/chapter_stack_and_queue/array_queue.cpp
View file

@ -42,7 +42,7 @@ public:
} }
/* 入队 */ /* 入队 */
void offer(int num) { void push(int num) {
if (queSize == queCapacity) { if (queSize == queCapacity) {
cout << "队列已满" << endl; cout << "队列已满" << endl;
return; return;
@ -90,11 +90,11 @@ int main() {
ArrayQueue* queue = new ArrayQueue(capacity); ArrayQueue* queue = new ArrayQueue(capacity);
/* 元素入队 */ /* 元素入队 */
queue->offer(1); queue->push(1);
queue->offer(3); queue->push(3);
queue->offer(2); queue->push(2);
queue->offer(5); queue->push(5);
queue->offer(4); queue->push(4);
cout << "队列 queue = "; cout << "队列 queue = ";
PrintUtil::printVector(queue->toVector()); PrintUtil::printVector(queue->toVector());
@ -117,7 +117,7 @@ int main() {
/* 测试环形数组 */ /* 测试环形数组 */
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
queue->offer(i); queue->push(i);
queue->poll(); queue->poll();
cout << "第 " << i << " 轮入队 + 出队后 queue = "; cout << "第 " << i << " 轮入队 + 出队后 queue = ";
PrintUtil::printVector(queue->toVector()); PrintUtil::printVector(queue->toVector());

12
codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp
View file

@ -35,7 +35,7 @@ public:
} }
/* 入队 */ /* 入队 */
void offer(int num) { void push(int num) {
// 尾结点后添加 num // 尾结点后添加 num
ListNode* node = new ListNode(num); ListNode* node = new ListNode(num);
// 如果队列为空，则令头、尾结点都指向该结点 // 如果队列为空，则令头、尾结点都指向该结点
@ -88,11 +88,11 @@ int main() {
LinkedListQueue* queue = new LinkedListQueue(); LinkedListQueue* queue = new LinkedListQueue();
/* 元素入队 */ /* 元素入队 */
queue->offer(1); queue->push(1);
queue->offer(3); queue->push(3);
queue->offer(2); queue->push(2);
queue->offer(5); queue->push(5);
queue->offer(4); queue->push(4);
cout << "队列 queue = "; cout << "队列 queue = ";
PrintUtil::printVector(queue->toVector()); PrintUtil::printVector(queue->toVector());

14
codes/csharp/chapter_stack_and_queue/array_queue.cs
View file

@ -41,7 +41,7 @@ namespace hello_algo.chapter_stack_and_queue
} }
/* 入队 */ /* 入队 */
public void offer(int num) public void push(int num)
{ {
if (queSize == capacity()) if (queSize == capacity())
{ {
@ -97,11 +97,11 @@ namespace hello_algo.chapter_stack_and_queue
ArrayQueue queue = new ArrayQueue(capacity); ArrayQueue queue = new ArrayQueue(capacity);
/* 元素入队 */ /* 元素入队 */
queue.offer(1); queue.push(1);
queue.offer(3); queue.push(3);
queue.offer(2); queue.push(2);
queue.offer(5); queue.push(5);
queue.offer(4); queue.push(4);
Console.WriteLine("队列 queue = " + string.Join(",", queue.toArray())); Console.WriteLine("队列 queue = " + string.Join(",", queue.toArray()));
/* 访问队首元素 */ /* 访问队首元素 */
@ -123,7 +123,7 @@ namespace hello_algo.chapter_stack_and_queue
/* 测试环形数组 */ /* 测试环形数组 */
for (int i = 0; i < 10; i++) for (int i = 0; i < 10; i++)
{ {
queue.offer(i); queue.push(i);
queue.poll(); queue.poll();
Console.WriteLine("第 " + i + " 轮入队 + 出队后 queue = " + string.Join(",", queue.toArray())); Console.WriteLine("第 " + i + " 轮入队 + 出队后 queue = " + string.Join(",", queue.toArray()));
} }

12
codes/csharp/chapter_stack_and_queue/linkedlist_queue.cs
View file

@ -34,7 +34,7 @@ namespace hello_algo.chapter_stack_and_queue
} }
/* 入队 */ /* 入队 */
public void offer(int num) public void push(int num)
{ {
// 尾结点后添加 num // 尾结点后添加 num
ListNode node = new ListNode(num); ListNode node = new ListNode(num);
@ -97,11 +97,11 @@ namespace hello_algo.chapter_stack_and_queue
LinkedListQueue queue = new LinkedListQueue(); LinkedListQueue queue = new LinkedListQueue();
/* 元素入队 */ /* 元素入队 */
queue.offer(1); queue.push(1);
queue.offer(3); queue.push(3);
queue.offer(2); queue.push(2);
queue.offer(5); queue.push(5);
queue.offer(4); queue.push(4);
Console.WriteLine("队列 queue = " + String.Join(",", queue.toArray())); Console.WriteLine("队列 queue = " + String.Join(",", queue.toArray()));
/* 访问队首元素 */ /* 访问队首元素 */

4
codes/go/chapter_stack_and_queue/array_queue.go
View file

@ -32,8 +32,8 @@ func (q *arrayQueue) isEmpty() bool {
return q.queSize == 0 return q.queSize == 0
} }
// offer 入队 // push 入队
func (q *arrayQueue) offer(num int) { func (q *arrayQueue) push(num int) {
// 当 rear == queCapacity 表示队列已满 // 当 rear == queCapacity 表示队列已满
if q.queSize == q.queCapacity { if q.queSize == q.queCapacity {
return return

16
codes/go/chapter_stack_and_queue/deque_test.go
View file

@ -54,11 +54,11 @@ func TestLinkedListDeque(t *testing.T) {
deque := newLinkedListDeque() deque := newLinkedListDeque()
// 元素入队 // 元素入队
deque.offerLast(2) deque.pushLast(2)
deque.offerLast(5) deque.pushLast(5)
deque.offerLast(4) deque.pushLast(4)
deque.offerFirst(3) deque.pushFirst(3)
deque.offerFirst(1) deque.pushFirst(1)
fmt.Print("队列 deque = ") fmt.Print("队列 deque = ")
PrintList(deque.toList()) PrintList(deque.toList())
@ -87,12 +87,12 @@ func TestLinkedListDeque(t *testing.T) {
// BenchmarkArrayQueue 67.92 ns/op in Mac M1 Pro // BenchmarkArrayQueue 67.92 ns/op in Mac M1 Pro
func BenchmarkLinkedListDeque(b *testing.B) { func BenchmarkLinkedListDeque(b *testing.B) {
stack := newLinkedListDeque() deque := newLinkedListDeque()
// use b.N for looping // use b.N for looping
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.offerLast(777) deque.pushLast(777)
} }
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.pollFirst() deque.pollFirst()
} }
} }

8
codes/go/chapter_stack_and_queue/linkedlist_deque.go
View file

@ -20,13 +20,13 @@ func newLinkedListDeque() *linkedListDeque {
} }
} }
// offerFirst 队首元素入队 // pushFirst 队首元素入队
func (s *linkedListDeque) offerFirst(value any) { func (s *linkedListDeque) pushFirst(value any) {
s.data.PushFront(value) s.data.PushFront(value)
} }
// offerLast 队尾元素入队 // pushLast 队尾元素入队
func (s *linkedListDeque) offerLast(value any) { func (s *linkedListDeque) pushLast(value any) {
s.data.PushBack(value) s.data.PushBack(value)
} }

4
codes/go/chapter_stack_and_queue/linkedlist_queue.go
View file

@ -21,8 +21,8 @@ func newLinkedListQueue() *linkedListQueue {
} }
} }
// offer 入队 // push 入队
func (s *linkedListQueue) offer(value any) { func (s *linkedListQueue) push(value any) {
s.data.PushBack(value) s.data.PushBack(value)
} }

34
codes/go/chapter_stack_and_queue/queue_test.go
View file

@ -51,11 +51,11 @@ func TestArrayQueue(t *testing.T) {
queue := newArrayQueue(capacity) queue := newArrayQueue(capacity)
// 元素入队 // 元素入队
queue.offer(1) queue.push(1)
queue.offer(3) queue.push(3)
queue.offer(2) queue.push(2)
queue.offer(5) queue.push(5)
queue.offer(4) queue.push(4)
fmt.Print("队列 queue = ") fmt.Print("队列 queue = ")
PrintSlice(queue.toSlice()) PrintSlice(queue.toSlice())
@ -78,7 +78,7 @@ func TestArrayQueue(t *testing.T) {
/* 测试环形数组 */ /* 测试环形数组 */
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
queue.offer(i) queue.push(i)
queue.poll() queue.poll()
fmt.Print("第", i, "轮入队 + 出队后 queue =") fmt.Print("第", i, "轮入队 + 出队后 queue =")
PrintSlice(queue.toSlice()) PrintSlice(queue.toSlice())
@ -90,11 +90,11 @@ func TestLinkedListQueue(t *testing.T) {
queue := newLinkedListQueue() queue := newLinkedListQueue()
// 元素入队 // 元素入队
queue.offer(1) queue.push(1)
queue.offer(3) queue.push(3)
queue.offer(2) queue.push(2)
queue.offer(5) queue.push(5)
queue.offer(4) queue.push(4)
fmt.Print("队列 queue = ") fmt.Print("队列 queue = ")
PrintList(queue.toList()) PrintList(queue.toList())
@ -119,24 +119,24 @@ func TestLinkedListQueue(t *testing.T) {
// BenchmarkArrayQueue 8 ns/op in Mac M1 Pro // BenchmarkArrayQueue 8 ns/op in Mac M1 Pro
func BenchmarkArrayQueue(b *testing.B) { func BenchmarkArrayQueue(b *testing.B) {
capacity := 1000 capacity := 1000
stack := newArrayQueue(capacity) queue := newArrayQueue(capacity)
// use b.N for looping // use b.N for looping
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.offer(777) queue.push(777)
} }
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.poll() queue.poll()
} }
} }
// BenchmarkLinkedQueue 62.66 ns/op in Mac M1 Pro // BenchmarkLinkedQueue 62.66 ns/op in Mac M1 Pro
func BenchmarkLinkedQueue(b *testing.B) { func BenchmarkLinkedQueue(b *testing.B) {
stack := newLinkedListQueue() queue := newLinkedListQueue()
// use b.N for looping // use b.N for looping
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.offer(777) queue.push(777)
} }
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.poll() queue.poll()
} }
} }

2
codes/go/chapter_stack_and_queue/stack_test.go
View file

@ -22,7 +22,7 @@ func TestStack(t *testing.T) {
stack = append(stack, 2) stack = append(stack, 2)
stack = append(stack, 5) stack = append(stack, 5)
stack = append(stack, 4) stack = append(stack, 4)
fmt.Print("栈 = ") fmt.Print("栈 stack = ")
PrintSlice(stack) PrintSlice(stack)
/* 访问栈顶元素 */ /* 访问栈顶元素 */

14
codes/java/chapter_stack_and_queue/array_queue.java
View file

@ -35,7 +35,7 @@ class ArrayQueue {
} }
/* 入队 */ /* 入队 */
public void offer(int num) { public void push(int num) {
if (queSize == capacity()) { if (queSize == capacity()) {
System.out.println("队列已满"); System.out.println("队列已满");
return; return;
@ -82,11 +82,11 @@ public class array_queue {
ArrayQueue queue = new ArrayQueue(capacity); ArrayQueue queue = new ArrayQueue(capacity);
/* 元素入队 */ /* 元素入队 */
queue.offer(1); queue.push(1);
queue.offer(3); queue.push(3);
queue.offer(2); queue.push(2);
queue.offer(5); queue.push(5);
queue.offer(4); queue.push(4);
System.out.println("队列 queue = " + Arrays.toString(queue.toArray())); System.out.println("队列 queue = " + Arrays.toString(queue.toArray()));
/* 访问队首元素 */ /* 访问队首元素 */
@ -107,7 +107,7 @@ public class array_queue {
/* 测试环形数组 */ /* 测试环形数组 */
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
queue.offer(i); queue.push(i);
queue.poll(); queue.poll();
System.out.println("第 " + i + " 轮入队 + 出队后 queue = " + Arrays.toString(queue.toArray())); System.out.println("第 " + i + " 轮入队 + 出队后 queue = " + Arrays.toString(queue.toArray()));
} }

20
codes/java/chapter_stack_and_queue/linkedlist_deque.java
View file

@ -39,7 +39,7 @@ class LinkedListDeque {
} }
/* 入队操作 */ /* 入队操作 */
private void offer(int num, boolean isFront) { private void push(int num, boolean isFront) {
ListNode node = new ListNode(num); ListNode node = new ListNode(num);
// 若链表为空，则令 front, rear 都指向 node // 若链表为空，则令 front, rear 都指向 node
if (isEmpty()) if (isEmpty())
@ -61,13 +61,13 @@ class LinkedListDeque {
} }
/* 队首入队 */ /* 队首入队 */
public void offerFirst(int num) { public void pushFirst(int num) {
offer(num, true); push(num, true);
} }
/* 队尾入队 */ /* 队尾入队 */
public void offerLast(int num) { public void pushLast(int num) {
offer(num, false); push(num, false);
} }
/* 出队操作 */ /* 出队操作 */
@ -141,9 +141,9 @@ public class linkedlist_deque {
public static void main(String[] args) { public static void main(String[] args) {
/* 初始化双向队列 */ /* 初始化双向队列 */
LinkedListDeque deque = new LinkedListDeque(); LinkedListDeque deque = new LinkedListDeque();
deque.offerLast(3); deque.pushLast(3);
deque.offerLast(2); deque.pushLast(2);
deque.offerLast(5); deque.pushLast(5);
System.out.print("双点队列 deque = "); System.out.print("双点队列 deque = ");
deque.print(); deque.print();
@ -154,10 +154,10 @@ public class linkedlist_deque {
System.out.println("队尾元素 peekLast = " + peekLast); System.out.println("队尾元素 peekLast = " + peekLast);
/* 元素入队 */ /* 元素入队 */
deque.offerLast(4); deque.pushLast(4);
System.out.print("元素 4 队尾入队后 deque = "); System.out.print("元素 4 队尾入队后 deque = ");
deque.print(); deque.print();
deque.offerFirst(1); deque.pushFirst(1);
System.out.print("元素 1 队首入队后 deque = "); System.out.print("元素 1 队首入队后 deque = ");
deque.print(); deque.print();

13
codes/java/chapter_stack_and_queue/linkedlist_queue.java
View file

@ -7,7 +7,6 @@
package chapter_stack_and_queue; package chapter_stack_and_queue;
import java.util.*; import java.util.*;
import include.*;
/* 基于链表实现的队列 */ /* 基于链表实现的队列 */
class LinkedListQueue { class LinkedListQueue {
@ -30,7 +29,7 @@ class LinkedListQueue {
} }
/* 入队 */ /* 入队 */
public void offer(int num) { public void push(int num) {
// 尾结点后添加 num // 尾结点后添加 num
ListNode node = new ListNode(num); ListNode node = new ListNode(num);
// 如果队列为空，则令头、尾结点都指向该结点 // 如果队列为空，则令头、尾结点都指向该结点
@ -79,11 +78,11 @@ public class linkedlist_queue {
LinkedListQueue queue = new LinkedListQueue(); LinkedListQueue queue = new LinkedListQueue();
/* 元素入队 */ /* 元素入队 */
queue.offer(1); queue.push(1);
queue.offer(3); queue.push(3);
queue.offer(2); queue.push(2);
queue.offer(5); queue.push(5);
queue.offer(4); queue.push(4);
System.out.println("队列 queue = " + Arrays.toString(queue.toArray())); System.out.println("队列 queue = " + Arrays.toString(queue.toArray()));
/* 访问队首元素 */ /* 访问队首元素 */

14
codes/javascript/chapter_stack_and_queue/array_queue.js
View file

@ -30,7 +30,7 @@ class ArrayQueue {
} }
/* 入队 */ /* 入队 */
offer(num) { push(num) {
if (this.size == this.capacity) if (this.size == this.capacity)
throw new Error("队列已满"); throw new Error("队列已满");
// 计算尾指针，指向队尾索引 + 1 // 计算尾指针，指向队尾索引 + 1
@ -75,11 +75,11 @@ const capacity = 10;
const queue = new ArrayQueue(capacity); const queue = new ArrayQueue(capacity);
/* 元素入队 */ /* 元素入队 */
queue.offer(1); queue.push(1);
queue.offer(3); queue.push(3);
queue.offer(2); queue.push(2);
queue.offer(5); queue.push(5);
queue.offer(4); queue.push(4);
console.log("队列 queue =", queue.toArray()); console.log("队列 queue =", queue.toArray());
/* 访问队首元素 */ /* 访问队首元素 */
@ -100,7 +100,7 @@ console.log("队列是否为空 = " + empty);
/* 测试环形数组 */ /* 测试环形数组 */
for (let i = 0; i < 10; i++) { for (let i = 0; i < 10; i++) {
queue.offer(i); queue.push(i);
queue.poll(); queue.poll();
console.log("第 " + i + " 轮入队 + 出队后 queue =", queue.toArray()); console.log("第 " + i + " 轮入队 + 出队后 queue =", queue.toArray());
} }

12
codes/javascript/chapter_stack_and_queue/linkedlist_queue.js
View file

@ -28,7 +28,7 @@ class LinkedListQueue {
} }
/* 入队 */ /* 入队 */
offer(num) { push(num) {
// 尾结点后添加 num // 尾结点后添加 num
const node = new ListNode(num); const node = new ListNode(num);
// 如果队列为空，则令头、尾结点都指向该结点 // 如果队列为空，则令头、尾结点都指向该结点
@ -78,11 +78,11 @@ class LinkedListQueue {
const queue = new LinkedListQueue(); const queue = new LinkedListQueue();
/* 元素入队 */ /* 元素入队 */
queue.offer(1); queue.push(1);
queue.offer(3); queue.push(3);
queue.offer(2); queue.push(2);
queue.offer(5); queue.push(5);
queue.offer(4); queue.push(4);
console.log("队列 queue = " + queue.toArray()); console.log("队列 queue = " + queue.toArray());
/* 访问队首元素 */ /* 访问队首元素 */

1
codes/python/.gitignore vendored Normal file
View file

@ -0,0 +1 @@
__pycache__

14
codes/swift/chapter_stack_and_queue/array_queue.swift
View file

@ -31,7 +31,7 @@ class ArrayQueue {
} }
/* 入队 */ /* 入队 */
func offer(num: Int) { func push(num: Int) {
if size() == capacity() { if size() == capacity() {
print("队列已满") print("队列已满")
return return
@ -82,11 +82,11 @@ enum _ArrayQueue {
let queue = ArrayQueue(capacity: capacity) let queue = ArrayQueue(capacity: capacity)
/* 元素入队 */ /* 元素入队 */
queue.offer(num: 1) queue.push(num: 1)
queue.offer(num: 3) queue.push(num: 3)
queue.offer(num: 2) queue.push(num: 2)
queue.offer(num: 5) queue.push(num: 5)
queue.offer(num: 4) queue.push(num: 4)
print("队列 queue = \(queue.toArray())") print("队列 queue = \(queue.toArray())")
/* 访问队首元素 */ /* 访问队首元素 */
@ -107,7 +107,7 @@ enum _ArrayQueue {
/* 测试环形数组 */ /* 测试环形数组 */
for i in 0 ..< 10 { for i in 0 ..< 10 {
queue.offer(num: i) queue.push(num: i)
queue.poll() queue.poll()
print("第 \(i) 轮入队 + 出队后 queue = \(queue.toArray())") print("第 \(i) 轮入队 + 出队后 queue = \(queue.toArray())")
} }

12
codes/swift/chapter_stack_and_queue/linkedlist_queue.swift
View file

@ -25,7 +25,7 @@ class LinkedListQueue {
} }
/* 入队 */ /* 入队 */
func offer(num: Int) { func push(num: Int) {
// 尾结点后添加 num // 尾结点后添加 num
let node = ListNode(x: num) let node = ListNode(x: num)
// 如果队列为空，则令头、尾结点都指向该结点 // 如果队列为空，则令头、尾结点都指向该结点
@ -79,11 +79,11 @@ enum _LinkedListQueue {
let queue = LinkedListQueue() let queue = LinkedListQueue()
/* 元素入队 */ /* 元素入队 */
queue.offer(num: 1) queue.push(num: 1)
queue.offer(num: 3) queue.push(num: 3)
queue.offer(num: 2) queue.push(num: 2)
queue.offer(num: 5) queue.push(num: 5)
queue.offer(num: 4) queue.push(num: 4)
print("队列 queue = \(queue.toArray())") print("队列 queue = \(queue.toArray())")
/* 访问队首元素 */ /* 访问队首元素 */

14
codes/typescript/chapter_stack_and_queue/array_queue.ts
View file

@ -31,7 +31,7 @@ class ArrayQueue {
} }
/* 入队 */ /* 入队 */
offer(num: number): void { push(num: number): void {
if (this.size == this.capacity) if (this.size == this.capacity)
throw new Error("队列已满"); throw new Error("队列已满");
// 计算尾指针，指向队尾索引 + 1 // 计算尾指针，指向队尾索引 + 1
@ -74,11 +74,11 @@ const capacity = 10;
const queue = new ArrayQueue(capacity); const queue = new ArrayQueue(capacity);
/* 元素入队 */ /* 元素入队 */
queue.offer(1); queue.push(1);
queue.offer(3); queue.push(3);
queue.offer(2); queue.push(2);
queue.offer(5); queue.push(5);
queue.offer(4); queue.push(4);
console.log("队列 queue =", queue.toArray()); console.log("队列 queue =", queue.toArray());
/* 访问队首元素 */ /* 访问队首元素 */
@ -99,7 +99,7 @@ console.log("队列是否为空 = " + empty);
/* 测试环形数组 */ /* 测试环形数组 */
for (let i = 0; i < 10; i++) { for (let i = 0; i < 10; i++) {
queue.offer(i); queue.push(i);
queue.poll(); queue.poll();
console.log("第 " + i + " 轮入队 + 出队后 queue =", queue.toArray()); console.log("第 " + i + " 轮入队 + 出队后 queue =", queue.toArray());
console.log(queue.toArray()); console.log(queue.toArray());

12
codes/typescript/chapter_stack_and_queue/linkedlist_queue.ts
View file

@ -28,7 +28,7 @@ class LinkedListQueue {
} }
/* 入队 */ /* 入队 */
offer(num: number): void { push(num: number): void {
// 尾结点后添加 num // 尾结点后添加 num
const node = new ListNode(num); const node = new ListNode(num);
// 如果队列为空，则令头、尾结点都指向该结点 // 如果队列为空，则令头、尾结点都指向该结点
@ -78,11 +78,11 @@ class LinkedListQueue {
const queue = new LinkedListQueue(); const queue = new LinkedListQueue();
/* 元素入队 */ /* 元素入队 */
queue.offer(1); queue.push(1);
queue.offer(3); queue.push(3);
queue.offer(2); queue.push(2);
queue.offer(5); queue.push(5);
queue.offer(4); queue.push(4);
console.log("队列 queue = " + queue.toArray()); console.log("队列 queue = " + queue.toArray());
/* 访问队首元素 */ /* 访问队首元素 */

14
codes/zig/chapter_stack_and_queue/array_queue.zig
View file

@ -50,7 +50,7 @@ pub fn ArrayQueue(comptime T: type) type {
} }
// 入队 // 入队
pub fn offer(self: *Self, num: T) !void { pub fn push(self: *Self, num: T) !void {
if (self.size() == self.capacity()) { if (self.size() == self.capacity()) {
std.debug.print("队列已满\n", .{}); std.debug.print("队列已满\n", .{});
return; return;
@ -102,11 +102,11 @@ pub fn main() !void {
defer queue.deinit(); defer queue.deinit();
// 元素入队 // 元素入队
try queue.offer(1); try queue.push(1);
try queue.offer(3); try queue.push(3);
try queue.offer(2); try queue.push(2);
try queue.offer(5); try queue.push(5);
try queue.offer(4); try queue.push(4);
std.debug.print("队列 queue = ", .{}); std.debug.print("队列 queue = ", .{});
inc.PrintUtil.printArray(i32, try queue.toArray()); inc.PrintUtil.printArray(i32, try queue.toArray());
@ -130,7 +130,7 @@ pub fn main() !void {
// 测试环形数组 // 测试环形数组
var i: i32 = 0; var i: i32 = 0;
while (i < 10) : (i += 1) { while (i < 10) : (i += 1) {
try queue.offer(i); try queue.push(i);
_ = queue.poll(); _ = queue.poll();
std.debug.print("\n第 {} 轮入队 + 出队后 queue = ", .{i}); std.debug.print("\n第 {} 轮入队 + 出队后 queue = ", .{i});
inc.PrintUtil.printArray(i32, try queue.toArray()); inc.PrintUtil.printArray(i32, try queue.toArray());

14
codes/zig/chapter_stack_and_queue/linkedlist_deque.zig
View file

@ -62,7 +62,7 @@ pub fn LinkedListDeque(comptime T: type) type {
} }
// 入队操作 // 入队操作
pub fn offer(self: *Self, num: T, isFront: bool) !void { pub fn push(self: *Self, num: T, isFront: bool) !void {
var node = try self.mem_allocator.create(ListNode(T)); var node = try self.mem_allocator.create(ListNode(T));
node.init(num); node.init(num);
// 若链表为空，则令 front, rear 都指向 node // 若链表为空，则令 front, rear 都指向 node
@ -86,13 +86,13 @@ pub fn LinkedListDeque(comptime T: type) type {
} }
// 队首入队 // 队首入队
pub fn offerFirst(self: *Self, num: T) !void { pub fn pushFirst(self: *Self, num: T) !void {
try self.offer(num, true); try self.push(num, true);
} }
// 队尾入队 // 队尾入队
pub fn offerLast(self: *Self, num: T) !void { pub fn pushLast(self: *Self, num: T) !void {
try self.offer(num, false); try self.push(num, false);
} }
// 出队操作 // 出队操作
@ -187,7 +187,7 @@ pub fn main() !void {
// 队尾入队 // 队尾入队
for (nums) |num| { for (nums) |num| {
try deque.offerLast(num); try deque.pushLast(num);
std.debug.print("\n元素 {} 队尾入队后，队列为\n", .{num}); std.debug.print("\n元素 {} 队尾入队后，队列为\n", .{num});
try deque.print(); try deque.print();
} }
@ -203,7 +203,7 @@ pub fn main() !void {
// 队首入队 // 队首入队
for (nums) |num| { for (nums) |num| {
try deque.offerFirst(num); try deque.pushFirst(num);
std.debug.print("\n元素 {} 队首入队后，队列为\n", .{num}); std.debug.print("\n元素 {} 队首入队后，队列为\n", .{num});
try deque.print(); try deque.print();
} }

12
codes/zig/chapter_stack_and_queue/linkedlist_queue.zig
View file

@ -50,7 +50,7 @@ pub fn LinkedListQueue(comptime T: type) type {
} }
// 入队 // 入队
pub fn offer(self: *Self, num: T) !void { pub fn push(self: *Self, num: T) !void {
// 尾结点后添加 num // 尾结点后添加 num
var node = try self.mem_allocator.create(inc.ListNode(T)); var node = try self.mem_allocator.create(inc.ListNode(T));
node.init(num); node.init(num);
@ -98,11 +98,11 @@ pub fn main() !void {
defer queue.deinit(); defer queue.deinit();
// 元素入队 // 元素入队
try queue.offer(1); try queue.push(1);
try queue.offer(3); try queue.push(3);
try queue.offer(2); try queue.push(2);
try queue.offer(5); try queue.push(5);
try queue.offer(4); try queue.push(4);
std.debug.print("队列 queue = ", .{}); std.debug.print("队列 queue = ", .{});
inc.PrintUtil.printArray(i32, try queue.toArray()); inc.PrintUtil.printArray(i32, try queue.toArray());

BIN
docs/chapter_stack_and_queue/deque.assets/deque_operations.png
View file

Binary file not shown.
Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 61 KiB

After

Width:  |  Height:  |  Size: 65 KiB

18
docs/chapter_stack_and_queue/deque.md
View file

@ -12,16 +12,16 @@ comments: true
## 5.3.1. 双向队列常用操作 ## 5.3.1. 双向队列常用操作
双向队列的常用操作见下表（方法命名以 Java 为例）。 双向队列的常用操作见下表，方法名需根据特定语言来确定。
<p align="center"> Table. 双向队列的常用操作 </p> <p align="center"> Table. 双向队列的常用操作 </p>
<div class="center-table" markdown> <div class="center-table" markdown>
| 方法 | 描述 | 时间复杂度 | | 方法名 | 描述 | 时间复杂度 |
| ------------ | ---------------- | ---------- | | ------------ | ---------------- | ---------- |
| offerFirst() | 将元素添加至队首 | $O(1)$ | | pushFirst() | 将元素添加至队首 | $O(1)$ |
| offerLast() | 将元素添加至队尾 | $O(1)$ | | pushLast() | 将元素添加至队尾 | $O(1)$ |
| pollFirst() | 删除队首元素 | $O(1)$ | | pollFirst() | 删除队首元素 | $O(1)$ |
| pollLast() | 删除队尾元素 | $O(1)$ | | pollLast() | 删除队尾元素 | $O(1)$ |
| peekFirst() | 访问队首元素 | $O(1)$ | | peekFirst() | 访问队首元素 | $O(1)$ |
@ -288,7 +288,7 @@ comments: true
} }
/* 入队操作 */ /* 入队操作 */
private void offer(int num, boolean isFront) { private void push(int num, boolean isFront) {
ListNode node = new ListNode(num); ListNode node = new ListNode(num);
// 若链表为空，则令 front, rear 都指向 node // 若链表为空，则令 front, rear 都指向 node
if (isEmpty()) if (isEmpty())
@ -310,13 +310,13 @@ comments: true
} }
/* 队首入队 */ /* 队首入队 */
public void offerFirst(int num) { public void pushFirst(int num) {
offer(num, true); push(num, true);
} }
/* 队尾入队 */ /* 队尾入队 */
public void offerLast(int num) { public void pushLast(int num) {
offer(num, false); push(num, false);
} }
/* 出队操作 */ /* 出队操作 */

BIN
docs/chapter_stack_and_queue/queue.assets/queue_operations.png
View file

Binary file not shown.
Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 58 KiB

After

Width:  |  Height:  |  Size: 58 KiB

50
docs/chapter_stack_and_queue/queue.md
View file

@ -14,19 +14,19 @@ comments: true
## 5.2.1. 队列常用操作 ## 5.2.1. 队列常用操作
队列的常用操作见下表（方法命名以 Java 为例）。 队列的常用操作见下表，方法名需根据特定语言来确定。
<p align="center"> Table. 队列的常用操作 </p> <p align="center"> Table. 队列的常用操作 </p>
<div class="center-table" markdown> <div class="center-table" markdown>
| 方法 | 描述 | 时间复杂度 | | 方法名 | 描述 | 时间复杂度 |
| --------- | ---------------------------- | ---------- | | --------- | -------------------------- | -------- |
| offer() | 元素入队，即将元素添加至队尾 | $O(1)$ | | push() | 元素入队，即将元素添加至队尾 | $O(1)$ |
| poll() | 队首元素出队 | $O(1)$ | | poll() | 队首元素出队 | $O(1)$ |
| front() | 访问队首元素 | $O(1)$ | | front() | 访问队首元素 | $O(1)$ |
| size() | 获取队列的长度 | $O(1)$ | | size() | 获取队列的长度 | $O(1)$ |
| isEmpty() | 判断队列是否为空 | $O(1)$ | | isEmpty() | 判断队列是否为空 | $O(1)$ |
</div> </div>
@ -302,7 +302,7 @@ comments: true
return size() == 0; return size() == 0;
} }
/* 入队 */ /* 入队 */
public void offer(int num) { public void push(int num) {
// 尾结点后添加 num // 尾结点后添加 num
ListNode node = new ListNode(num); ListNode node = new ListNode(num);
// 如果队列为空，则令头、尾结点都指向该结点 // 如果队列为空，则令头、尾结点都指向该结点
@ -361,7 +361,7 @@ comments: true
return queSize == 0; return queSize == 0;
} }
/* 入队 */ /* 入队 */
void offer(int num) { void push(int num) {
// 尾结点后添加 num // 尾结点后添加 num
ListNode* node = new ListNode(num); ListNode* node = new ListNode(num);
// 如果队列为空，则令头、尾结点都指向该结点 // 如果队列为空，则令头、尾结点都指向该结点
@ -459,8 +459,8 @@ comments: true
} }
} }
// offer 入队 // push 入队
func (s *linkedListQueue) offer(value any) { func (s *linkedListQueue) push(value any) {
s.data.PushBack(value) s.data.PushBack(value)
} }
@ -515,7 +515,7 @@ comments: true
return this.size === 0; return this.size === 0;
} }
/* 入队 */ /* 入队 */
offer(num) { push(num) {
// 尾结点后添加 num // 尾结点后添加 num
const node = new ListNode(num); const node = new ListNode(num);
// 如果队列为空，则令头、尾结点都指向该结点 // 如果队列为空，则令头、尾结点都指向该结点
@ -567,7 +567,7 @@ comments: true
return this.size === 0; return this.size === 0;
} }
/* 入队 */ /* 入队 */
offer(num: number): void { push(num: number): void {
// 尾结点后添加 num // 尾结点后添加 num
const node = new ListNode(num); const node = new ListNode(num);
// 如果队列为空，则令头、尾结点都指向该结点 // 如果队列为空，则令头、尾结点都指向该结点
@ -630,7 +630,7 @@ comments: true
return size() == 0; return size() == 0;
} }
/* 入队 */ /* 入队 */
public void offer(int num) public void push(int num)
{ {
// 尾结点后添加 num // 尾结点后添加 num
ListNode node = new ListNode(num); ListNode node = new ListNode(num);
@ -689,7 +689,7 @@ comments: true
} }
/* 入队 */ /* 入队 */
func offer(num: Int) { func push(num: Int) {
// 尾结点后添加 num // 尾结点后添加 num
let node = ListNode(x: num) let node = ListNode(x: num)
// 如果队列为空，则令头、尾结点都指向该结点 // 如果队列为空，则令头、尾结点都指向该结点
@ -746,7 +746,7 @@ comments: true
细心的同学可能会发现一个问题，即在入队与出队的过程中，两个指针都在向后移动，**在到达尾部后则无法继续移动了**。 细心的同学可能会发现一个问题，即在入队与出队的过程中，两个指针都在向后移动，**在到达尾部后则无法继续移动了**。
为了解决此问题，我们可以采取一个取巧方案，**即将数组看作是“环形”的**。具体做法是规定指针越过数组尾部后，再次回到头部接续遍历，这样相当于使数组“首尾相连”了。在环形数组的设定下，获取长度 `size()` 、入队 `offer()` 、出队 `poll()` 方法都需要做相应的取余操作处理，使得当尾指针绕回数组头部时，仍然可以正确处理操作。 为了解决此问题，我们可以采取一个取巧方案，**即将数组看作是“环形”的**。具体做法是规定指针越过数组尾部后，再次回到头部接续遍历，这样相当于使数组“首尾相连”了。在环形数组的设定下，获取长度 `size()` 、入队 `push()` 、出队 `poll()` 方法都需要做相应的取余操作处理，使得当尾指针绕回数组头部时，仍然可以正确处理操作。
=== "Java" === "Java"
@ -778,7 +778,7 @@ comments: true
} }
/* 入队 */ /* 入队 */
public void offer(int num) { public void push(int num) {
if (queSize == capacity()) { if (queSize == capacity()) {
System.out.println("队列已满"); System.out.println("队列已满");
return; return;
@ -848,7 +848,7 @@ comments: true
} }
/* 入队 */ /* 入队 */
void offer(int num) { void push(int num) {
if (queSize == queCapacity) { if (queSize == queCapacity) {
cout << "队列已满" << endl; cout << "队列已满" << endl;
return; return;
@ -955,8 +955,8 @@ comments: true
return q.queSize == 0 return q.queSize == 0
} }
// offer 入队 // push 入队
func (q *arrayQueue) offer(num int) { func (q *arrayQueue) push(num int) {
// 当 rear == queCapacity 表示队列已满 // 当 rear == queCapacity 表示队列已满
if q.queSize == q.queCapacity { if q.queSize == q.queCapacity {
return return
@ -1026,7 +1026,7 @@ comments: true
} }
/* 入队 */ /* 入队 */
offer(num) { push(num) {
if (this.size == this.capacity) if (this.size == this.capacity)
throw new Error("队列已满"); throw new Error("队列已满");
// 计算尾指针，指向队尾索引 + 1 // 计算尾指针，指向队尾索引 + 1
@ -1085,7 +1085,7 @@ comments: true
} }
/* 入队 */ /* 入队 */
offer(num: number): void { push(num: number): void {
if (this.size == this.capacity) if (this.size == this.capacity)
throw new Error("队列已满"); throw new Error("队列已满");
// 计算尾指针，指向队尾索引 + 1 // 计算尾指针，指向队尾索引 + 1
@ -1155,7 +1155,7 @@ comments: true
} }
/* 入队 */ /* 入队 */
public void offer(int num) public void push(int num)
{ {
if (queSize == capacity()) if (queSize == capacity())
{ {
@ -1220,7 +1220,7 @@ comments: true
} }
/* 入队 */ /* 入队 */
func offer(num: Int) { func push(num: Int) {
if size() == capacity() { if size() == capacity() {
print("队列已满") print("队列已满")
return return