爱上数据结构：栈和队列的OJ及选择题

于 2024-04-01 17:51:20 发布
阅读量934 收藏 24
点赞数 44
分类专栏： 数据结构C语言版 c语言 文章标签： 数据结构 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bskmns/article/details/137204509
版权

​

​
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

🔥个人主页：guoguoqiang. 🔥专栏：数据结构

Alt

​

一、 栈和队列的OJ题

1.括号匹配问题

括号匹配问题
在这里插入图片描述

typedef char STDataType;
typedef struct Stack {
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
STDataType STTop(ST* ps);
int STSize(ST* ps);
bool STEmpty(ST* ps);
void STInit(ST* ps) {
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 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");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
void STPop(ST* ps) {
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}
STDataType STTop(ST* ps) {
	assert(ps);
	assert(!STEmpty(ps));
	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;
}
bool isValid(char* s) {
    ST st;
    STInit(&st);
    while(*s){
        if(*s=='['||*s=='('||*s=='{'){
            STPush(&st,*s);
        }
        else{
            if(STEmpty(&st)){
                STDestroy(&st);
                return false;
            }
            char top =STTop(&st);
            STPop(&st);
            if((*s==']'&&top!='[')
            ||(*s=='}'&&top!='{')
            ||(*s==')'&&top!='('))
            {
                STDestroy(&st);
                return false;
            }
        }
        s++;
    }
    bool ret=STEmpty(&st);
    STDestroy(&st);
    return ret;
}

2.用队列实现栈

在这里插入图片描述
队列是先进先出，用两个队列实现栈，一个队列专门用来入数据，一个队列专门用来出数据，如果第二个队列为空之后再从第一个队列往第二个队列入数据。

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

typedef int QDataType;
typedef struct QueueNode
{
	int val;
	struct QueueNode* next;
}QNode;
typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);

// 入队列
void QueuePush(Queue* pq, QDataType x);
// 出队列
void QueuePop(Queue* pq);

QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);

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

	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

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

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

		cur = next;
	}

	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

// 入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

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

	if (pq->ptail)
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	else
	{
		pq->phead = pq->ptail = newnode;
	}

	pq->size++;
}

// 出队列
void QueuePop(Queue* pq)
{
	assert(pq);

	// 0个节点
	// 温柔检查
	//if (pq->phead == NULL)
	//	return;

	// 暴力检查 
	assert(pq->phead != NULL);

	// 一个节点
	// 多个节点
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}

	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);

	// 暴力检查 
	assert(pq->phead != NULL);

	return pq->phead->val;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);

	// 暴力检查 
	assert(pq->ptail != NULL);

	return pq->ptail->val;
}

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

	return pq->size == 0;
}

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

	return pq->size;
}
typedef struct {
    Queue q1;
    Queue 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) {
    Queue*pEmptyQ=&obj->q1;
    Queue*pNonEmptyQ=&obj->q2;
    if(!QueueEmpty(&obj->q1)){
        pEmptyQ=&obj->q2;
        pNonEmptyQ=&obj->q1;
    }
    while(QueueSize(pNonEmptyQ)>1){
        int front =QueueFront(pNonEmptyQ);
        QueuePush(pEmptyQ,front);
        QueuePop(pNonEmptyQ);
    }
        int front =QueueFront(pNonEmptyQ);
        QueuePop(pNonEmptyQ);
        return front;
}

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

3.用栈实现队列

在这里插入图片描述

typedef int DataType;


typedef struct Stack {
	DataType* arr;
	int top;
	int capacity;
}Stack;


void StackInit(Stack* st) {//初始化
	assert(st);
	st->arr = NULL;
	st->capacity = 0;
	st->top = -1;
}

void CheckCapacity(Stack* st) {
	assert(st);
	if (st->top +1 == st->capacity) {
		//扩容
		int newcap = st->capacity == 0 ? 4 : 2 * st->capacity;
		DataType* tmp = (DataType*)realloc(st->arr, newcap * sizeof(DataType));  //注意点。开辟的空间大小为字节数
		if (NULL == tmp) {
			perror("realloc fail\n");
			exit(-1);
		}
		st->arr = tmp;
		st->capacity = newcap;
	}
}

bool Empty(Stack* st) { //栈是否为空
	assert(st);
	return st->top == -1;
}

void StackPush(Stack* st, DataType x) {//入栈
	assert(st);
	CheckCapacity(st);
	st->arr[++st->top] = x;
}

void StackPop(Stack* st) { //出栈
	assert(st);
	if (Empty(st)) {
		return;
	}
	st->top--;
}

DataType StackTop(Stack* st) { //获取栈顶元素
	assert(st);
	if (Empty(st)) {
		return -1; //栈为空理应报错
	}
	return st->arr[st->top];
}

void StackDestory(Stack* st) {
	assert(st);
	if (st->arr) {
		free(st->arr);
	}
	st->capacity = 0;
	st->top = -1;
}

void StackPrint(Stack* st) {
	assert(st);
	if (Empty(st)) {
		printf("STACK IS EMPTY\n");
		return;
	}

	for (int i = 0;i <= st->top;++i) {
		printf("%d ", st->arr[i]);
	}
	printf("\n");
}


void StackInit(Stack* st);//初始化

void CheckCapacity(Stack* st); //检测是否需要扩容

void StackPush(Stack* st, DataType x); //入栈

void StackPop(Stack* st); //出栈

DataType StackTop(Stack* st); //获取栈顶元素

void StackDestory(Stack* st); //销毁栈

bool Empty(Stack* st); //栈是否为空

void StackPrint(Stack* st); //打印栈内数据




typedef struct {
    Stack _inqueue;
    Stack _outqueue;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* mq = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&mq->_inqueue);
    StackInit(&mq->_outqueue);
    return mq;
}

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

int myQueuePop(MyQueue* obj) {
    if(Empty(&obj->_outqueue)){
        while(!Empty(&obj->_inqueue)){
        DataType x = StackTop(&obj->_inqueue);
        StackPop(&obj->_inqueue);
        StackPush(&obj->_outqueue,x);
        }
    }
    DataType out = StackTop(&obj->_outqueue);
    StackPop(&obj->_outqueue);
    return out;
}

int myQueuePeek(MyQueue* obj) {
        if(Empty(&obj->_outqueue)){
        while(!Empty(&obj->_inqueue)){
        DataType x = StackTop(&obj->_inqueue);
        StackPop(&obj->_inqueue);
        StackPush(&obj->_outqueue,x);
        }
    }
    DataType out = StackTop(&obj->_outqueue);
    return out;
}

bool myQueueEmpty(MyQueue* obj) {
    return Empty(&obj->_inqueue) && Empty(&obj->_outqueue);
}

void myQueueFree(MyQueue* obj) {
    StackDestory(&obj->_inqueue);
    StackDestory(&obj->_outqueue);
}

​

二、选择题

1.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出
栈的顺序是（ ）。
A 12345ABCDE
B EDCBA54321
C ABCDE12345
D 54321EDCBA

栈是后进先出所以选B

2.若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A 1,4,3,2
B 2,3,4,1
C 3,1,4,2
D 3,4,2,1

栈可以入一个出一个，但是不能切换顺序 C

3.循环队列的存储空间为 Q(1:100) ，初始状态为 front=rear=100 。经过一系列正常的入队与退队操作
后， front=rear=99 ，则循环队列中的元素个数为（ ）
A 1
B 2
C 99
D 0或者100

D

4.以下( )不是队列的基本运算？
A 从队尾插入一个新元素
B 从队列中删除第i个元素
C 判断一个队列是否为空
D 读取队头元素的值

B

5.现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N。其队内有效长度为？(假设队头不存放数据)
A (rear - front + N) % N + 1
B (rear - front + N) % N
C （rear - front) % (N + 1)
D (rear - front + N) % (N - 1)

在正常不考虑超出的情况下为满是rear-front，但是要考虑是否rear在前，而front在后，所以最后的答案为(rear-front+N)%N,%N就可以防止超出范围。

guoguoqiang.
关注
专栏目录
【数据结构】队列详解 && 栈和队列OJ题 —— 用队列实现栈、用栈实现队列、设计循环队列
StackFrame
11-16 1140
队列的概念和结构讲解、C语言实现队列、OJ题 —— 用队列实现栈、用栈实现队列、设计循环队列
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2289
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
栈相关习题及详解(选择题和综合题) ——数据结构
Amour
10-26 9954
栈的基本概念栈的定义栈：只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但是限定这种线性表只能在某一端进行插入和删除操作。栈顶：线性表允许进行插入和删除的那一端 栈底：固定的，不允许进行插入和删除的另一端 空栈：不含任何元素的空表。进栈出栈的变化形式最先进栈的元素，是不是就只能是最后出栈呢答案是不一定，要看什么情况。栈对线性表的插入和删除的位置进行了限制，并没有对元素进出的时间进行限
栈练习
qq_52051345的博客
08-10 228
问题 A: 简单计算器 算法分析： 对于这个题，大体思想是这样的：把所有乘除先算出来，再算加减（废话）。 ①首先我们把字符串中的空格去掉，不过这里在输入时候记得一定要用getline ②然后用两个栈分别存储数据和运算符，在此之前还要写一个precede函数来判断运算符的优先级，由于栈是先进后出，所以栈顶元素的运算符优先级更高。 ③在存储运算符的时候，是否压入栈是根据运算符优先级（precede返...
数据结构关于栈的选择题
smile的博客
11-08 3270
一个栈的入栈序列为A B C D E 则不可能的输出序列为（C） 1.  EDCBA 2.  DECBA  3.  DCEAB  4.  ABCDE A   正确。选项中第一个出栈的是E,所以最后一个入栈的必须为E. 此时，栈元素为:(stack-head) E D C B A。 所以，出栈顺序必然为 E D C B A. B.  正确。      同理，首先必须将 A
【数据结构】栈和队列选择题和面试编程题
m0_63198468的博客
06-03 1129
本文重点讲述了数据结构里面的练习题和一些常见的面试题，给出了详细的解析思路，还附有动图，希望可以帮助大家。
【数据结构】栈与队列经典选择题
睿的博客
04-08 1345
快来看看你的栈与队列学的如何吧！
西南科技大学SWUST OJ 数据结构 图相关题题解 图.zip
01-01
SWUST OJ ： 1055、1056、1057、1058、1059、1060、1061、1062、1063、1064、1065、1066、1067、1068、1069、1070、1071、1072、1075、1086题答案
swust西南科技大学OJ数据结构80题答案
10-14
在线评测系统（Online Judge，简称OJ）是检验编程能力，特别是算法和数据结构应用能力的常见平台。西南科技大学的OJ提供了80道数据结构相关的题目，旨在帮助学生深入理解和掌握各种数据结构及其应用。 在这个压缩包...
数据结构C语言篇《三》栈和队列概念，模拟函数实现，以及相关OJ面试题
愿你有青春亦可奔赴
05-22 1182
#pragma once typedef int DataType; typedef struct Stcak { DataType *arr; int capacity; //容量大小 int size; //有效元素个数---栈顶 }Stack; //栈的初始化 void StackInit(Stack *ps); //入栈 void StackPush(Stack *ps, DataType data); //出栈 void StackPop(Stack *ps); //获取栈顶元
【数据结构练习】栈的面试题集锦
最新发布
WHabc2002的博客
09-05 1199
数据结构想要学的好，刷题少不了，我们不仅要多刷题，还要刷好题！为此我开启了一个必做好题锦集的系列，此为第一篇选择题篇，该系列会不定期更新敬请期待！栈（Stack）的详解_WHabcwu的博客-CSDN博客。
算法与数据结构 第三章 栈与队列（详解）
m0_62205773的博客
05-06 2574
目录 一、判断题 二、选择题 一、判断题 1、所谓“循环队列”是指用单向循环链表或者循环数组表示的队列。F 解析：错误，循环队列指的是后者，用数组表示的队列，利用求余数运算使得头尾相接。循环队列本身是一种顺序存储结构，而循环链表是一种链式存储结构。 2、An algorithm to check for balancing symbols in an expression uses a stack to store the symbols.T 解析：balancing symbols指的是一.
数据结构——栈、队列、数组、串の选择题整理
王王仙贝的博客
07-18 3646
1、设链表不带头结点且所有操作均在表头进行，则下列最不适合作为链栈的是（）A、只有表头结点指针，没有表尾指针的双向循环链表B、只有表尾结点指针，没有表头指针的双向循环链表C、只有表头结点指针，没有表尾指针的单向循环链表D、只有表尾结点指针，没有表头指针的单向循环链表对于双向循环链表，找头结点和尾结点都很方便对于单向循环链表，已知头结点，找尾结点需要遍历整个链表，已知尾结点找头结点很方便。栈的存取时间复杂度都是O(1)，因此不存在减少存取时间的问题。注意！！！......
数据结构---第三章栈和队列---栈和队列的应用---选择题
programmer9的博客
05-22 548
数据结构---第三章栈和队列---栈和队列的应用---选择题
数据结构---第三章栈和队列---栈---选择题
programmer9的博客
05-16 2248
数据结构---第三章栈和队列---栈---选择题
栈的讲解和练习题
令狐静慧
07-22 2947
目录 1.栈的讲解 2.回文数 3.进制转换 4.递归 5.佩兹糖果盒 6.括号是否匹配 1.栈的讲解 1.1 栈的入门        栈就是和列表类似的一种数据结构，只能在栈顶添加或删除，后入先出，入栈使用push() 方法，pop()方法虽然可以访问栈顶的元素，但是调用该方法后，栈顶元素也从栈中被永久性地删除了。peek()方法则只返回栈顶元素，而不删除它。clear(...
笔试选择题——出栈&入栈问题
空夜's Blog
09-22 3980
昨天笔试，遇到一道有关出栈入栈顺序问题的选择题，当时晕晕乎乎好像做错了，时间太长没遇到这题已经忘记是啥意思了。   苦逼。   现在回头来复习一下。   下面是一道实例： 一个栈的入栈序列为ABCDE，则不可能的出栈序列为?（不定项选择题） A： ECDBA B： DCEAB C： DECBA D： ABCDE E： EDCBA正确答案是：AB 解
栈的一些习题
热门推荐
qq_34241112的博客
04-19 2万+
1.栈和队列具有相同的（    ）。 A.抽象数据类型     B.逻辑结构     C.存储结构     D.运算 2.栈是（）。 A.顺序存储的线性结构     B.链式存储的非线性结构 C.限制存取点的线性结构     D.限制存储点的非线性结构 3.（）不是栈的基本操作。 A.删除栈顶元素     B.删除栈底元素 C.判断栈是否为空     D.将栈置为空栈
C语言实现数据结构：栈的理解与应用
文章通过这样的讲解，不仅覆盖了栈的基本概念，还深入到栈的实现细节，对于学习C语言和数据结构的初学者来说，是一份非常有价值的参考资料。同时，结合实际的OJ题目的解析，可以帮助读者将理论知识应用到实践中，...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值