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

build

Browse Source
This commit is contained in:
krahets
2023-04-14 04:01:38 +08:00
parent cf431646e9
commit 4d318e8e6b
26 changed files with 469 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
chapter_stack_and_queue/deque.md
View File

@@ -323,9 +323,10 @@ comments: true
```java title="linkedlist_deque.java"
/* 双向链表节点 */
class ListNode {
int val; // 节点值
int val; // 节点值
ListNode next; // 后继节点引用（指针）
ListNode prev; // 前驱节点引用（指针）
ListNode(int val) {
this.val = val;
prev = next = null;
@@ -335,7 +336,7 @@ comments: true
/* 基于双向链表实现的双向队列 */
class LinkedListDeque {
private ListNode front, rear; // 头节点 front ，尾节点 rear
private int queSize = 0; // 双向队列的长度
private int queSize = 0; // 双向队列的长度
public LinkedListDeque() {
front = rear = null;
@@ -368,7 +369,7 @@ comments: true
// 将 node 添加至链表尾部
rear.next = node;
node.prev = rear;
rear = node; // 更新尾节点
rear = node; // 更新尾节点
}
queSize++; // 更新队列长度
}
@@ -398,17 +399,17 @@ comments: true
fNext.prev = null;
front.next = null;
}
front = fNext; // 更新头节点
front = fNext; // 更新头节点
// 队尾出队操作
} else {
val = rear.val; // 暂存尾节点值
val = rear.val; // 暂存尾节点值
// 删除尾节点
ListNode rPrev = rear.prev;
if (rPrev != null) {
rPrev.next = null;
rear.prev = null;
}
rear = rPrev; // 更新尾节点
rear = rPrev; // 更新尾节点
}
queSize--; // 更新队列长度
return val;
@@ -452,21 +453,23 @@ comments: true
```cpp title="linkedlist_deque.cpp"
/* 双向链表节点 */
struct DoublyListNode {
int val; // 节点值
DoublyListNode *next; // 后继节点指针
DoublyListNode *prev; // 前驱节点指针
DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {}
int val; // 节点值
DoublyListNode *next; // 后继节点指针
DoublyListNode *prev; // 前驱节点指针
DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {
}
};
/* 基于双向链表实现的双向队列 */
class LinkedListDeque {
private:
private:
DoublyListNode *front, *rear; // 头节点 front ，尾节点 rear
int queSize = 0; // 双向队列的长度
public:
public:
/* 构造方法 */
LinkedListDeque() : front(nullptr), rear(nullptr) {}
LinkedListDeque() : front(nullptr), rear(nullptr) {
}
/* 析构方法 */
~LinkedListDeque() {
@@ -506,7 +509,7 @@ comments: true
// 将 node 添加至链表尾部
rear->next = node;
node->prev = rear;
rear = node; // 更新尾节点
rear = node; // 更新尾节点
}
queSize++; // 更新队列长度
}
@@ -537,7 +540,7 @@ comments: true
front->next = nullptr;
delete front;
}
front = fNext; // 更新头节点
front = fNext; // 更新头节点
// 队尾出队操作
} else {
val = rear->val; // 暂存尾节点值
@@ -548,7 +551,7 @@ comments: true
rear->prev = nullptr;
delete rear;
}
rear = rPrev; // 更新尾节点
rear = rPrev; // 更新尾节点
}
queSize--; // 更新队列长度
return val;
@@ -1366,8 +1369,8 @@ comments: true
```java title="array_deque.java"
/* 基于环形数组实现的双向队列 */
class ArrayDeque {
private int[] nums; // 用于存储双向队列元素的数组
private int front; // 队首指针，指向队首元素
private int[] nums; // 用于存储双向队列元素的数组
private int front; // 队首指针，指向队首元素
private int queSize; // 双向队列长度
/* 构造方法 */
@@ -1475,12 +1478,12 @@ comments: true
```cpp title="array_deque.cpp"
/* 基于环形数组实现的双向队列 */
class ArrayDeque {
private:
vector<int> nums; // 用于存储双向队列元素的数组
int front; // 队首指针，指向队首元素
int queSize; // 双向队列长度
private:
vector<int> nums; // 用于存储双向队列元素的数组
int front; // 队首指针，指向队首元素
int queSize; // 双向队列长度
public:
public:
/* 构造方法 */
ArrayDeque(int capacity) {
nums.resize(capacity);

22
chapter_stack_and_queue/queue.md
View File

@@ -282,7 +282,7 @@ comments: true
```java title="linkedlist_queue.java"
/* 基于链表实现的队列 */
class LinkedListQueue {
private ListNode front, rear; // 头节点 front ，尾节点 rear
private ListNode front, rear; // 头节点 front ，尾节点 rear
private int queSize = 0;
public LinkedListQueue() {
@@ -350,11 +350,11 @@ comments: true
```cpp title="linkedlist_queue.cpp"
/* 基于链表实现的队列 */
class LinkedListQueue {
private:
ListNode *front, *rear; // 头节点 front ，尾节点 rear
private:
ListNode *front, *rear; // 头节点 front ，尾节点 rear
int queSize;
public:
public:
LinkedListQueue() {
front = nullptr;
rear = nullptr;
@@ -379,7 +379,7 @@ comments: true
/* 入队 */
void push(int num) {
// 尾节点后添加 num
ListNode* node = new ListNode(num);
ListNode *node = new ListNode(num);
// 如果队列为空，则令头、尾节点都指向该节点
if (front == nullptr) {
front = node;
@@ -400,7 +400,7 @@ comments: true
ListNode *tmp = front;
front = front->next;
// 释放内存
delete tmp;
delete tmp;
queSize--;
}
@@ -413,7 +413,7 @@ comments: true
/* 将链表转化为 Vector 并返回 */
vector<int> toVector() {
ListNode* node = front;
ListNode *node = front;
vector<int> res(size());
for (int i = 0; i < res.size(); i++) {
res[i] = node->val;
@@ -955,8 +955,8 @@ comments: true
```java title="array_queue.java"
/* 基于环形数组实现的队列 */
class ArrayQueue {
private int[] nums; // 用于存储队列元素的数组
private int front; // 队首指针，指向队首元素
private int[] nums; // 用于存储队列元素的数组
private int front; // 队首指针，指向队首元素
private int queSize; // 队列长度
public ArrayQueue(int capacity) {
@@ -1026,13 +1026,13 @@ comments: true
```cpp title="array_queue.cpp"
/* 基于环形数组实现的队列 */
class ArrayQueue {
private:
private:
int *nums; // 用于存储队列元素的数组
int front; // 队首指针，指向队首元素
int queSize; // 队列长度
int queCapacity; // 队列容量
public:
public:
ArrayQueue(int capacity) {
// 初始化数组
nums = new int[capacity];

25
chapter_stack_and_queue/stack.md
View File

@@ -284,9 +284,9 @@ comments: true
```java title="linkedlist_stack.java"
/* 基于链表实现的栈 */
class LinkedListStack {
private ListNode stackPeek; // 将头节点作为栈顶
private int stkSize = 0; // 栈的长度
private ListNode stackPeek; // 将头节点作为栈顶
private int stkSize = 0; // 栈的长度
public LinkedListStack() {
stackPeek = null;
}
@@ -342,11 +342,11 @@ comments: true
```cpp title="linkedlist_stack.cpp"
/* 基于链表实现的栈 */
class LinkedListStack {
private:
ListNode* stackTop; // 将头节点作为栈顶
private:
ListNode *stackTop; // 将头节点作为栈顶
int stkSize; // 栈的长度
public:
public:
LinkedListStack() {
stackTop = nullptr;
stkSize = 0;
@@ -369,7 +369,7 @@ comments: true
/* 入栈 */
void push(int num) {
ListNode* node = new ListNode(num);
ListNode *node = new ListNode(num);
node->next = stackTop;
stackTop = node;
stkSize++;
@@ -394,7 +394,7 @@ comments: true
/* 将 List 转化为 Array 并返回 */
vector<int> toVector() {
ListNode* node = stackTop;
ListNode *node = stackTop;
vector<int> res(size());
for (int i = res.size() - 1; i >= 0; i--) {
res[i] = node->val;
@@ -864,6 +864,7 @@ comments: true
/* 基于数组实现的栈 */
class ArrayStack {
private ArrayList<Integer> stack;
public ArrayStack() {
// 初始化列表（动态数组）
stack = new ArrayList<>();
@@ -910,10 +911,10 @@ comments: true
```cpp title="array_stack.cpp"
/* 基于数组实现的栈 */
class ArrayStack {
private:
private:
vector<int> stack;
public:
public:
/* 获取栈的长度 */
int size() {
return stack.size();
@@ -937,7 +938,7 @@ comments: true
/* 访问栈顶元素 */
int top() {
if(empty())
if (empty())
throw out_of_range("栈为空");
return stack.back();
}