【C语言】栈和队列是什么，我该怎么去使用？

已于 2024-01-19 14:21:04 修改
阅读量57 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： c语言 数据结构 算法
于 2023-10-21 11:03:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KQ_EB/article/details/133951423
版权

栈

概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端
称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。

实现 

数组和链表都可以实现，相对而言数组结构更优一些

注意初始化时候的定值：

我们初始化时定义top为0,所以真实的Top是下标为top-1的元素

我们用的是第一个方法也就是top为0 

创一个源文（Stack.c）件和一个头文件（Stack.h）

Stack.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps); 
// 入栈 
void StackPush(Stack* ps, STDataType data); 
// 出栈 
void StackPop(Stack* ps); 
// 获取栈顶元素 
STDataType StackTop(Stack* ps); 
// 获取栈中有效元素个数 
int StackSize(Stack* ps); 
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps); 
// 销毁栈 
void StackDestroy(Stack* ps);

 Stack.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"
void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void STDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;

	ps->top = ps->capacity = 0;
}

void STPush(ST* ps, STDataType* x)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}

void STPop(ST* ps)
{
	assert(ps);

	//空
	assert(ps->top > 0);

	ps->top--;
}

STDataType STTop(ST* ps)
{
	assert(ps);

	//空
	assert(ps->top > 0);

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

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

	return ps->top;
}

bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

队列

概念：

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)

入队列：进行插入操作的一端称为队尾

出队列：进行删除操作的一端称为队头

实现： 

这次我们用链表会更优，可以想一下医院挂号时的场景

注意入队和出队时的情况：

Queue.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		// 栈顶
	int _capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps); 
// 入栈 
void StackPush(Stack* ps, STDataType data); 
// 出栈 
void StackPop(Stack* ps); 
// 获取栈顶元素 
STDataType StackTop(Stack* ps); 
// 获取栈中有效元素个数 
int StackSize(Stack* ps); 
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps); 
// 销毁栈 
void StackDestroy(Stack* ps);

Queue.c

#include"Queue.h"

void QueueInit(Que* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueueDestroy(Que* pq)
{
	assert(pq);

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

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueuePush(Que* pq, QDatatype x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

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

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

void QueuePop(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}


	pq->size--;
}
QDatatype QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QDatatype QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

bool QueueEmpty(Que* pq)
{
	assert(pq);

	return pq->head == NULL;
}

int QueueSize(Que* pq)
{
	assert(pq);

	return pq->size;
}

相关OJ题

用队列实现栈

题目

 思路：

重点部分代码：

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


MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);

		return pst;
}

void myStackPush(MyStack* obj, int x) {
    if (!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        QueuePush(&obj->q2, x);
    }
}

int myStackPop(MyStack* obj) {
    Que* empty = &obj->q1;
    Que* nonEmpty = &obj->q2;
    if (!QueueEmpty(&obj->q1))
    {
        nonEmpty = &obj->q1;
        empty = &obj->q2;
    }

    // 前size-1个导入
    while (QueueSize(nonEmpty) > 1)
    {
        QueuePush(empty, QueueFront(nonEmpty));
        QueuePop(nonEmpty);
    }

    int top = QueueFront(nonEmpty);
    QueuePop(nonEmpty);

    return top;
}

int myStackTop(MyStack* obj) {
    if (!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);

}

之前学的队列声明和定义都要拷贝进去，这只是代码重点 

 用栈实现队列

题目描述：

思路： 

 

重点部分代码 ：

ypedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->pushst);
    STInit(&obj->popst);

		return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    STPush(&obj->pushst, x);
}

int myQueuePeek(MyQueue* obj) {
    if (STEmpty(&obj->popst))
    {
        // 倒数据
        while (!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst, STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }

    return STTop(&obj->popst);
}

int myQueuePop(MyQueue* obj) {
    int front = myQueuePeek(obj);
    STPop(&obj->popst);
    return front;
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->pushst) && STEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->popst);
    STDestroy(&obj->pushst);

    free(obj);
}

和之前一样，要把栈的声明和定义加进去。

设计循环队列 

题目描述：

思路：

先感受一下循环的整个过程

 

代码： 

typedef struct {
    int * a;
    int front;
    int rear;
    int k
} MyCircularQueue;

//构造器，设置队列长度为 k 。
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue *obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    // 多开一个空间方便区分空和满
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    obj->front = obj->rear = 0;
    obj->k = k;

    return obj;
}//去写空和满

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->rear;
}

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

//向循环队列插入一个元素。如果成功插入则返回真。
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->rear] = value;
    obj->rear++;

    obj->rear %= (obj->k + 1);

    return true;
}


bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }

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

//从队首获取元素。如果队列为空，返回 -1 。
int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[obj->front];
    }
}

//获取队尾元素。如果队列为空，返回 -1 。
int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->a[(obj->rear + obj->k) % (obj->k + 1)];
    }
}



void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

可能难理解的地方 

enQueue(value) 向循环队列插入一个元素。如果成功插入则返回真。

deQueue(): 从循环队列中删除一个元素 。如果成功删除则返回真。

Rear: 获取队尾元素。如果队列为空，返回 -1 。

 这个公式直接记的住就记记不住下次用到的时候再来看，问题不大。

总结：主要是思路要捋清楚，看清题目的要求，代码不是特别难。

No more cages
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c语言栈和队列实验报告,数据结构与算法实验报告栈
weixin_42500616的博客
05-18 1679
数据结构与算法实验报告栈Tag内容描述：1、实验二 栈和队列实现四则运算 一、实验目的及要求： 1、掌握栈和队列的基本操作：建立、插入、删除、查找、合并 2、掌握用栈和队列的储存 3、熟悉C语言上机编程环境 4、掌握编译、调试程序的方法 二、实验内容： 采用栈进行表达式的求值，表达式求值是程序设计语言编译中的一个最基本问题。它的实现是栈应用的又一个典型例子，本报告使用的是“算符优先法”求表达式的值...
C语言中栈和队列实现表达式求值的实例
08-29
主要介绍了C语言中栈和队列实现表达式求值的实例的相关资料,这里主要是对数据结构中栈和队列的理解和应用，需要的朋友可以参考下
C语言栈和队列的实现
k666499436的博客
05-28 4379
详细讲解栈与队列的定义和特性，用C语言分别实现顺序栈、链栈、顺序(循环)队列、链队列，已经顺序存储与链式存储的区别
C语言中对栈和队列的使用详解
weixin_41872439的博客
08-23 1909
C语言详细介绍如何使用数组对栈进行实现，以及使用链表对队列进行实现。
《数据结构C语言版》——栈和队列详解(图文并茂)，从零开始的学习
青春无问西东 岁月自成芳华
04-20 4239
一文搞懂数据结构系列之栈和队列部分，从0基础到快速手敲数据结构，小白也能轻松看懂的宝典！
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
C语言栈和队列总结
WanTonSam的博客
09-20 533
栈 栈是限定仅在表尾进行插入和删除操作的线性表 结构定义 typedef int SElenType typedef struct { SElemType data[MAXSIZE]; int top; }Sqstack; 进栈操作 Status push(Sqstack *S,SElemType e) { if(S->top==MAXSIZE-1) return error; //栈满 S->top++; S->data[S->top]=e; return OK;
C语言使用栈和队列实现停车场管理
雨天的麦子的博客
06-25 9705
C语言利用栈和队列实现停车场管理 这次做的是C语言利用栈实现停车场管理–纯手打非转载 停车场管理 [问题描述] 设停车场是一个可停放n辆车的狭长通道，且只有一个大门可供汽车进出。在停车场内，汽车按到达的先后次序，由北向南依次排列（假设大门在最南端）。若车场内已停满n辆车，则后来的汽车需在门外的便道上等候，当有车开走时，便道上的第一辆车即可开入。当停车场内某辆车要离开时，在它之后进入的车辆必须先退出...
C语言实现栈和队列(动态)
2301_76269963的博客
03-28 1591
C语言实现栈和队列(动态)
数据结构入门（C语言版）栈和队列之队列的介绍及实现
立志做一个高产且细节博主
04-10 615
队列的介绍及实现
C语言---栈和队列
qq_62743629的博客
05-01 3194
严格来说,栈和队列都属于线性表 "一对一" 栈:"先进后出" 队列: "先进先出" 栈 栈只能从一端存取,另一端是封闭的 在栈中,不论是存还是取,都必须遵循"先进后出"的原则 ==>栈是一种只能从表的一端存取数据,且遵循"先进后出"原则的线性存储结构 进栈和出栈 进栈:将数据存储到栈里面去 出栈:将数据从栈中间取出来 栈的实现方法 栈:有点"特殊"的线性存储结构 顺序表==>顺序栈 (顺序存储结构) 链表==>链栈 (链式存储结构)
C语言 表、栈和队列详解及实例代码
01-20
C语言 表、栈和队列详解 表ADT  形如A1,A2,A3…An的表，这个表的大小为n，而大小为0的表称为空表，非空表中，Ai+1后继Ai，Ai-1前驱Ai，表ADT的相关操有PrintList打印表中的元素；CreateEmpty创建一个空表；Find...
C语言栈和队列代码实现
08-08
包含内容：栈、队列、循环队列的数组实现方式和链表实现方式
C语言用栈和队列实现的回文检测功能示例
08-30
主要介绍了C语言用栈和队列实现的回文检测功能,结合具体实例形式分析了C语言栈和队列的定义及使用栈和队列进行回文检测的操作技巧,需要的朋友可以参考下
C语言：指针（1）
最新发布
2301_80416749的博客
05-08 1129
在指针类型中有⼀种特殊的类型是 void* 类型的，可以理解为⽆具体类型的指针（或者叫泛型指 针），这种类型的指针可以⽤来接受任意类型地址。如果函数内部要修改主调函数中的变量的值，就需要传址调⽤。如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL. NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址.const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指 向的内容，可以通过指针改变。
从C向C++17——常见算法
墨城烟柳ベ旧人殇的博客
05-06 743
C++STL常见算法
C语言：__attribute__((packed))
qq_26226375的博客
05-08 318
在使用结构体的时候，经常要。但是按照C语言的规则，会对不同类型的数据类型进行。有时候就会造成一些问题，如果不需要使用自动对齐的功能，就需要使用到本章的关键字。
有用的C 预定义的宏：__DATE__,__TIME__,__FILE__,__LINE__
qq_34503002的博客
05-07 312
有用的C 预定义的宏：__DATE__,__TIME__,__FILE__,__LINE__
指针的奥秘（一）：指针概念+指针类型+指针运算+野指针
2203_76003626的博客
05-05 1273
一谈到指针，大家的印象都是非常的难，但是指针对于C语言的学习是至关重要的，有了指针的基础，对于以后学习数据结构有很大的帮助，这是一个承上启下的过程，但是如果指针没有学好的话，学习数据结构是相当吃力地，即便是最简单的顺序表，链表。对于指针的学习，首先是不能畏惧指针，你若害怕一件事，那么迎接你的大概是你最不希望看到的，生活也是如此。所以要有一种迎难而上的精神，要对自己充满信心，抱着一定能学好指针的态度，即便过程艰辛但结局完美，也不辜此行。那么从现在开始，行动起来吧，自信的你才是最完美的自己！
在c语言中,队列和栈有什么区别？
06-01
在 C 语言中，队列和栈是两种不同的数据结构，主要的区别在于它们的数据存储和访问方式。 1. 队列（Queue） 队列是一种先进先出（First-In-First-Out, FIFO）的数据结构，类似于排队等候服务的过程。在队列中，新的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

No more cages

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值