数据结构之栈、队列——算法与数据结构入门笔记（四）_c-free中q-&gt；arr[q-&gt；top](1)

做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。

别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。

我先来介绍一下这些东西怎么用，文末抱走。

---

（1）Python所有方向的学习路线（新版）

这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

最近我才对这些路线做了一下新的更新，知识体系更全面了。

（2）Python学习视频

包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。

（3）100多个练手项目

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。

（4）200多本电子书

这些年我也收藏了很多电子书，大概200多本，有时候带实体书不方便的话，我就会去打开电子书看看，书籍可不一定比视频教程差，尤其是权威的技术书籍。

基本上主流的和经典的都有，这里我就不放图了，版权问题，个人看看是没有问题的。

（5）Python知识点汇总

知识点汇总有点像学习路线，但与学习路线不同的点就在于，知识点汇总更为细致，里面包含了对具体知识点的简单说明，而我们的学习路线则更为抽象和简单，只是为了方便大家只是某个领域你应该学习哪些技术栈。

（6）其他资料

还有其他的一些东西，比如说我自己出的Python入门图文类教程，没有电脑的时候用手机也可以学习知识，学会了理论之后再去敲代码实践验证，还有Python中文版的库资料、MySQL和HTML标签大全等等，这些都是可以送给粉丝们的东西。

这些都不是什么非常值钱的东西，但对于没有资源或者资源不是很好的学习者来说确实很不错，你要是用得到的话都可以直接抱走，关注过我的人都知道，这些都是可以拿到的。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

} 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;

if (is_empty(q)) {
    q->front = new_node;
    q->rear = new_node;
} else {
    q->rear->next = new_node;
    q->rear = new_node;
}

q->size++;

}

// 出队
int dequeue(struct queue* q) {
if (is_empty(q)) {
printf(“Queue Underflow\n”);
return -1;
}

struct queue_node* temp = q->front;
int value = temp->data;

if (q->front == q->rear) {
    q->front = NULL;
    q->rear = NULL;
} else {
    q->front = q->front->next;
}

free(temp);
q->size--;

return value;

}

// 获取队首元素
int front(struct queue* q) {
if (is_empty(q)) {
printf(“Queue Underflow\n”);
return -1;
}
return q->front->data;
}

// 获取队列长度
int size(struct queue* q) {
return q->size;
}

// 销毁队列
void destroy(struct queue* q) {
while (!is_empty(q)) {
dequeue(q);
}
free(q);
}

如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费学习大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、全套PDF电子书

书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。

四、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

成为一个Python程序员专家或许需要花费数年时间，但是打下坚实的基础只要几周就可以，如果你按照我提供的学习路线以及资料有意识地去实践，你就有很大可能成功！
最后祝你好运！！！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！