mirror of
https://github.com/krahets/hello-algo.git
synced 2026-04-05 03:30:30 +08:00
build
This commit is contained in:
krahets
@@ -221,7 +221,7 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="deque.c"
|
||||
|
||||
// C 未提供内置双向队列
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -1036,9 +1036,163 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="linkedlist_deque.c"
|
||||
[class]{ListNode}-[func]{}
|
||||
/* 双向链表节点 */
|
||||
struct doublyListNode {
|
||||
int val; // 节点值
|
||||
struct doublyListNode *next; // 后继节点
|
||||
struct doublyListNode *prev; // 前驱节点
|
||||
};
|
||||
|
||||
[class]{LinkedListDeque}-[func]{}
|
||||
/* 构造函数 */
|
||||
doublyListNode *newDoublyListNode(int num) {
|
||||
doublyListNode *new = (doublyListNode *)malloc(sizeof(doublyListNode));
|
||||
new->val = num;
|
||||
new->next = NULL;
|
||||
new->prev = NULL;
|
||||
return new;
|
||||
}
|
||||
|
||||
/* 析构函数 */
|
||||
void delDoublyListNode(doublyListNode *node) {
|
||||
free(node);
|
||||
}
|
||||
|
||||
/* 基于双向链表实现的双向队列 */
|
||||
struct linkedListDeque {
|
||||
doublyListNode *front, *rear; // 头节点 front ，尾节点 rear
|
||||
int queSize; // 双向队列的长度
|
||||
};
|
||||
|
||||
/* 构造j */
|
||||
linkedListDeque *newLinkedListDeque() {
|
||||
linkedListDeque *deque = (linkedListDeque *)malloc(sizeof(linkedListDeque));
|
||||
deque->front = NULL;
|
||||
deque->rear = NULL;
|
||||
deque->queSize = 0;
|
||||
return deque;
|
||||
}
|
||||
|
||||
/* 析构函数 */
|
||||
void delLinkedListdeque(linkedListDeque *deque) {
|
||||
// 释放所有节点
|
||||
for (int i = 0; i < deque->queSize && deque->front != NULL; i++) {
|
||||
doublyListNode *tmp = deque->front;
|
||||
deque->front = deque->front->next;
|
||||
free(tmp);
|
||||
}
|
||||
// 释放 deque 结构体
|
||||
free(deque);
|
||||
}
|
||||
|
||||
/* 获取队列的长度 */
|
||||
int size(linkedListDeque *deque) {
|
||||
return deque->queSize;
|
||||
}
|
||||
|
||||
/* 判断队列是否为空 */
|
||||
bool empty(linkedListDeque *deque) {
|
||||
return (size(deque) == 0);
|
||||
}
|
||||
|
||||
/* 入队 */
|
||||
void push(linkedListDeque *deque, int num, bool isFront) {
|
||||
doublyListNode *node = newDoublyListNode(num);
|
||||
// 若链表为空，则令 front, rear 都指向node
|
||||
if (empty(deque)) {
|
||||
deque->front = deque->rear = node;
|
||||
}
|
||||
// 队首入队操作
|
||||
else if (isFront) {
|
||||
// 将 node 添加至链表头部
|
||||
deque->front->prev = node;
|
||||
node->next = deque->front;
|
||||
deque->front = node; // 更新头节点
|
||||
}
|
||||
// 对尾入队操作
|
||||
else {
|
||||
// 将 node 添加至链表尾部
|
||||
deque->rear->next = node;
|
||||
node->prev = deque->rear;
|
||||
deque->rear = node;
|
||||
}
|
||||
deque->queSize++; // 更新队列长度
|
||||
}
|
||||
|
||||
/* 队首入队 */
|
||||
void pushFirst(linkedListDeque *deque, int num) {
|
||||
push(deque, num, true);
|
||||
}
|
||||
|
||||
/* 队尾入队 */
|
||||
void pushLast(linkedListDeque *deque, int num) {
|
||||
push(deque, num, false);
|
||||
}
|
||||
|
||||
/* 访问队首元素 */
|
||||
int peekFirst(linkedListDeque *deque) {
|
||||
assert(size(deque) && deque->front);
|
||||
return deque->front->val;
|
||||
}
|
||||
|
||||
/* 访问队尾元素 */
|
||||
int peekLast(linkedListDeque *deque) {
|
||||
assert(size(deque) && deque->rear);
|
||||
return deque->rear->val;
|
||||
}
|
||||
|
||||
/* 出队 */
|
||||
int pop(linkedListDeque *deque, bool isFront) {
|
||||
if (empty(deque))
|
||||
return -1;
|
||||
int val;
|
||||
// 队首出队操作
|
||||
if (isFront) {
|
||||
val = peekFirst(deque); // 暂存头节点值
|
||||
doublyListNode *fNext = deque->front->next;
|
||||
if (fNext) {
|
||||
fNext->prev = NULL;
|
||||
deque->front->next = NULL;
|
||||
delDoublyListNode(deque->front);
|
||||
}
|
||||
deque->front = fNext; // 更新头节点
|
||||
}
|
||||
// 队尾出队操作
|
||||
else {
|
||||
val = peekLast(deque); // 暂存尾节点值
|
||||
doublyListNode *rPrev = deque->rear->prev;
|
||||
if (rPrev) {
|
||||
rPrev->next = NULL;
|
||||
deque->rear->prev = NULL;
|
||||
delDoublyListNode(deque->rear);
|
||||
}
|
||||
deque->rear = rPrev; // 更新尾节点
|
||||
}
|
||||
deque->queSize--; // 更新队列长度
|
||||
return val;
|
||||
}
|
||||
|
||||
/* 队首出队 */
|
||||
int popFirst(linkedListDeque *deque) {
|
||||
return pop(deque, true);
|
||||
}
|
||||
|
||||
/* 队尾出队 */
|
||||
int popLast(linkedListDeque *deque) {
|
||||
return pop(deque, false);
|
||||
}
|
||||
|
||||
/* 打印队列 */
|
||||
void printLinkedListDeque(linkedListDeque *deque) {
|
||||
int arr[deque->queSize];
|
||||
// 拷贝链表中的数据到数组
|
||||
int i;
|
||||
doublyListNode *node;
|
||||
for (i = 0, node = deque->front; i < deque->queSize; i++) {
|
||||
arr[i] = node->val;
|
||||
node = node->next;
|
||||
}
|
||||
printArray(arr, deque->queSize);
|
||||
}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -2004,7 +2158,124 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="array_deque.c"
|
||||
[class]{ArrayDeque}-[func]{}
|
||||
/* 基于环形数组实现的双向队列 */
|
||||
struct arrayDeque {
|
||||
int *nums; // 用于存储队列元素的数组
|
||||
int front; // 队首指针，指向队首元素
|
||||
int queSize; // 尾指针，指向队尾 + 1
|
||||
int queCapacity; // 队列容量
|
||||
};
|
||||
|
||||
/* 构造函数 */
|
||||
arrayDeque *newArrayDeque(int capacity) {
|
||||
arrayDeque *deque = (arrayDeque *)malloc(sizeof(arrayDeque));
|
||||
// 初始化数组
|
||||
deque->queCapacity = capacity;
|
||||
deque->nums = (int *)malloc(sizeof(int) * deque->queCapacity);
|
||||
deque->front = deque->queSize = 0;
|
||||
return deque;
|
||||
}
|
||||
|
||||
/* 析构函数 */
|
||||
void delArrayDeque(arrayDeque *deque) {
|
||||
free(deque->nums);
|
||||
deque->queCapacity = 0;
|
||||
}
|
||||
|
||||
/* 获取双向队列的容量 */
|
||||
int capacity(arrayDeque *deque) {
|
||||
return deque->queCapacity;
|
||||
}
|
||||
|
||||
/* 获取双向队列的长度 */
|
||||
int size(arrayDeque *deque) {
|
||||
return deque->queSize;
|
||||
}
|
||||
|
||||
/* 判断双向队列是否为空 */
|
||||
bool empty(arrayDeque *deque) {
|
||||
return deque->queSize == 0;
|
||||
}
|
||||
|
||||
/* 判断双向队列是否为空 */
|
||||
bool empty(arrayDeque *deque) {
|
||||
return deque->queSize == 0;
|
||||
}
|
||||
|
||||
int dequeIndex(arrayDeque *deque, int i) {
|
||||
// 通过取余操作实现数组首尾相连
|
||||
// 当 i 越过数组尾部时，回到头部
|
||||
// 当 i 越过数组头部后，回到尾部
|
||||
return ((i + capacity(deque)) % capacity(deque));
|
||||
}
|
||||
|
||||
/* 队首入队 */
|
||||
void pushFirst(arrayDeque *deque, int num) {
|
||||
if (deque->queSize == capacity(deque)) {
|
||||
printf("双向队列已满\r\n");
|
||||
return;
|
||||
}
|
||||
// 队首指针向左移动一位
|
||||
// 通过取余操作，实现 front 越过数组头部回到尾部
|
||||
deque->front = dequeIndex(deque, deque->front - 1);
|
||||
// 将 num 添加到队首
|
||||
deque->nums[deque->front] = num;
|
||||
deque->queSize++;
|
||||
}
|
||||
|
||||
/* 队尾入队 */
|
||||
void pushLast(arrayDeque *deque, int num) {
|
||||
if (deque->queSize == capacity(deque)) {
|
||||
printf("双向队列已满\r\n");
|
||||
return;
|
||||
}
|
||||
// 计算尾指针，指向队尾索引 + 1
|
||||
int rear = dequeIndex(deque, deque->front + deque->queSize);
|
||||
// 将 num 添加至队尾
|
||||
deque->nums[rear] = num;
|
||||
deque->queSize++;
|
||||
}
|
||||
|
||||
/* 访问队首元素 */
|
||||
int peekFirst(arrayDeque *deque) {
|
||||
// 访问异常：双向队列为空
|
||||
assert(empty(deque) == 0);
|
||||
return deque->nums[deque->front];
|
||||
}
|
||||
|
||||
/* 访问队尾元素 */
|
||||
int peekLast(arrayDeque *deque) {
|
||||
// 访问异常：双向队列为空
|
||||
assert(empty(deque) == 0);
|
||||
int last = dequeIndex(deque, deque->front + deque->queSize - 1);
|
||||
return deque->nums[last];
|
||||
}
|
||||
|
||||
/* 队首出队 */
|
||||
int popFirst(arrayDeque *deque) {
|
||||
int num = peekFirst(deque);
|
||||
// 队首指针向后移动一位
|
||||
deque->front = dequeIndex(deque, deque->front + 1);
|
||||
deque->queSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* 队尾出队 */
|
||||
int popLast(arrayDeque *deque) {
|
||||
int num = peekLast(deque);
|
||||
deque->queSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* 打印队列 */
|
||||
void printArrayDeque(arrayDeque *deque) {
|
||||
int arr[deque->queSize];
|
||||
// 拷贝
|
||||
for (int i = 0, j = deque->front; i < deque->queSize; i++, j++) {
|
||||
arr[i] = deque->nums[j % deque->queCapacity];
|
||||
}
|
||||
printArray(arr, deque->queSize);
|
||||
}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
@@ -195,7 +195,7 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="queue.c"
|
||||
|
||||
// C 未提供内置队列
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -679,7 +679,87 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="linkedlist_queue.c"
|
||||
[class]{linkedListQueue}-[func]{}
|
||||
/* 基于链表实现的队列 */
|
||||
struct linkedListQueue {
|
||||
ListNode *front, *rear;
|
||||
int queSize;
|
||||
};
|
||||
|
||||
/* 构造函数 */
|
||||
linkedListQueue *newLinkedListQueue() {
|
||||
linkedListQueue *queue = (linkedListQueue *)malloc(sizeof(linkedListQueue));
|
||||
queue->front = NULL;
|
||||
queue->rear = NULL;
|
||||
queue->queSize = 0;
|
||||
return queue;
|
||||
}
|
||||
|
||||
/* 析构函数 */
|
||||
void delLinkedListQueue(linkedListQueue *queue) {
|
||||
// 释放所有节点
|
||||
for (int i = 0; i < queue->queSize && queue->front != NULL; i++) {
|
||||
ListNode *tmp = queue->front;
|
||||
queue->front = queue->front->next;
|
||||
free(tmp);
|
||||
}
|
||||
// 释放 queue 结构体
|
||||
free(queue);
|
||||
}
|
||||
|
||||
/* 获取队列的长度 */
|
||||
int size(linkedListQueue *queue) {
|
||||
return queue->queSize;
|
||||
}
|
||||
|
||||
/* 判断队列是否为空 */
|
||||
bool empty(linkedListQueue *queue) {
|
||||
return (size(queue) == 0);
|
||||
}
|
||||
|
||||
/* 入队 */
|
||||
void push(linkedListQueue *queue, int num) {
|
||||
// 尾节点处添加 node
|
||||
ListNode *node = newListNode(num);
|
||||
// 如果队列为空，则令头、尾节点都指向该节点
|
||||
if (queue->front == NULL) {
|
||||
queue->front = node;
|
||||
queue->rear = node;
|
||||
}
|
||||
// 如果队列不为空，则将该节点添加到尾节点后
|
||||
else {
|
||||
queue->rear->next = node;
|
||||
queue->rear = node;
|
||||
}
|
||||
queue->queSize++;
|
||||
}
|
||||
|
||||
/* 访问队首元素 */
|
||||
int peek(linkedListQueue *queue) {
|
||||
assert(size(queue) && queue->front);
|
||||
return queue->front->val;
|
||||
}
|
||||
|
||||
/* 出队 */
|
||||
void pop(linkedListQueue *queue) {
|
||||
int num = peek(queue);
|
||||
ListNode *tmp = queue->front;
|
||||
queue->front = queue->front->next;
|
||||
free(tmp);
|
||||
queue->queSize--;
|
||||
}
|
||||
|
||||
/* 打印队列 */
|
||||
void printLinkedListQueue(linkedListQueue *queue) {
|
||||
int arr[queue->queSize];
|
||||
// 拷贝链表中的数据到数组
|
||||
int i;
|
||||
ListNode *node;
|
||||
for (i = 0, node = queue->front; i < queue->queSize && queue->front != queue->rear; i++) {
|
||||
arr[i] = node->val;
|
||||
node = node->next;
|
||||
}
|
||||
printArray(arr, queue->queSize);
|
||||
}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -1371,7 +1451,82 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="array_queue.c"
|
||||
[class]{arrayQueue}-[func]{}
|
||||
/* 基于环形数组实现的队列 */
|
||||
struct arrayQueue {
|
||||
int *nums; // 用于存储队列元素的数组
|
||||
int front; // 队首指针，指向队首元素
|
||||
int queSize; // 尾指针，指向队尾 + 1
|
||||
int queCapacity; // 队列容量
|
||||
};
|
||||
|
||||
/* 构造函数 */
|
||||
arrayQueue *newArrayQueue(int capacity) {
|
||||
arrayQueue *queue = (arrayQueue *)malloc(sizeof(arrayQueue));
|
||||
// 初始化数组
|
||||
queue->queCapacity = capacity;
|
||||
queue->nums = (int *)malloc(sizeof(int) * queue->queCapacity);
|
||||
queue->front = queue->queSize = 0;
|
||||
return queue;
|
||||
}
|
||||
|
||||
/* 析构函数 */
|
||||
void delArrayQueue(arrayQueue *queue) {
|
||||
free(queue->nums);
|
||||
queue->queCapacity = 0;
|
||||
}
|
||||
|
||||
/* 获取队列的容量 */
|
||||
int capacity(arrayQueue *queue) {
|
||||
return queue->queCapacity;
|
||||
}
|
||||
|
||||
/* 获取队列的长度 */
|
||||
int size(arrayQueue *queue) {
|
||||
return queue->queSize;
|
||||
}
|
||||
|
||||
/* 判断队列是否为空 */
|
||||
bool empty(arrayQueue *queue) {
|
||||
return queue->queSize == 0;
|
||||
}
|
||||
|
||||
/* 访问队首元素 */
|
||||
int peek(arrayQueue *queue) {
|
||||
assert(size(queue) != 0);
|
||||
return queue->nums[queue->front];
|
||||
}
|
||||
|
||||
/* 入队 */
|
||||
void push(arrayQueue *queue, int num) {
|
||||
if (size(queue) == capacity(queue)) {
|
||||
printf("队列已满\r\n");
|
||||
return;
|
||||
}
|
||||
// 计算队尾指针，指向队尾索引 + 1
|
||||
// 通过取余操作，实现 rear 越过数组尾部后回到头部
|
||||
int rear = (queue->front + queue->queSize) % queue->queCapacity;
|
||||
// 将 num 添加至队尾
|
||||
queue->nums[rear] = num;
|
||||
queue->queSize++;
|
||||
}
|
||||
|
||||
/* 出队 */
|
||||
void pop(arrayQueue *queue) {
|
||||
int num = peek(queue);
|
||||
// 队首指针向后移动一位，若越过尾部则返回到数组头部
|
||||
queue->front = (queue->front + 1) % queue->queCapacity;
|
||||
queue->queSize--;
|
||||
}
|
||||
|
||||
/* 打印队列 */
|
||||
void printArrayQueue(arrayQueue *queue) {
|
||||
int arr[queue->queSize];
|
||||
// 拷贝
|
||||
for (int i = 0, j = queue->front; i < queue->queSize; i++, j++) {
|
||||
arr[i] = queue->nums[j % queue->queCapacity];
|
||||
}
|
||||
printArray(arr, queue->queSize);
|
||||
}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
@@ -194,7 +194,7 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="stack.c"
|
||||
|
||||
// C 未提供内置栈
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -630,7 +630,74 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="linkedlist_stack.c"
|
||||
[class]{linkedListStack}-[func]{}
|
||||
/* 基于链表实现的栈 */
|
||||
struct linkedListStack {
|
||||
ListNode *top; // 将头节点作为栈顶
|
||||
int size; // 栈的长度
|
||||
};
|
||||
|
||||
/* 构造函数 */
|
||||
linkedListStack *newLinkedListStack() {
|
||||
linkedListStack *s = malloc(sizeof(linkedListStack));
|
||||
s->top = NULL;
|
||||
s->size = 0;
|
||||
return s;
|
||||
}
|
||||
|
||||
/* 析构函数 */
|
||||
void delLinkedListStack(linkedListStack *s) {
|
||||
while (s->top) {
|
||||
ListNode *n = s->top->next;
|
||||
free(s->top);
|
||||
s->top = n;
|
||||
}
|
||||
free(s);
|
||||
}
|
||||
|
||||
/* 获取栈的长度 */
|
||||
int size(linkedListStack *s) {
|
||||
assert(s);
|
||||
return s->size;
|
||||
}
|
||||
|
||||
/* 判断栈是否为空 */
|
||||
bool isEmpty(linkedListStack *s) {
|
||||
assert(s);
|
||||
return size(s) == 0;
|
||||
}
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
int peek(linkedListStack *s) {
|
||||
assert(s);
|
||||
assert(size(s) != 0);
|
||||
return s->top->val;
|
||||
}
|
||||
|
||||
/* 入栈 */
|
||||
void push(linkedListStack *s, int num) {
|
||||
assert(s);
|
||||
ListNode *node = (ListNode *)malloc(sizeof(ListNode));
|
||||
node->next = s->top; // 更新新加节点指针域
|
||||
node->val = num; // 更新新加节点数据域
|
||||
s->top = node; // 更新栈顶
|
||||
s->size++; // 更新栈大小
|
||||
}
|
||||
|
||||
/* 出栈 */
|
||||
int pop(linkedListStack *s) {
|
||||
if (s->size == 0) {
|
||||
printf("stack is empty.\n");
|
||||
return INT_MAX;
|
||||
}
|
||||
assert(s);
|
||||
int val = peek(s);
|
||||
ListNode *tmp = s->top;
|
||||
s->top = s->top->next;
|
||||
// 释放内存
|
||||
free(tmp);
|
||||
s->size--;
|
||||
return val;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
@@ -1131,7 +1198,60 @@ comments: true
|
||||
=== "C"
|
||||
|
||||
```c title="array_stack.c"
|
||||
[class]{arrayStack}-[func]{}
|
||||
/* 基于数组实现的栈 */
|
||||
struct arrayStack {
|
||||
int *data;
|
||||
int size;
|
||||
};
|
||||
|
||||
/* 构造函数 */
|
||||
arrayStack *newArrayStack() {
|
||||
arrayStack *s = malloc(sizeof(arrayStack));
|
||||
// 初始化一个大容量，避免扩容
|
||||
s->data = malloc(sizeof(int) * MAX_SIZE);
|
||||
s->size = 0;
|
||||
return s;
|
||||
}
|
||||
|
||||
/* 获取栈的长度 */
|
||||
int size(arrayStack *s) {
|
||||
return s->size;
|
||||
}
|
||||
|
||||
/* 判断栈是否为空 */
|
||||
bool isEmpty(arrayStack *s) {
|
||||
return s->size == 0;
|
||||
}
|
||||
|
||||
/* 入栈 */
|
||||
void push(arrayStack *s, int num) {
|
||||
if (s->size == MAX_SIZE) {
|
||||
printf("stack is full.\n");
|
||||
return;
|
||||
}
|
||||
s->data[s->size] = num;
|
||||
s->size++;
|
||||
}
|
||||
|
||||
/* 访问栈顶元素 */
|
||||
int peek(arrayStack *s) {
|
||||
if (s->size == 0) {
|
||||
printf("stack is empty.\n");
|
||||
return INT_MAX;
|
||||
}
|
||||
return s->data[s->size - 1];
|
||||
}
|
||||
|
||||
/* 出栈 */
|
||||
int pop(arrayStack *s) {
|
||||
if (s->size == 0) {
|
||||
printf("stack is empty.\n");
|
||||
return INT_MAX;
|
||||
}
|
||||
int val = peek(s);
|
||||
s->size--;
|
||||
return val;
|
||||
}
|
||||
```
|
||||
|
||||
=== "C#"
|
||||
|
||||
Reference in New Issue
Block a user