【数据结构】栈与队列全解析(一篇文章让你从入门到进阶)_在认识栈和队列之前,先来了解一下数据结构是怎么进行分类的。前面两篇介绍了数组

最新推荐文章于 2024-10-29 22:07:14 发布
最新推荐文章于 2024-10-29 22:07:14 发布
阅读量824 收藏 21
点赞数 25
分类专栏： 2024年程序员学习 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84165919/article/details/138004485
版权

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新HarmonyOS鸿蒙全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
img

img
img
htt

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注鸿蒙）
img

正文

return ps->a[ps->top - 1];
}

int StackSize(ST* ps)
{
assert(ps);

return ps->top;
}

bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}

1.3 链栈

上文提到，链栈结构选择头作为栈顶实现入栈（头插）、出栈（头删）比较简单，所以这个结构大家可以动手写一写，与链表实现极为相似，这里不过多赘述。
在这里插入图片描述
这次，我们要实现用链尾当栈顶的非双向链表写法。由于这种写法实际用途不大，所以我们只讲解基本实现思路。

链栈结构
  1. 创建栈结构

typedef int STDataType;

typedef struct StackNode
{
struct StackNode* next;
STDataType data;
}STNode;

typedef struct Stack
{
STNode* top;
STNode* bottom;
}Stack;

这里由于单向链表的节点只能指向下一个节点，所以我们只能在栈结构中记录一下栈顶和栈底的位置。
在这里插入图片描述

链栈入栈
  1. 再来说下一个难题——如何入栈？
  • 先创建一个新节点，将所给数据存入
  • 判断bottom是否为NULL
    • 如果是，说明栈中没有数据，则让top与bottom都指向新节点
    • 如果不是，则实施尾插，尾插结束后，使top指向尾节点

void StackPush(Stack* ps, STDataType data)
{
assert(ps);

STNode* newnode = (STNode*)malloc(sizeof(STNode));
if (newnode == NULL)
{
printf(“malloc fail\n”);
exit(-1);
}
newnode->data = data;
newnode->next = NULL;

if (ps->bottom == NULL)
{
ps->bottom = ps->top = newnode;
}
else
{
ps->top->next = newnode;
ps->top = newnode;
}

}

链栈出栈
  1. 如何出栈？
  • 首先，判断是否栈中为空
  • 其次，遍历找到尾节点的前一个节点，删除数据，top指向原尾节点前一个元素
  • 这里有个特殊情况，如果栈中只有一个元素，那么删除完后，还得把bottom还原为NULL

void StackPop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));

STNode* Del = ps->bottom;

if (ps->bottom == ps->top)
{
free(ps->bottom);
ps->bottom = ps->top = NULL;
return;
}

while (Del->next != ps->top)
{
Del = Del->next;
}

free(ps->top);
Del->next = NULL;
ps->top = Del;
}

剩下的函数都不难实现，大家可以参考下文代码实现。

链栈全局代码

typedef int STDataType;

typedef struct StackNode
{
struct StackNode* next;
STDataType data;
}STNode;

typedef struct Stack
{
STNode* top;
STNode* bottom;
}Stack;

// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈底元素
STDataType StackBottom(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
bool StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);

void StackInit(Stack* ps)
{
assert(ps);
ps->top = NULL;
ps->bottom = NULL;
}

void StackDestroy(Stack* ps)
{
assert(ps);

STNode* cur = ps->bottom;

while (cur)
{
STNode* next = cur->next;
free(cur);
cur = next;
}

ps->bottom = ps->top = NULL;
}

bool StackEmpty(Stack* ps)
{
assert(ps);

return ps->bottom == NULL;
}

void StackPush(Stack* ps, STDataType data)
{
assert(ps);

STNode* newnode = (STNode*)malloc(sizeof(STNode));
if (newnode == NULL)
{
printf(“malloc fail\n”);
exit(-1);
}
newnode->data = data;
newnode->next = NULL;

if (ps->bottom == NULL)
{
ps->bottom = ps->top = newnode;
}
else
{
ps->top->next = newnode;
ps->top = newnode;
}

}

void StackPop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));

STNode* Del = ps->bottom;

if (ps->bottom == ps->top)
{
free(ps->bottom);
ps->bottom = ps->top = NULL;
return;
}

while (Del->next != ps->top)
{
Del = Del->next;
}

free(ps->top);
Del->next = NULL;
ps->top = Del;
}

STDataType StackTop(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));

return ps->top->data;
}

STDataType StackBottom(Stack* ps)
{
assert(ps);
assert(!StackEmpty(ps));

return ps->bottom->data;
}

int StackSize(Stack* ps)
{
assert(ps);

int sz = 0;
STNode* cur = ps->bottom;

while (cur)
{
sz++;
cur = cur->next;
}

return sz;
}

2.队列

2.1 队列的定义和结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 的性质。
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头
在这里插入图片描述

这个结构，我们可以想到什么呢？
没错，就像是一列火车。我们可以做个假设，把每个节点视为一个火车车厢，那么一个队列结构就好像是一列直行的火车。那么入队就可以视为火车进站时，车厢依次入站，前面的车厢先进，后面的车厢后进；出队就可以理解为，火车出站时，前面的车厢先离开，后面的车厢后离开。
我们以上面的队列为例，先来感受一下先进先出的特点：
入队(进站)：
在这里插入图片描述
从数据在队列中的存储状态可以分析出，元素 1 最先进队，其次是元素 2，以此类推，最后是元素 5。
出队 (出队)：
请添加图片描述
根据队列 “先进先出” 的特点，元素 1 要先出队列，元素 2 再出队列，以此类推，最后才轮到元素 5 出队列。

现在我们来对比一下栈和队列：

栈是先进后出 ，为一端封闭，另一端完成插入和删除；而队列是先进先出，一段插入，另一端删除。 这个不同一定要记住，不要混淆了。(入栈与出栈的演示)

在了解了队列的基本结构以后，我们现在就可以尝试实现队列结构了。
1️⃣那么，第一个问题是，选择顺序表还是链表来实现队列呢？
要完成一个结构，很关键的步骤就是，插入和删除数据。
假设我们选择顺序表：

  • 当我们选择顺序表头为队头时：
    入队过程：
    请添加图片描述

入队过程可以看到过程十分的繁琐，时间复杂度为O(n)，出队也相同，这样的代价我们是不能接受的。

  • 当我们选择顺序表尾为队头时：
    入队操作就基本无法实现，因为我们不知道要存多少个数据，所以队头的下标就不能确定。但是这也给我们提了一个醒，队列的元素个数确定，我们就可以使用顺序表来实现队列(此处是一个伏笔)。

所以，我们要选择在物理结构上不联系，并且方便插入和删除的链表来实现。

具体结构如下图：
在这里插入图片描述

2.2 链队列

链队列结构

链队列节点的结构与链表节点相同，这里我们不再赘述。 (链表全解析)
但是考虑到队列有队头和队尾，我们要在队列的结构中存储队头和队尾的指针(这一点与链栈很相似)。

  • 具体代码实现如下：

typedef int QDataType;

// 链式结构：表示队列
typedef struct QListNode
{
struct QListNode* next;
QDataType data;
}QNode;

// 队列的结构
typedef struct Queue
{
QNode* front;//队头
QNode* rear;//队尾
}Queue;

实现完结构后，我们现在就要来实现接口函数。

// 初始化队列
void QueueInit(Queue* q);
// 队尾入队列
void QueuePush(Queue* q, QDataType data);
// 队头出队列
void QueuePop(Queue* q);
// 获取队列头部元素
QDataType QueueFront(Queue* q);
// 获取队列队尾元素
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* q);
// 销毁队列
void QueueDestroy(Queue* q);

初始化和销毁
  • 初始化是老规矩了，将头和尾指针置为空；
  • 销毁时，从队头开始，逐个遍历释放，最后将头尾指针置零。

void QueueInit(Queue* q)
{
assert(q);

q->front = NULL;
q->rear = NULL;
}

void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->front;

while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}

q->front = NULL;
q->rear = NULL;
}

入队
  • 由于队列先入先出的性质，所以第一个元素始终占据队头，如果要插入其他数据，就得用尾插，以保证先来的占据头，后来的在尾；
  • 这里我们要分类讨论一下，如果队列为空，这时头尾指针都指向NULL，插入第一个元素时，头和尾都是这个元素；
    在这里插入图片描述
  • 如果队列不为空，此时头指针不需要移动，只需要在将原最后一个元素的next指向新节点，尾指针也指向新节点即可。
    我们以入队元素 1，元素 2，元素 3，元素 4为例：
    在这里插入图片描述
    在这里插入图片描述

入队完成
在这里插入图片描述
我们再以入队元素 1，元素 2为例
可以再动态感受一下：
在这里插入图片描述

  • 代码实现：

void QueuePush(Queue* q, QDataType data)
{
assert(q);

QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
printf(“malloc fail\n”);
exit(-1);
}

newnode->next = NULL;
newnode->data = data;

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

判断队列是否为空 及 获取队列中元素个数
  • 判断是否为空，其实就是判断头指针或尾指针是否指向NULL(只要队列中有元素，头尾指针都不可能为空)。如果是，则为空；如不是，则不为空。
  • 获取队列中个数，说白了就是从队头开始遍历，直到队尾，统计出数据个数。

bool QueueEmpty(Queue* q)
{
assert(q);

return q->front == NULL;
}

int QueueSize(Queue* q)
{
assert(q);

int sz = 0;
QNode* cur = q->front;

while (cur)
{
sz++;
cur = cur->next;
}

return sz++;
}

出队
  • 出队，就是要删除队头的元素，对于结构操作来说，就是头删，注意事项也和头删相同
  • 首先，要保证队里不为空，用上面判断是否为空的函数就可以实现
  • 其次，当删最后一个节点时，不仅头指针要置为空，尾指针也要置空
    在这里插入图片描述
    在这里插入图片描述
  • 代码实现：

void QueuePop(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));

QNode* next = q->front->next;

free(q->front);
q->front = next;

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

获取队头/队尾元素
  • 这个其实非常简单啦，因为存储了队头队尾的指针，所以直接就可以找到数据(还是要保证队列不为空)。

QDataType QueueFront(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));

return q->front->data;
}

QDataType QueueBack(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));

return q->rear->data;
}

链队列全局代码

typedef int QDataType;

// 链式结构：表示队列
typedef struct QListNode
{
struct QListNode* next;
QDataType data;
}QNode;

// 队列的结构
typedef struct Queue
{
QNode* front;
QNode* rear;
}Queue;

void QueueInit(Queue* q)
{
assert(q);

q->front = NULL;
q->rear = NULL;
}

void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->front;

while (cur)
{
QNode* next = cur->next;
free(cur);
cur = next;
}

q->front = NULL;
q->rear = NULL;
}

bool QueueEmpty(Queue* q)
{
assert(q);

return q->front == NULL;
}

void QueuePush(Queue* q, QDataType data)
{
assert(q);

QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
printf(“malloc fail\n”);
exit(-1);
}

newnode->next = NULL;
newnode->data = data;

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

void QueuePop(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));

QNode* next = q->front->next;

free(q->front);
q->front = next;

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

QDataType QueueFront(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));

return q->front->data;
}

QDataType QueueBack(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));

return q->rear->data;
}

int QueueSize(Queue* q)
{
assert(q);

int sz = 0;
QNode* cur = q->front;

while (cur)
{
sz++;
cur = cur->next;
}

return sz++;
}

从这里开始就是进阶内容了，加油，一起变得更强！
为了避免冗余，进阶内容主要讲实现思想，对于具体代码实现操作只会简单提及，但仍会有每一个函数的代码实现。

2.3 循环队列

循环链表定义和结构

还记不记得前文我的伏笔，现在我就来回收这个伏笔。
如果有元素个数确定，那么我们是可以使用顺序表来实现的，并且为了提高空间的利用率，我们要把它设计成可以重复利用相同空间的结构，所以我们要让队列成一个循环。
在这里插入图片描述

从上图我们可以看出循环队列只是在逻辑上是循环的，其实它仍然是个顺序表，只不过通过调控下标来保证循环。

  • 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。
  • 它也被称为“环形缓冲器”。
  • 储存空间大小确定
  • 循环队列的一个好处是我们可以利用这个队列之前用过的空间。
  • 结构具体实现：

typedef int CQDataType;

typedef struct {
CQDataType* arr;
int front;//队头
int tail;//队尾，这里的队尾就是最后一个元素的下一个位置
int k;//最大存储元素的个数
} MyCircularQueue;

循环队列实现思路

初始化这一步可以说是关键，因为这里我们要开辟k+1个空间，原因如下图：
在这里插入图片描述
如果只开辟k个空间：

  • 当队列为空时：
    在这里插入图片描述
    当队列为空时，队列的头指针等于队列的尾指针；
  • 当队列满时：
    在这里插入图片描述

当数组满员时，队列的头指针等于队列的尾指针；

所以要开辟k+1个空间用来判断。
当用顺序表实现时：
在这里插入图片描述
也即
在这里插入图片描述

当用链表实现时：
在这里插入图片描述

这个核心思路有了，剩下的函数就依照上文的思路，控制好下标实现即可。

顺序表循环链表全局实现

typedef int CQDataType;

typedef struct {
CQDataType* arr;
int front;
int tail;
int k;
} MyCircularQueue;

//初始化循环队列
MyCircularQueue* myCircularQueueCreate(int k);
//入队(尾插)
bool myCircularQueueEnQueue(MyCircularQueue* obj, CQDataType value);
//出队(头删)
bool myCircularQueueDeQueue(MyCircularQueue* obj);
//取队头数据
CQDataType myCircularQueueFront(MyCircularQueue* obj);
//取队尾数据
CQDataType myCircularQueueRear(MyCircularQueue* obj);
//判断队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
//判断队列是否已满
bool myCircularQueueIsFull(MyCircularQueue* obj);
//销毁队列
void myCircularQueueFree(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k)
{
MyCircularQueue* pq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
if (pq == NULL)
{
printf(“malloc fail”);
exit(-1);
}
pq->arr = (CQDataType*)malloc(sizeof(CQDataType) * (k + 1));//多开一个空间，以便于判空和判满
pq->front = 0;
pq->tail = 0;
pq->k = k;

return pq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, CQDataType value)
{
assert(obj);

if (myCircularQueueIsFull(obj))
{
return false;
}

obj->arr[obj->tail] = value;
obj->tail++;
obj->tail %= (obj->k + 1);//可使tail始终在0~k内
return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
assert(obj);

if (myCircularQueueIsEmpty(obj))
{
return false;
}

obj->front++;
obj->front %= (obj->k + 1);
return true;
}

CQDataType myCircularQueueFront(MyCircularQueue* obj)
{
assert(obj);
assert(!myCircularQueueIsEmpty(obj));

return obj->arr[obj->front];
}

CQDataType myCircularQueueRear(MyCircularQueue* obj)
{
assert(obj);
assert(!myCircularQueueIsEmpty(obj));

return obj->arr[(obj->tail + obj->k) % (obj->k + 1)];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
assert(obj);

return obj->front == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj)
{
return (obj->tail + 1) % (obj->k + 1) == (obj->front);
}

void myCircularQueueFree(MyCircularQueue* obj)
{
assert(obj);

free(obj->arr);
free(obj);
}

链表循环链表全局实现

typedef int CQDataType;

typedef struct CQNode
{
CQDataType data;
struct CQNode* next;
}CQNode;

typedef struct {
CQNode* front;
CQNode* tail;
CQNode* end;
CQNode* start;
int k;
} MyCircularQueue;

// 判空
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
// 判满
bool myCircularQueueIsFull(MyCircularQueue* obj);
// 创建循环链表
MyCircularQueue* myCircularQueueCreate(int k);
// 入队
bool myCircularQueueEnQueue(MyCircularQueue* obj, CQDataType value);
// 出队
bool myCircularQueueDeQueue(MyCircularQueue* obj);
// 获取队头元素
CQDataType myCircularQueueFront(MyCircularQueue* obj);
// 获取队尾元素
CQDataType myCircularQueueRear(MyCircularQueue* obj);
// 销毁
void myCircularQueueFree(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
if (cq == NULL)
{
printf(“malloc fail\n”);
exit(-1);
}

cq->k = k;
cq->front = NULL;
cq->tail = NULL;

for (int i = 0; i < k + 1; i++)
{
CQNode* newnode = (CQNode*)malloc(sizeof(CQNode));
if (newnode == NULL)
{
printf(“malloc fail\n”);
exit(-1);
}
newnode->next = NULL;
if (cq->front == NULL)
{
cq->front = cq->tail = newnode;
cq->start = newnode;
}
else
{
cq->tail->next = newnode;
cq->tail = newnode;
}
}
cq->end = cq->tail;

cq->tail->next = cq->front;
cq->tail = cq->front;

return cq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, CQDataType value) {
assert(obj);

if (myCircularQueueIsFull(obj))
{
return false;
}

if (myCircularQueueIsEmpty(obj))
{
obj->front->data = obj->tail->data = value;
obj->tail = obj->tail->next;
}
else
{
obj->tail->data = value;
obj->tail = obj->tail->next;
}

return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
assert(obj);

if (myCircularQueueIsEmpty(obj))
{
return false;
}

obj->front = obj->front->next;
return true;
}

CQDataType myCircularQueueFront(MyCircularQueue* obj) {
assert(obj);

if (myCircularQueueIsEmpty(obj))
{
return -1;
}

return obj->front->data;
}

CQDataType myCircularQueueRear(MyCircularQueue* obj) {
assert(obj);

if (myCircularQueueIsEmpty(obj))
{
return -1;
}

CQNode* cur = obj->front;
while (cur->next != obj->tail)
{
cur = cur->next;
}

return cur->data;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
assert(obj);

return obj->tail == obj->front;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
assert(obj);

return obj->tail->next == obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) {
assert(obj);

CQNode* cur = obj->start;

while (cur != obj->end)
{
CQNode* next = cur->next;
free(cur);
cur = next;
}

free(obj->end);
free(obj);
}

3.用栈实现队列

在这里插入图片描述

核心思路

核心思路：

  • 两个队列，入数据往不为空的队列里入；
    在这里插入图片描述
  • 出数据或者取栈顶元素，先将不为空的那个队列最后一个数据元素前的元素全移到另一个队列中，再出那个队列最后一个元素(栈顶元素)。
    请添加图片描述
  • 如此往复，就能实现先入后出。
    请添加图片描述

全局实现

typedef int QDataType;

// 链式结构：表示队列
typedef struct QListNode
{
struct QListNode* next;
QDataType data;
}QNode;

// 队列的结构
typedef struct Queue
{
QNode* front;
QNode* rear;
}Queue;

typedef struct {
Queue q1;
Queue q2;
} MyStack;

// 初始化队列
void QueueInit(Queue* q);
// 队尾入队列
void QueuePush(Queue* q, QDataType data);
// 队头出队列
void QueuePop(Queue* q);
// 获取队列头部元素
QDataType QueueFront(Queue* q);
// 获取队列队尾元素
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* q);
// 销毁队列
void QueueDestroy(Queue* q);

MyStack* myStackCreate();
void myStackPush(MyStack* obj, QDataType x);
QDataType myStackPop(MyStack* obj);
QDataType myStackTop(MyStack* obj);
bool myStackEmpty(MyStack* obj);
void myStackFree(MyStack* obj);

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

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注鸿蒙）
img

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

if)

  • 出数据或者取栈顶元素，先将不为空的那个队列最后一个数据元素前的元素全移到另一个队列中，再出那个队列最后一个元素(栈顶元素)。
    请添加图片描述
  • 如此往复，就能实现先入后出。
    请添加图片描述

全局实现

typedef int QDataType;

// 链式结构：表示队列
typedef struct QListNode
{
struct QListNode* next;
QDataType data;
}QNode;

// 队列的结构
typedef struct Queue
{
QNode* front;
QNode* rear;
}Queue;

typedef struct {
Queue q1;
Queue q2;
} MyStack;

// 初始化队列
void QueueInit(Queue* q);
// 队尾入队列
void QueuePush(Queue* q, QDataType data);
// 队头出队列
void QueuePop(Queue* q);
// 获取队列头部元素
QDataType QueueFront(Queue* q);
// 获取队列队尾元素
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* q);
// 销毁队列
void QueueDestroy(Queue* q);

MyStack* myStackCreate();
void myStackPush(MyStack* obj, QDataType x);
QDataType myStackPop(MyStack* obj);
QDataType myStackTop(MyStack* obj);
bool myStackEmpty(MyStack* obj);
void myStackFree(MyStack* obj);

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

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注鸿蒙）
[外链图片转存中…(img-4SceNz9X-1713604120589)]

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

2401_84165919
关注
专栏目录
Redis框架从入门到学精（全）
码农研究僧的博客
07-02 2万+
目录前言1.NoSQL2.Redis2.1 软件安装数据类型 前言 解决功能新问题：JAVA jsp rdsms tomcat html linux jdbc svn 解决发展性问题：strtus spring springmvc hibernate mybatis 解决性能问题：NOSQL java 线程 hadoop nginx mq elasticsearch 1.NoSQL NoSQL特点 非关系型数据库，不依赖业务逻辑数据库存储，以简单key-value存储 适用于 ~高并发读写 ~海量数据读
【栈 进 阶】
qq_61079540的博客
04-29 65
栈和队列对应两种不同的处理顺序，以及两个相应的数据结构栈：先进后出。例如：仓库进货、出货。队列：先进先出。例如：排队打疫苗。
【数据结构】栈与队列全解析(一篇文章让你从入门到进阶)
白晨的博客
01-03 755
☀️ HELLO,大家好，我是白晨❤️呀！????今天又到了我们一起来学习的时间啦????，苦心人、天不负，卧薪尝胆，三千越甲可吞吴，一起加油吧????????。 前言 在顺序表和链表中我们讲述了数据结构最基本的两种结构，今天我们就要在这两种数据结构的基础上来继续认识另外两种数据结构——栈和队列。 为了内容的完整性以及可读性(主要是有进阶内容)，我将前一篇文章栈结构全解析也搬到了这里。 废话不多说，正文见下 1.栈 1.1 栈的定义及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删
数据结构：数组、链表、栈、队列的理解
weixin_30512785的博客
04-10 828
解释定义 数据结构： 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。再简单描述一下：数据结构就是描述对象间逻辑关系的学科。 如果还是不太清楚下面会举例说明的。 数据存储结构： 简单的讲就是数据在计算机中的存储方式。 常用的数据存储方式有两种：顺序存储，非顺序存储。顺序存储就是把数据存储在一块联系的存储介质（硬盘或内存等）中。反之就是非顺序存储咯。Java中的数组就是典型的...
《算法和数据结构》从语言到算法的过渡篇
英雄哪里出来
09-30 4万+
《算法和数据结构》学习路线总纲
python爬虫从入门到进阶分享_Python 爬虫从入门到进阶之路（十七）
weixin_39517546的博客
11-29 113
在之前的文章中我们介绍了 scrapy 框架并给予 scrapy 框架写了一个爬虫来爬取《糗事百科》的糗事，本章我们继续说一下 scrapy 框架并对之前的糗百爬虫做一下优化和丰富。在上一篇文章中，我们在项目中创建了一个 qiushiSpider.py 的文件，代码如下：1 importscrapy2 from ..items importQiushiItem345 classQiushiSpid...
【容器化技术】Docker从入门到进阶，一遍文章就够了
古采尼的博客
03-12 1856
Docker从入门到进阶，一遍文章就够了
《算法和数据结构》题海战术篇
英雄哪里出来
09-12 5万+
刷了 3333 题 算法题 后的一点点经验总结 —— 题不是这么刷的！
牛逼！Java 从入门到精通，超全汇总版
程序员cxuan的个人主页
05-06 7万+
文章目录Java 基础Head First JavaJava 核心技术卷一Java 编程思想设计模式Head First 设计模式图解设计模式设计模式重学 Java 设计模式Java 进阶Java 并发编程实战Java 并发编程艺术Java 并发编程之美图解Java多线程设计模式JVM深入理解 Java 虚拟机Java 虚拟机规范HotSpot 实战自己动手写 Java 虚拟机MySQLMySQL 基础教程SQL 基础教程深入浅出 MySQLMySQL 必知必会SQL 必知必会高性能 MySQLMySQL
Python实现基本数据结构中队列的操作方法示例
09-21
### Python 实现基本数据结构中队列的操作方法详解 #### 一、队列的基本概念 队列（Queue）是一种特殊的线性表，它只允许在一端进行插入操作，在另一端进行删除操作。进行插入操作的一端称为队尾（rear），进行删除...
2024年Unity 面试题 |五萬字 二佰道| Unity面试题大全，面试题总结【全网最全，收藏一篇足够面试】
热门推荐
努力前行，总会成为自己心中的那道光
02-23 12万+
正所谓 金三银四 ，又到了找工作的大好时机了，不知道大家有没有意向找一份更好的工作呢~ 之前写了很多Unity的学习和实例文章，但是面试题部分还没有一个系统的整理。 那本篇文章就来整理一下Unity中一些常见的面试题，说不准就会面试的时候就会遇到！ 本篇文章会将Unity所有方面的面试资料都融会贯通，绝对是2022年Unity面试领域最实用的文章啦！
《英雄编程体验课》第 15 课 | C语言中的数学库
英雄哪里出来
07-05 5万+
C语言中的数学库
《算法和数据结构》从语言到算法的过渡篇_当语言学到什么程度可以开始学算法了
2401_84586779的博客
04-26 2571
看到太多爆肝熬夜整合的内容，又是几万字，又是爆肝，我也来试试看能不能扛得住。试完后发现，果然还是扛不住啊。但是既然整理完了，那就把我的算法学习路线发出来吧，我把整个算法学习的阶段总结成了五个步骤，分别为：「 基础语法 」「 语法练习 」「 数据结构 」「 算法入门 」「 算法进阶 」。本文梳理了这五个大项的思维导图，在下文会有详细介绍。希望各位能够找到自己的定位，通过自己的努力在算法这条路上越走越远。刚开始切勿心浮气躁，说一定要把这么多东西都学会。就算你的精力旺盛，日夜操劳，时间也是有限的。
通用型函数——冒泡排序
2401_84654619的博客
10-29 280
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
数据结构：并查集
最新发布
2303_78940834的博客
10-29 836
在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。举个例子看看比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，武汉招3人，10个人来自不同的学校，起先互不相识，每个学生都是一个独立的小团体，现给这些学生进行编号：{0, 1, 2, 3,
python之数据结构与算法（数据结构篇）-- 集合
2301_81807150的博客
10-26 437
集合就是元素的集合体。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3799
BSP驱动开发工程师-OS、4 道编程题
【数据结构-邻项消除】力扣2216. 美化数组的最少删除数
sjsjs11的博客
10-29 355
我们定义一个变量i来记录在构造完美数组中的索引，当i为偶数的时候，我们就让原数组的元素为preNum，如果当i为奇数，并且nums不等于preNum的时候，那么我们可以将num放到i位置，然后我们让i++指向下一个位置。解释：可以删除 nums[0] 或 nums[1] ，这样得到的 nums = [1,2,3,5] 是一个美丽数组。解释：可以删除 nums[0] 和 nums[5] ，这样得到的 nums = [1,2,2,3] 是一个美丽数组。输入：nums = [1,1,2,2,3,3]
java常用数据结构及其接口
weixin_48485132的博客
10-29 431
**LinkedList（作为 Queue 和 Deque）**：同时支持队列和双端队列操作。- **ArrayList**：动态数组，支持快速随机访问，但在插入和删除操作时可能较慢。- **PriorityQueue**：基于优先级的队列，元素根据自然排序或比较器排序。- **LinkedList**：双向链表，适合频繁插入和删除操作。- **TreeSet**：有序集合，使用红黑树实现。- **HashMap**：键值对存储，允许快速查找。- **HashSet**：不允许重复元素，无序。
Java版数据结构与算法入门指南
4. **第四章：栈和队列** - 介绍这两种基础数据结构及其在问题解决中的应用，如递归、回溯算法等。 5. **第五章：链表** - 链表是另一种重要的数据结构，作者会深入讲解单链表、双向链表和循环链表，以及如何处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值