数据结构--栈和队列练习题

最新推荐文章于 2023-06-03 10:40:42 发布
最新推荐文章于 2023-06-03 10:40:42 发布
阅读量132 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32780809/article/details/129250105
版权

目录

一、有效的括号

在这里插入图片描述

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

typedef char STDataType;

typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;

//初始化
void StackInit(ST* ps);
//销毁
void StackDestory(ST* ps);
//进栈
void StackPush(ST* ps,STDataType x);
//出栈
void StackPop(ST* ps);
//取栈顶的数据
STDataType StackTop(ST* ps);
//栈里面的数据
int StackSize(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);


//初始化
void StackInit(ST* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}
//销毁
void StackDestory(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}
//进栈
void StackPush(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, Newcapacity * sizeof(STDataType));
        if (tmp == NULL)
        {
            printf("realloc fail");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity = Newcapacity;
    }
    ps->a[ps->top] = x;
    (ps->top)++;
}
//出栈
void StackPop(ST* ps)
{
    assert(ps);
    assert(ps->top > 0);
    ps->top--;
}
//取栈顶的数据
STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
    return ps->a[ps->top-1];
}
//栈里面的数据个数
int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}
//判断栈是否为空
bool StackEmpty(ST* ps)
{
    //逻辑真假
    return ps->top == 0;
}


bool isValid(char * s)
{
	ST ps;
	StackInit(&ps);
	while(*s)
	{
		if(*s == '('
		|| *s == '['
		|| *s == '{')
		{
			StackPush(&ps,*s);
			++s;
		}
		else
		{
			//遇到右括号的了，但是栈里面没有数据
			//说明前面没有左括号，不匹配，返回false
			if(StackEmpty(&ps))
			{
				//[[]]]
				//内存泄漏，要释放内存
				StackDestory(ps);
				return false;
			}
			else
			{
				STDataType top = StackTop(&ps);
				StackPop(&ps);
				if((*s == '}' && top != '{')
				|| (*s == ']' && top != '[')
				|| (*s == ')' && top != '('))
				{
					StackDestory(&ps);
					return false;
				}
				else
				{
					++s;
				}
			}
		}
	}
	bool ret = StackEmpty(&ps);
	StackDestory(&ps);
	return ret;
}

二、用队列实现栈

在这里插入图片描述

typedef int QDataType;

typedef struct QueueNode
{
    struct QueueNode* next;
    QDataType data;
}QueueNode;

typedef struct Queue
{
    QueueNode* head;
    QueueNode* tail;
}Queue;

//初始化
void QueueInit(Queue* pq);
//销毁队列，释放内存
void QueueDestory(Queue* pq);
//插入
void QueuePush(Queue* pq, QDataType x);
//删除
void QueuePop(Queue* pq);
//取队头的数据
QDataType QueueFront(Queue* pq);
//取队尾的数据
QDataType QueueBack(Queue* pq);
//查询数据个数
int QueueSize(Queue* pq);
//判断是否为空
bool QueueEmpty(Queue* pq);
//打印
void QueuePrint(Queue* pq);


//初始化
void QueueInit(Queue* pq)
{
    pq->head = NULL;
    pq->tail = NULL;

}
//销毁队列，释放内存
void QueueDestory(Queue* pq)
{
    assert(pq);
    QueueNode* cur = pq->head;
    while (cur != NULL)
    {
        QueueNode* next = cur->next;
        free(cur);
        cur = next;
    }
    pq->head = pq->tail = NULL;
}
//插入
void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);
    QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
    newnode->data = x;
    newnode->next = NULL;
    if (pq->head == NULL)
    {
        pq->head = pq->tail = newnode;
    }
    else
    {
        pq->tail->next = newnode;
        pq->tail = newnode;
    }
}
//删除
void QueuePop(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    QueueNode* next = pq->head->next;
    free(pq->head);
    pq->head = next;
    if (pq->head == NULL)
    {
        pq->tail = NULL;
    }
}
//取队头的数据
QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->head->data;
}
//取队尾的数据
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));
    return pq->tail->data;
}
//查询数据的个数
int QueueSize(Queue* pq)
{
    assert(pq);
    int n = 0;
    QueueNode* cur = pq->head;
    while (cur)
    {
        ++n;
        cur = cur->next;
    }
    return n;
}
//判断是否为空
bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->head == NULL;
}
//打印
void QueuePrint(Queue* pq)
{
    QueueNode* cur = pq->head;
    while (cur)
    {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
}



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

MyStack* myStackCreate()
{
	MyStack* st = (MyStack*)malloc(sizeof(MyStack));
	QueueInit(MyStack->q1);
	QueueInit(Mystack->q2);
	return st;
}

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

int myStackPop(MyStack* obj)
{
	Queue* emptyQ = &obj->q1;
	Queue* nonemptyQ = &obj->q2;
	if(!QueueEmpty(&obj->q1))
	{
		emptyQ = &obj->q2;
		nonemptyQ = &obj->q1;
	}
	while(QueueSize(nonemptyQ)>1)
	{
		QueuePush(emptyQ,QueueFront(nonemptyQ));
		QueuePop(nonempty);
	}
	int top = QueueFront(nonemptyQ);
	QueuePop(nonemptyQ);
	return top;
}

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

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

void myStackFree(MyStack* obj)
{
	QueueDestory(&obj->q1);
	QueueDestory(&obj->q2);
	free(obj);
}

三、用栈实现队列

在这里插入图片描述

typedef char STDataType;

typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;

//初始化
void StackInit(ST* ps);
//销毁
void StackDestory(ST* ps);
//进栈
void StackPush(ST* ps,STDataType x);
//出栈
void StackPop(ST* ps);
//取栈顶的数据
STDataType StackTop(ST* ps);
//栈里面的数据
int StackSize(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);

//初始化
void StackInit(ST* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}
//销毁
void StackDestory(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}
//进栈
void StackPush(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, Newcapacity * sizeof(STDataType));
        if (tmp == NULL)
        {
            printf("realloc fail");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity = Newcapacity;
    }
    ps->a[ps->top] = x;
    (ps->top)++;
}
//出栈
void StackPop(ST* ps)
{
    assert(ps);
    assert(ps->top > 0);
    ps->top--;
}
//取栈顶的数据
STDataType StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));
    return ps->a[ps->top-1];
}
//栈里面的数据个数
int StackSize(ST* ps)
{
    assert(ps);
    return ps->top;
}
//判断栈是否为空
bool StackEmpty(ST* ps)
{
    //逻辑真假
    return ps->top == 0;
}

typedef struct 
{
	ST pushST;
	ST popST;
}MyQueue;

MyQueue* myQueueCreate()
{
	//创建一个动态内存存储数据
	MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
	//初始化
	StackInit(&q->pushST);
	StackInit(&q->popST);
	return q;
}

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

int myQueuePop(MyQueue* obj)
{
	//如果popST中没有数据，将pushST的数据导进去
	//popST中的数据先进先出的顺序
	if(StackEmpty(&obj->popST)
	{
		while(!StackEmpty(&obj->pushST))
		{
			StackPush(*obj->popST,StackTop(&obj->pushST));
			StackPop(&obj->pushST);
		}
	}
	//取popST的栈上的数据
	int front = StackTop(&obj->popST);
	StackPop(&obj->popST);
	return front;
}

int myQueuePeek(MyQueue* obj)
{
	if(StackEmpty(&obj->popST))
	{
		while(!StackEmpty(&obj->pushST))
		{
			StackPush(&obj->popST,StackTop(&obj->pushST);
			StackPop(&obj->pushST);
		}
	}
	return StackTop(&obj->popST);
}

bool myQueueEmpty(MyQueue* obj)
{
	return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj)
{
	StackDestory(&obj->pushST);
	StackDestory(&obj->popST);
	free(obj);
}

四、环形队列

另外扩展了解一下，实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型
时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。
在这里插入图片描述

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

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k)
{
	MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	cq->a = (int*)malloc(sizeof(int)*(k+1));
	cq->front = cq->tail = 0;
	cq->k = k;
	return cq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
	//满了
	if(!myCircularQueueIsFull(obj))
	{
		return false;
	}
	obj->a[obj->tail] = value;
	++obj->tail;
	//防止出现tail在最后一个位置的情况
	obj->tail %= (obj->k+1)
	retunr true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
	if(myCircularQueueIsEmpty(obj))
		return false;
	++obj->front;
	//应对出现front在最后一个位置的情况
	obj->front %= (obj->k+1);
}

int myCircularQueueFront(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
        return -1;
    //如果下标为0
    if(obj->tail == 0)
    {
        return obj->a[obj->k];
    }
    else
        return obj->a[obj->tail-1];
}

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

void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->a);
    free(obj);
}
我想玩游戏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
栈和队列——相关例题
每天进步一点点！
11-26 1419
栈和队列例题
3.26栈和队列相关练习题
m0_61548909的博客
03-20 1050
1. 括号匹配问题 左括号入栈，右括号出栈 若用C语言，栈的操作相关函数需要在前面单独写出 bool isValid(char * s){ Stack st; StackInit(&st); while(*s) { //左括号入入栈 //右括号找最近的左括号匹配 if(*s == '['||*s == '('||*s == '{') { StackPus..
【数据结构】数据结构练习题2——栈+队列
xtcc的博客
12-18 4685
一、选择题 1.假定一个循环顺序队列的队首和队尾指针分别为f和r，则判断队空的条件是（D） A f+1==r B r+1==f C f==0 D f==r 2.假定一个链队（有头结点）的队首和队尾指针分别为front和rear，则判断队空的条件是（A） A front==rear B front!=NULL C rear!=NULL D front==NULL 3.循环队列用数组A[0，m-1]存放其元素值，已知其头尾指针分别是front和rear，则当前队列中的元素个数是 （A） A (rear-fron
＜栈和队列＞题目练习《数据结构(C语言版)》
m0_57859086的博客
06-03 2017
＜栈和队列＞题目练习《数据结构(C语言版)》 ——By 作者：新晓·故知
【数据结构】栈和队列选择题和面试编程题
m0_63198468的博客
06-03 1001
本文重点讲述了数据结构里面的练习题和一些常见的面试题，给出了详细的解析思路，还附有动图，希望可以帮助大家。
数据结构练习题-栈和队列.pdf
07-09
数据结构练习题-栈和队列.pdf数据结构练习题-栈和队列.pdf数据结构练习题-栈和队列.pdf数据结构练习题-栈和队列.pdf数据结构练习题-栈和队列.pdf数据结构练习题-栈和队列.pdf数据结构练习题-栈和队列.pdf数据结构...
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
C语言-数据结构-栈队列实现
03-10
C语言-数据结构-栈队列实现
数据结构栈和队列练习题答案.doc
04-02
数据结构
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
（C语言）数据结构之栈和队列面试题
博主qq1077644249
08-11 822
下一次想出栈的时候就再倒一次，也就是把q2的前n-1个元素出队并入队到q1，然后q2把剩下的那个元素出队即可，此时q2为空下一次再入栈的时候，也就不用管q1还是q2，就直接谁有元素就往谁的里面入队元素即可。每次入队的时候先要判断当先队列是否是满的，不为满，让back当前位置赋值要入队的元素，然后back正常++往后走，关键的来了再进行back=back %（k+1）操作即可实现循环。为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是最后入栈的元素。...
数据结构习题——栈和队列（二）
煮酒blog
06-06 3488
第3章 栈和队列 一、填空题 1. 线性表、栈和队列都是 线性 结构，可以在线性表的 任何 位置插入和删除元素；对于栈只能在 栈顶 插入和删除元素；对于队列只能在 队尾 插入和 队头 删除元素。 2. 队列 是被限定为只能在表的一端进行插入运算，在表的另一端进行删除运算的线性表。 3. 在具有n个单元的循环队列中，队满时共有 n-1 个元素。 4. 带表头结点的空循环双向链表的长度等于...
数据结构习题3---栈和队列
qq_62474991的博客
12-06 1133
学习数据结构栈和队列后的一些习题
数据结构51题之栈和队列18题
&volume的博客
05-31 1387
数据结构系统练习题，从头走到尾
（PTA）数据结构（作业）7、栈和队列应用，字符串矩阵，树
Misasagi Inori的博客
04-28 5358
作业而已，仅供参考，欢迎交流，有大佬带带我最好
数据结构--栈、队列练习题
丹丹的后花园
09-27 1959
数据结构–栈、队列作业 作业1： ​ 1.有五个元素，其入栈次序为：A，B，C，D，E，在各种可能的出栈序列中，以元素C、D最先出栈（即C第一个且D第二个出栈）的次序有哪些？ ​ 2.铁路进行列车调度时，常把站台设计成栈式结构，试问： ​ (1) 设有编号为1,2,3,4,5,6的6辆列车，顺序开入栈式结构的站台，则可能的出栈序列有多少种？ ​ (2)若进站的6辆列车顺序如上所述，那么是否能够得到435612、326541、154623和135426的出站序列？如果不能，说明为什么不能；如果能，说明如何得到
【栈和队列】【习题汇总】
qq_42825058的博客
02-11 896
zoj3210 思路：这个题很好的体现了栈和队列的特点，栈是先进后出，队列是先进先出。 #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;algorithm&gt; using namespace std; int t,n; int a[110],b[110]; bool isque,isstk; int main(...
【数据结构】判断有效的括号（栈和队列）
qq_42270373的博客
10-14 599
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 具体实现代码如下： #pragma once #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &l...
数据结构_练习 第3章 栈和队列
热门推荐
Cynical丶Gary_博客
01-08 2万+
1．选择题 （1）若让元素1，2，3，4，5依次进栈，则出栈次序不可能出现在（  ）种情况。 A．5，4，3，2，1   B．2，1，5，4，3    C．4，3，1，2，5    D．2，3，5，4，1 答案：C 解释：栈是后进先出的线性表，不难发现C选项中元素1比元素2先出栈，违背了栈的后进先出原则，所以不可能出现C选项所示的情况。 （2）若已知一个栈的入栈序列是1，2
数据结构栈和队列课后习题头歌
最新发布
10-18
根据提供的引用内容，我可以为您解答数据结构栈和队列课后习题的相关问题。 根据引用中的内容，我们可以知道栈和队列都是线性结构，栈是一种特殊的线性表，允许插入和删除运算的一端称为栈顶，不允许插入和删除运算...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值