【数据结构】栈和队列选择题和面试编程题

news2025/1/13 10:35:11

目录

一、选择题

二、栈和队列的面试题

  1、括号匹配问题

     1.1 题目说明

     1.2 题目解析

  2、用队列实现栈

     2.1 题目说明

     2.2 题目解析

  3、用栈实现队列

     3.1 题目说明

     3.2 题目解析

一、选择题

1、若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是( C )

A: 1,4,3,2     B: 2,3,4,1      C: 3,1,4,2     D: 3,4,2,1

解析：A：先进1，然后出1，连续进2，3，4，然后出栈就是4,3,2.

           B：先进1,2，然后出2，再进3，然后出3，再进4，然后出4，最后再出1.

           C：先进1,2,3，然后出3，下一个出栈的要么是2，要么是4先进栈，然后4再出栈。

           D：先进1,2,3，然后出3，再进4，然后出4，接着再出2，再出1。

2、一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出 栈的顺序是( B )

A: 12345ABCDE      B: EDCBA54321       C: ABCDE12345       D: 54321EDCBA

3、现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N。其队内有效长度为？(假设 队头不存放数据)    ( B )

A：(rear - front + N) % N + 1           B：(rear - front + N) % N

C：(rear - front) % (N + 1)               D：(rear - front + N) % (N - 1)

二、栈和队列的面试题

  1、括号匹配问题

     1.1 题目说明

      题目链接：括号匹配问题

      给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

      有效字符串需满足：

1、左括号必须用相同类型的右括号闭合。
2、左括号必须以正确的顺序闭合。
3、每个右括号都有一个对应的相同类型的左括号。

 

     1.2 题目解析

   思路：先让左括号入栈，当取到右括号时，就用这个右括号和进栈的左括号进行匹配，若能够成功匹配就接着往下，否则就返回false，当全部取完的时候都没有返回false时就返回true. 最后还要考虑栈不为空的情况：(1)如果都是左括号,形如“（（ ”,根本不出栈 ;(2)假如直接是空的字符串或者只有右括号。

typedef char STDataType;
typedef struct Stack
{
	STDataType* a;//数组
	int capacity;
	int top;   //初始为0，表示栈顶位置下一个位置的下标
}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;
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	ps->top = 0;
	ps->capacity = 4;
}
//销毁
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

//入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//扩容
	if (ps->capacity == ps->top)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}

	ps->a[ps->top] = x;
	ps->top++;
}
//出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	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)
{
	assert(ps);
	return ps->top == 0;
}

bool isValid(char * s){
    ST st;
    StackInit(&st);
    while(*s)
    {
        if(*s == '[' || *s == '{' || *s == '(')
        {
            StackPush(&st,*s);
            s++;
        }
        else
        {
            if(StackEmpty(&st))
            {
                StackDestory(&st);
                return false;
            }
            char top = StackTop(&st);
            StackPop(&st);
            //不匹配
            if((*s == ']' && top != '[')
               || (*s == '}' && top != '{')
               || (*s == ')' && top != '('))
               {
                    StackDestory(&st);
                    return false;
               }
             else//继续
             {
                s++;
             }
        }
    }
    bool ret = StackEmpty(&st);//栈为空，为真(true)
    StackDestory(&st);
    return ret;
}

  2、用队列实现栈

     2.1 题目说明

      题目链接：用队列实现栈

      请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

      实现MyStack类：

  • void push(int x)  将元素 x 压入栈顶。
  • int pop()  移除并返回栈顶元素。
  • int top()  返回栈顶元素。
  • boolean empty()  如果栈是空的，返回 true ；否则，返回 false 。

     2.2 题目解析

用队列实现栈，队列的功能是先进先出，而栈功能是先进后出。 

思路：所以就要创建两个队列，让其中一个队列为空队列，然后另一个队列插入数据。删除数据时，有数据的队列开始出队列，直接进入另一个空队列中，直到先前有数据的队列出到size=1时，然后再删除数据。如果还要再入数据，就入到有数据的队列，保证另一个队列为空。

因此，我们需要自己先创建一个队列，然后再用队列实现栈。 

typedef int	QDataType;
// 链式结构：表示队列
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;
// 队列的结构
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	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);

// 获取队列中有效元素个数
int QueueSize(Queue* pq);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* pq);

// 初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
// 销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;
		free(del);
		//del = NULL;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

// 队尾入队列
void QueuePush(Queue* 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(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->head->next == NULL)//只有一个结点
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;
		free(del);
	}
	pq->size--;
}

// 获取队列头部元素
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)
{
	int size = 0;
	return pq->size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL && pq->tail == NULL;
}



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

//需要自己创建结构体，并进行初始化
MyStack* myStackCreate() {
    MyStack*obj = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

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;
    }
    //非空队列的前n-1个数据倒入空队列
    while(QueueSize(nonemptyQ) > 1)
    {
        QueuePush(emptyQ,QueueFront(nonemptyQ));
        QueuePop(nonemptyQ);
    }
    int top = QueueFront(nonemptyQ);
    QueuePop(nonemptyQ);
    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);
}

  3、用栈实现队列

     3.1 题目说明

      题目链接：用栈实现队列

      请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

      实现MyStack类：

  • void push(int x)  将元素 x 压入栈顶。
  • int pop()  移除并返回栈顶元素。
  • int top()  返回栈顶元素。
  • boolean empty()  如果栈是空的，返回 true ；否则，返回 false 。

     3.2 题目解析

思路：用两个栈实现队列，一个pushst栈，一个popst栈。只要插入数据，我们就将数据放到pushst栈中，想要删除数据，就可以直接删除popst栈中的数据，如果popst栈为空，就将pushst栈的全部数据放到popst栈中，直到popst栈为空时，再将pushst栈中的数据倒入到popst栈中。

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;//数组
	int capacity;
	int top;   //初始为0，表示栈顶位置下一个位置的下标
}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;
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	ps->top = 0;
	ps->capacity = 4;
}
//销毁
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

//入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//扩容
	if (ps->capacity == ps->top)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}

	ps->a[ps->top] = x;
	ps->top++;
}
//出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	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)
{
	assert(ps);
	return ps->top == 0;
}

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

bool myQueueEmpty(MyQueue* obj);
int myQueuePeek(MyQueue* obj);

//需要自己创建结构体，并进行初始化
MyQueue* myQueueCreate() {
    MyQueue* pq = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&pq->pushst);
    StackInit(&pq->popst);
    return pq;
}

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

int myQueuePop(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(obj));

    int peek = myQueuePeek(obj);
    StackPop(&obj->popst);
    return peek;
}

//对头
int myQueuePeek(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(obj));

    //pushst中的数据倒入popst中
    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) {
    assert(obj);
    return StackEmpty(&obj->pushst) &&  StackEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    StackDestory(&obj->pushst);
    StackDestory(&obj->popst);
    free(obj);
}

本文要是有不足的地方，欢迎大家在下面评论，我会在第一时间更正。

老铁们，记着点赞加关注!!! 

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/604653.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

软考A计划-电子商务设计师-信息安全知识

软考A计划-电子商务设计师-信息安全知识

点击跳转专栏>Unity3D特效百例点击跳转专栏>案例项目实战源码点击跳转专栏>游戏脚本-辅助自动化点击跳转专栏>Android控件全解手册点击跳转专栏>Scratch编程案例 👉关于作者 专注于Android/Unity和各种游戏开发技巧，以及各种资源分享&am…
阅读更多...
安全防御——IDS（入侵检测系统）

安全防御——IDS（入侵检测系统）

安全防御——IDS（入侵检测系统） IDS介绍为什么需要IDSIDS的工作原理IDS的工作过程第一步：信息收集第二步：数据分析 IDS的主要检测方法1、模式匹配（误用检测）2、统计分析（异常检测）3、…
阅读更多...
chatgpt赋能python：Python创建venv的完全指南

chatgpt赋能python：Python创建venv的完全指南

Python创建venv的完全指南 在Python开发中，虚拟环境是一个非常有用的工具。它可以让我们在同一台计算机上拥有多个Python环境，而不会互相干扰。在本文中，我们将介绍如何使用Python创建venv（虚拟环境）。 什么是venv&a…
阅读更多...
4-5.配置信息和路由信息

4-5.配置信息和路由信息

一、配置信息 app.run()的参数 参数1：host，如果我们不指定，默认值是127.0.0.1。参数2：port，如果我们不指定，默认值是5000。参数3：debug，调试模式，如果不指定&#xff0…
阅读更多...
chatgpt赋能python：Python创建画布语句

chatgpt赋能python：Python创建画布语句

Python 创建画布语句 在数据可视化的领域，画布（Canvas）是一个重要的概念。画布可以视为一个空白的像素或向量画布，用于绘制图表、图形、图像和动画等。Python 提供了多种创建画布的方式，其中包括使用第三方库和内置库…
阅读更多...
哲学家就餐问题（死锁）

哲学家就餐问题（死锁）

本文主要讲述死锁的一个经典案例—哲学家就餐问题，并对该问题进行修复。 1. 问题描述 看上图，有五位哲学家，每天循环做两件事：思考，吃面。吃面时每人面前都有一个盘子，盘子左边和右边都有一根筷子&#xff…
阅读更多...
5.3 树和二叉树的抽象数据类型定义

5.3 树和二叉树的抽象数据类型定义

博主简介：一个爱打游戏的计算机专业学生博主主页： 夏驰和徐策所属专栏：算法设计与分析 1.什么是树的抽象数据类型定义 树的抽象数据类型定义是指对树这种数据结构的一种抽象描述，其中包括了树的基本操作和性质。它定义了树作为一…
阅读更多...
基于深度学习的目标姿态检测方法_kaic

基于深度学习的目标姿态检测方法_kaic

目录 摘要 第1章 引言 1.1 研究背景和意义 1.2 国内外研究现状 1.3 主要内容 第2章 单目相机的目标姿态检测技术 2.1单目相机的工作原理 2.2目标姿态检测 2.3已有的目标姿态检测方法及其局限性 2.4本章总结 第3章 构建数据集 3.1 数据集来源 3.2数据集标注 3.3数据集分析 3.4本…
阅读更多...
基于Springboot的社区论坛系统(源代码+数据库)055

基于Springboot的社区论坛系统(源代码+数据库)055

部分代码地址 https://gitee.com/ynwynwyn/forum-public 基于Springboot的社区论坛系统(源代码数据库) 一、系统介绍 前台： 话题列表，搜索话题，发布话题通过标签筛选话题个人设置：修改个人信息，查看发布话题记录&a…
阅读更多...
FPGA设计的指导性原则 （三）

FPGA设计的指导性原则 （三）

例12. 在SDC文件中附加syn_ramstyle综合约束属性，指定综合存贮单元的类型 SDC文件是Synplicity综合工具通用的综合约束属性文件，其扩展名为”sde”。在SDC 指定 syn_ramstyle的语法格式为： define_attribute (signal_name [bit_range)) syn_ramstyle (atring) 其中，黑体…
阅读更多...
1.Python高频函数—数据合并merge()

1.Python高频函数—数据合并merge()

前言 数据处理中经常对多个表的数据进行合并处理，python 提供两个十分好用的函数处理。merge() 、 concat() merger函数是Python里的数据分析工作中最常见的函数之一，主要应用场景是：针对同一个主键存在两张不同字段的表。（这里强…
阅读更多...
《Kali渗透基础》05. 主动信息收集（二）

《Kali渗透基础》05. 主动信息收集（二）

kali渗透 1：端口扫描2：UDP 扫描2.1：Scapy2.2：nmap 3：半开放扫描3.1：Scapy3.2：nmap3.3：hping3 4：全连接扫描4.1：Scapy4.2：nmap4.3：dmit…
阅读更多...
前端web入门-CSS-day04

前端web入门-CSS-day04

(创作不易，感谢有你，你的支持，就是我前行的最大动力，如果看完对你有帮助，请留下您的足迹） 目录 复合选择器 后代选择器 子代选择器 并集选择器 交集选择器 伪类选择器 伪类-超链接（拓…
阅读更多...
leetcode95--不同的二叉搜索树 II(java)

leetcode95--不同的二叉搜索树 II(java)

不同的二叉搜索树 II leetcode95 -- 不同的二叉搜索树 II题目描述 解题思路代码演示二叉树专题 leetcode95 – 不同的二叉搜索树 II 原题链接: https://leetcode.cn/problems/unique-binary-search-trees-ii/ 题目描述 给你一个整数 n ，请你生成并返回所有由 n 个节…
阅读更多...
HTTP协议+Ajax基本知识+axios+模板引擎的基本使用

HTTP协议+Ajax基本知识+axios+模板引擎的基本使用

1.客服端服务器 我们先来了解一下上网的目的是什么？ 例如：刷微博、浏览新闻、在线听音乐、在线看电影、等等... 上网的本质目的：通过互联网的形式来 获取和消费资源 1.2 服务器 上网过程中，负责 存放和对外提供资源 的电脑&am…
阅读更多...
dockers映射网络及数据卷

dockers映射网络及数据卷

DOCKER docker run创建镜像时 1）检查本地是狗存在指定的惊像 2）利用镜像创建并启动一个容器 3）分配一个文件系统给容器，在只读的镜像曾外改在一层可读可写层 4）从宿主机配置的网桥接口中桥接一个虚拟机接口到容器…
阅读更多...
springboot+vue实验室器材预约学习系统设计与实现

springboot+vue实验室器材预约学习系统设计与实现

1、理论学习 深入学习Java Web开发技术。 在此基础上研究核心框架SpringBoot, MyBatis和Bootstrap等，为设计开发基于J2EE_SpringBoot的中药实验管理系统做好技术准备。 2.1功能要求 课题以提高中药实验开放共享、实施实验室网络化管理、提供优质的实验教学信息化服…
阅读更多...
几何分布和负二项分布的关系

几何分布和负二项分布的关系

几何分布和负二项分布的关系 几何分布 在独立重复Bernoulli试验中，事件A首次发生时所进行的试验次数X服从几何分布 P ( X k ) ( 1 − p ) k − 1 p （ k 1 , 2 ⋯ ） E ( X ) 1 p 、 D ( X ) 1 − p p 2 P(Xk)(1-p)^{k-1}p（k…
阅读更多...
sql server 字符串链接，及表连接多个值显示连接显示为一列 STUFF for xml path

sql server 字符串链接，及表连接多个值显示连接显示为一列 STUFF for xml path

sql server 字符串链接，及表连接多个值显示连接显示为一列 STUFF for xml path STUFF ( character_expression , start , length , replaceWith_expression ) 以下示例从第一个字符串 abcdef 的第 2 个位置 (b) 开始删除三个字符，然后在删除位置插入…
阅读更多...
第10章_管理库表(DDL语句)

第10章_管理库表(DDL语句)

第10章_管理库表(DDL语句) 1. 基础知识 1.1 一条数据存储的过程 存储数据是处理数据的第一步 。只有正确地把数据存储起来，我们才能进行有效的处理和分析。否则，只能是一团乱麻，无从下手。那么，怎样才能把用户各种经营相关的、…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023