printf("Stack underflow\n");
return -1;
}
item = stack->data[stack->top]; // 获取栈顶元素
stack->top--; // 栈顶指针减1
return item;
}
// 获取栈顶元素
int peek(Stack *stack) {
if (isEmpty(stack)) {
printf(“Stack is empty\n”);
return -1;
}
return stack->data[stack->top];
}
// 销毁栈
void destroy(Stack *stack) {
stack->top = -1; // 将栈顶指针重置为-1,表示栈为空
}
int main() {
Stack stack;
init(&stack);
push(&stack, 1);
push(&stack, 2);
push(&stack, 3);
printf("Top element: %d\n", peek(&stack));
printf("Popped element: %d\n", pop(&stack));
printf("Popped element: %d\n", pop(&stack));
printf("Top element: %d\n", peek(&stack));
destroy(&stack);
return 0;
}
#### 链表栈
#include <stdio.h>
#include <stdlib.h>
// 定义链表节点
typedef struct Node {
int data;
struct Node* next;
} Node;
// 定义栈结构
typedef struct {
Node* top; // 栈顶指针
} Stack;
// 初始化栈
void init(Stack* stack) {
stack->top = NULL; // 初始化栈顶指针为空
}
// 判断栈是否为空
int isEmpty(Stack* stack) {
return stack->top == NULL;
}
/* 由于链表实现的栈理论上没有大小限制,因此不存在“栈满”的情况。在入栈操作时只需要创建新节点,并将其插入到链表头部即可。
如需限制栈的大小,可以通过设置一个变量来记录当前栈中存储的元素个数,然后在入栈时进行判断,若已满则不允许再次入栈。*/
// 入栈操作
void push(Stack* stack, int item) {
Node* newNode = (Node*)malloc(sizeof(Node)); // 创建新节点
if (newNode == NULL) {
printf(“Memory allocation failed\n”);
return;
}
newNode->data = item; // 设置新节点的数据为要入栈的元素
newNode->next = stack->top; // 将新节点插入到栈顶
stack->top = newNode; // 更新栈顶指针
}
// 出栈操作
int pop(Stack* stack) {
if (isEmpty(stack)) {
printf(“Stack underflow\n”);
return -1;
}
Node* topNode = stack->top; // 获取栈顶节点
int item = topNode->data; // 获取栈顶元素
stack->top = topNode->next; // 更新栈顶指针
free(topNode); // 释放栈顶节点的内存
return item;
}
// 获取栈顶元素
int peek(Stack* stack) {
if (isEmpty(stack)) {
printf(“Stack is empty\n”);
return -1;
}
return stack->top->data;
}
// 销毁栈
void destroy(Stack* stack) {
while (!isEmpty(stack)) {
pop(stack);
}
}
int main() {
Stack stack;
init(&stack);
push(&stack, 1);
push(&stack, 2);
push(&stack, 3);
printf("Top element: %d\n", peek(&stack));
printf("Popped element: %d\n", pop(&stack));
printf("Popped element: %d\n", pop(&stack));
printf("Top element: %d\n", peek(&stack));
destroy(&stack);
return 0;
}
## 队列
队列是栈的兄弟结构,是**只允许在一端进行插入元素操作,在另一端进行删除元素操作**的线性数据结构。进行插入操作的一端称为队尾,进行删除操作的一端称为队头。队列中的数据元素遵守**先进先出** FIFO(First In First Out)的原则,即最先进入的元素最先被访问。
![请添加图片描述](https://img-blog.csdnimg.cn/ac4187587d734c87bdd1924a1adc0bab.gif#pic_center)
### 队列的特点
1. 先进先出(FIFO):第一个插入的元素是第一个被删除的元素,因此表现为先进先出的顺序。
2. 元素只能从队尾插入(入队)和从队头删除(出队)。
### 队列的应用
1. **消息传递**:在消息传递模型中,消息被发送到队列中等待接收方进行处理。发送方可以通过入队操作向队列发送消息,而接收方则通过出队操作从队列中获取消息。
2. **缓存区管理**:在网络通信、磁盘I/O等场景中,队列被用于管理数据的缓冲区。接收到的数据被放入队列中,然后按照一定的规则从队列中取出,保证数据按照顺序传输。
3. **任务调度**:操作系统中的任务调度通常使用队列来管理待执行的任务,按照先来先服务(First-Come-First-Served,FCFS)的原则进行调度。
4. **广度优先搜索**:图的广度优先搜索算法(BFS)使用队列来保存待访问的节点。从起始节点开始,将其放入队列中,然后不断从队列中取出节点,并将其邻接节点放入队列,直到队列为空。
### 队列的基本操作
1. 入队(enqueue):将元素插入到队列的末尾。
2. 出队(dequeue):从队列的头部删除一个元素并返回。
3. 获取队列头部元素的值。
4. 获取队列中元素的个数。
5. 判断队列是否为空、是否已满。
6. 队列的销毁
### C 语言
队列有两种实现方式,一种是使用数组来实现,另一种是使用链表来实现。下面是总结的用数组和链表实现的优缺点。
>
> 用数组实现的优点
> 1 . 数组在内存中是连续存储的,因此访问元素时速度较快。CPU高速缓存命中率会更高。
> 2 . 数组实现相对简单,不需要额外的指针来维护元素之间的关系。
> 数组实现的缺点
> 1 . 需要事先确定队列的最大长度,这可能会导致性能下降。
> 2 . 需要移动元素来保持队列的顺序。
>
>
>
>
> 用链表实现的优点
> 1 . 不需要事先确定队列的最大长度,可以动态扩展。
> 2 . 插入和删除操作只需要修改指针,不需要移动元素。
> 3 . 可以实现多个队列共享一个链表。
> 链表实现的缺点
> 1 . CPU高速缓存命中率会更低,不是连续存储的,因此访问元素时速度较慢。
> 2 .实现相对复杂。
>
>
>
用链表还是用数组结构实现,这个问题的答案取决于具体的应用场景和需求,下面我们给出了数组队列和链表队列的 C 语言实现。
#### 数组队列
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100 // 队列的最大大小
// 定义队列结构体
struct queue {
int* arr; // 数组指针
int front; // 队首位置
int rear; // 队尾位置
int size; // 当前队列中存储的元素个数
};
// 初始化队列
struct queue* init() {
struct queue* q = (struct queue*)malloc(sizeof(struct queue));
q->arr = (int*)malloc(MAX_SIZE * sizeof(int));
q->front = 0;
q->rear = -1;
q->size = 0;
return q;
}
// 判断队列是否为空
int is_empty(struct queue* q) {
return q->size == 0;
}
// 判断队列是否已满
int is_full(struct queue* q) {
return q->size == MAX_SIZE;
}
// 入队
void enqueue(struct queue* q, int value) {
if (is_full(q)) {
printf(“Queue Overflow\n”);
return;
}
q->rear = (q->rear + 1) % MAX_SIZE;
q->arr[q->rear] = value;
q->size++;
}
// 出队
int dequeue(struct queue* q) {
if (is_empty(q)) {
printf(“Queue Underflow\n”);
return -1;
}
int value = q->arr[q->front];
q->front = (q->front + 1) % MAX_SIZE;
q->size–;
return value;
}
// 获取队首元素
int front(struct queue* q) {
if (is_empty(q)) {
printf(“Queue Underflow\n”);
return -1;
}
return q->arr[q->front];
}
// 获取队列长度
int size(struct queue* q) {
return q->size;
}
// 销毁队列
void destroy(struct queue* q) {
free(q->arr);
free(q);
}
int main() {
struct queue* q = init();
enqueue(q, 10);
enqueue(q, 20);
enqueue(q, 30);
printf(“%d\n”, dequeue(q)); // 输出10
printf(“%d\n”, front(q)); // 输出20
enqueue(q, 40);
printf(“%d\n”, dequeue(q)); // 输出20
printf(“%d\n”, dequeue(q)); // 输出30
printf(“%d\n”, dequeue(q)); // 输出40
printf(“%d\n”, dequeue(q)); // 输出Queue Underflow
destroy(q); // 销毁队列
return 0;
}
#### 链表队列
#include <stdio.h>
#include <stdlib.h>
// 定义队列节点结构体
struct queue_node {
int data;
struct queue_node* next;
};
// 定义队列结构体
struct queue {
struct queue_node* front; // 队首指针
struct queue_node* rear; // 队尾指针
int size; // 当前队列中存储的元素个数
};
// 初始化队列
struct queue* init() {
struct queue* q = (struct queue*)malloc(sizeof(struct queue));
q->front = NULL;
q->rear = NULL;
q->size = 0;
return q;
}
// 判断队列是否为空
int is_empty(struct queue* q) {
return q->size == 0;
}
// 同链表栈,链表队列没有固定的大小限制,因此不需要判断队列是否已满
// 入队
void enqueue(struct queue* q, int value) {
// 创建新节点
struct queue_node* new_node = (struct queue_node*)malloc(sizeof(struct queue_node));
new_node->data = value;
new_node->next = NULL;
最后
不知道你们用的什么环境,我一般都是用的Python3.6环境和pycharm解释器,没有软件,或者没有资料,没人解答问题,都可以免费领取(包括今天的代码),过几天我还会做个视频教程出来,有需要也可以领取~
给大家准备的学习资料包括但不限于:
Python 环境、pycharm编辑器/永久激活/翻译插件
python 零基础视频教程
Python 界面开发实战教程
Python 爬虫实战教程
Python 数据分析实战教程
python 游戏开发实战教程
Python 电子书100本
Python 学习路线规划
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!