栈和队列 面试题 概念选择题 数据结构 C语言实现

最新推荐文章于 2024-05-20 12:46:49 发布
最新推荐文章于 2024-05-20 12:46:49 发布
阅读量303 收藏
点赞数
分类专栏： C语言数据结构 文章标签： c语言 数据结构 链表 leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63666347/article/details/124803537
版权

3.栈和队列面试题

1）括号匹配问题

typedef char STDataType;
typedef struct stack
{
	STDataType* a;
	int top;
	int capacity;
}stack;
void StackInit(stack* ps)//初始化
{
	assert(ps != NULL);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackDestroy(stack* ps)//销毁
{
	assert(ps != NULL);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity=0;
}
void StackPush(stack* ps, STDataType x)//入栈
{
	assert(ps != NULL);
	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)
		{
			exit(1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
bool StackEmpty(stack* ps)//判断栈是否为空
{
	assert(ps != NULL);
	return ps->top==0;
}
void StackPop(stack* ps)//出栈
{
	assert(ps != NULL);
	assert(!StackEmpty(ps));
	ps->top--;
}
STDataType StackTop(stack* ps)//取栈顶元素
{
	assert(ps != NULL);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}
bool isValid(char * s){
       stack st;
       StackInit(&st);
       while(*s)
       {
           if(*s=='('||*s=='['||*s=='{')
           {
               StackPush(&st,*s);
               s++;
           }
           else
           {
               if(StackEmpty(&st))return false;
               STDataType top=StackTop(&st);
               StackPop(&st);
               if(top=='{'&&*s=='}'||top=='['&&*s==']'||top=='('&&*s==')')
               {
                   s++;
               }
               else return false;
           }
       }
       bool ret=StackEmpty(&st);
       StackDestroy(&st);
       return ret;
}

遇到左半括号把左半括号入到栈里，遇到右半括号让左半括号出栈，看两个括号是不是一对 

2）用队列实现栈

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

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

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;
void QueueInit(Queue* q)//初始化队列
{
	assert(q!=NULL);
	q->head = q->tail = NULL;
}
void QueueDestroy(Queue* q)//销毁队列
{
	assert(q != NULL);
	QueueNode* p = q->head;
	while (p != NULL)
	{
		QueueNode* s = p->next;
		free(p);
		p = s;
	}
}
bool QueueEmpty(Queue* q)//检测队列是否为空
{
	assert(q != NULL);
	return q->head == NULL;
}
void QueuePush(Queue* q, QDataType x)//队尾入队列
{
	assert(q!=NULL);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)exit(1);
	newnode->data = x;
	newnode->next = NULL;
	if (q->head == NULL)
	{
		q->head=q->tail= newnode;
	}
	else
	{
		q->tail->next = newnode;
        q->tail = q->tail->next;
	}	
}
void QueuePop(Queue* q)//队头出队列
{
	assert(q != NULL);
	assert(!QueueEmpty(q));
	if (q->head->next == NULL)
	{
		free(q->head);
		q->head = q->tail = NULL;
	}
	else
	{
		QueueNode* s = q->head;
		q->head = q->head->next;
		free(s);
	}
}
QDataType QueueFront(Queue* q)//获取队列头部元素
{
	assert(q != NULL);
	assert(!QueueEmpty(q));
	return q->head->data;
}
QDataType QueueBack(Queue* q)//获取队列队尾元素
{
	assert(q != NULL);
	assert(!QueueEmpty(q));
	return q->tail->data;
}

int QueueSize(Queue* q)//获取队列中有效元素个数
{
	assert(q != NULL);
	int i = 0;
	QueueNode* s = q->head;
	while (s != NULL)
	{
		i++;
		s = s->next;
	}
	return i;
}


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*empty=&obj->q1;
   Queue*unempty=&obj->q2;
   if(!QueueEmpty(empty))
   {
       empty=&obj->q2;
       unempty=&obj->q1;
   }
   while(QueueSize(unempty)>1)
   {
       QueuePush(empty,QueueFront(unempty));
       QueuePop(unempty);
   }
   int top=QueueFront(unempty);
   QueuePop(unempty);
   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);
}

 把元素都入到一个队列里（1234），然后往另外一个空队列里导（123），当导到只剩一个元素的时候，剩的那一个（4）出队列，这样后入的先出了和栈的顺序相同，每出栈一次，两个队列就要导一次，第一次入栈入到哪个栈都可以因为都是空的，后面如果再入，入到非空的栈里。

因为一个队的元素出队之后入到另外一个队，元素的顺序根本没有变化，而要实现的是栈，出队的元素顺序是出栈的逆序，所以只能靠来回倒来得到逆序的元素

3）用栈实现队列

typedef int STDataType;
typedef struct stack
{
	STDataType* a;
	int top;
	int capacity;
}stack;
void StackInit(stack* ps)//初始化
{
	assert(ps != NULL);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackDestroy(stack* ps)//销毁
{
	assert(ps != NULL);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity=0;
}
void StackPush(stack* ps, STDataType x)//入栈
{
	assert(ps != NULL);
	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)
		{
			exit(1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
bool StackEmpty(stack* ps)//判断栈是否为空
{
	assert(ps != NULL);
	return ps->top==0;
}
void StackPop(stack* ps)//出栈
{
	assert(ps != NULL);
	assert(!StackEmpty(ps));
	ps->top--;
}
STDataType Stacktop(stack* ps)//取栈顶元素
{
	assert(ps != NULL);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}
int StackSize(stack* ps)//元素个数
{
	assert(ps != NULL);
	return ps->top;
}
typedef struct {
    stack pushst;
    stack popst;
} MyQueue;


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

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

int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->popst))
    {
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,Stacktop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    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->popst)&&StackEmpty(&obj->pushst);
}

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

 两个栈，元素（1234）入到第一个栈里，再出栈（4321），入到第二个栈里（4321），此时元素的顺序整个调过来了，再从第二个栈里出栈（1234）就和正常出队的顺序（1234）是一样的了，再出队就不用再来回导数据了

因为一个栈的元素出栈之后入到另外一个栈，元素的顺序变成了逆序，而要实现的是队，逆序的元素出栈顺序恰好是队的出队顺序，所以不用再来回倒

要等负责出队的栈的元素全出栈后，在把负责入队的栈里的元素倒过来

4）设计循环队列

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


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=malloc(sizeof(int)*(k+1));
    obj->head=0;
    obj->tail=0;
    obj->k=k;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head==obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    int next=obj->tail+1;
    if(next==obj->k+1)next=0;
    return next==obj->head;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))return false;
    obj->a[obj->tail]=value;
    obj->tail++;
    if(obj->tail==obj->k+1)
    obj->tail=0;
    //obj->tail%=(k+1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))return false;
    obj->head++;
    if(obj->head==obj->k+1)
    obj->head=0;
    return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))return -1;
    int prev=obj->tail-1;
    //int prev=obj->tail-1+k+1
    //prev%=(k+1);
    if(obj->tail==0)prev=obj->k;
    return obj->a[prev];
}


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

4.概念选择题

第一题

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

第二题

若进栈序列为 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

第三题

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

A 1
B 2
C 99
D 0或者100

第四题

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

第五题

现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N，实际最多存N-1个数据其队内有效长度为？(B)

A (rear - front + N) % N + 1
B (rear - front + N) % N
C (rear - front) % (N + 1)
D (rear - front + N) % (N - 1)

达志华
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现栈和队列面试题
09-03
主要介绍了Java实现栈和队列的面试题，每个例题代码实现非常详细，每一个方法讲解也很到位，特别适合参加Java面试的朋友阅读。
c语言数据结构_c语言的世界数据结构的基本概念
weixin_39814093的博客
11-29 158
点击在看关注我们C语言的世界-数据结构的基本概念01今天小编继续为大家推荐C语言的一些题目。在今后的c语言推荐中，小c会结合计算机二级题库和书本，推荐一些关于数据结构和算法的代码等等。希望大家喜欢。算法介绍2020/4/28了解数据结构问题1：什么是数据结构？数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可...
栈和递归——刷题oj及概念选择题
Ll_R_lL的博客
05-24 230
1.编程oj题 1.1有效的括号 1.1.1题目 力扣 1.1.2思路： 不能数数量，数量对得上不一定是正确的 用栈来解决： 左括号入栈 右括号出栈 1.1.3代码 //先写一个栈 ////////////////////////////////////////////// typedef char STDatatype; typedef struct Stack { STDatatype* a; int top; // 栈顶.
栈专项练习
weixin_59179454的博客
09-14 688
顺序存储方式把逻辑上相邻的节点存储在物理位置放在相邻的存储单元里，节点间的逻辑关系由存储单元的邻接关系来体现。其次，栈的内存分配是由系统自动管理，而堆需要人为通过new、delete等形式分配、释放内存，容易产生碎片化严重的问题；2.再把运算符移到括号后面（前缀移到前面）: (A((B C)+D)*)+;2. 再把运算符移到括号后面（前缀移到前面）：(A ((B C)+ D)*)+；1. 先将中缀表达式加括号：(A + ((B + C) * D))；1.先将中缀表达式加括号：(A+((B+C)*D));
数据结构与算法---顺序存储结构（队）
weixin_45404784的博客
12-13 152
ArrayQueue(队列) 队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表,对于队的操作也是基于线性表来进行操作，所以针对面向对象思想，我们在对队进行操作时就可以直接把队ArrayList的某些操作直接拿来用。 package DS01.动态数组; public interface Queue<E> extends Iterable<E>{ //...
【数据结构】栈和队列选择题和面试编程题
m0_63198468的博客
06-03 947
本文重点讲述了数据结构里面的练习题和一些常见的面试题，给出了详细的解析思路，还附有动图，希望可以帮助大家。
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构，用C语言实现顺序栈和链式队列的源码
04-02
定义顺序栈，完成栈的基本操作：空栈、入栈、出栈、取栈顶元素； 实现十进制数与八进制数的转换，十进制数与十六进制数的转换和任意进制之间的转换； 定义链式队列，完成队列的基本操作：入队和出队；
C语言——模拟实现库函数atoi
2302_80250536的博客
05-13 401
INT_MAX 和 INT_MIN 是 C语言 的两个预定义宏，代表了整型变量能够存储的最大正整数21474836472^31 − 1）和最小负整数-2^31这个值是相对于二进制补码表示的，也就是说，负数的范围比正数大 1,这两个宏在头文件中定义。
C语言：设计循环队列
Another_Shi的博客
05-18 759
本篇博客是写完LeetCode_662.设计循环队列之后有感而发，于是写下了一些思路和总结。本题用了两种方法来解答——顺序表和链表。
数据结构中时间复杂度的介绍
gygkhd的博客
05-17 757
在计算机科学领域，特别是在数据结构和算法的研究中，时间复杂度是一个非常关键的概念。它表示一个算法执行完成所需要的计算工作量。了解时间复杂度有助于预测程序运行的速度和效率，这对于优化程序和解决大规模数据处理问题尤为重要。时间复杂度通常用大O符号（O-notation）来表示，它描述了算法性能与输入数据之间的关系。大O符号忽略了常数和低阶项，只关注程序执行时间随输入数据规模增长的变化趋势。例如，时间复杂度为O(n)的算法表示执行时间与输入数据的规模成线性关系。
java常见算法
qq_24099547的博客
05-17 183
要求待查询的序列是有序数列, 每个取中间位置的值与目标值进行比较。
数据结构总结与练习题
最新发布
关注收藏，可以私信解决问题！
05-20 232
数据结构：数组、链表、栈、队列、哈希表、树、图。算法：排序（冒泡排序、快速排序、归并排序）、搜索算法、动态规划、贪心算法、图算法。操作系统：进程管理、内存管理、文件系统、输入/输出管理。计算机网络：网络层协议（IP、ICMP）、传输层协议（TCP、UDP）、应用层协议（HTTP、FTP、DNS）。编程语言：基础语法、控制结构、数据类型、面向对象编程、函数式编程。知识点数组：固定大小的连续内存空间。链表：由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。
【数据结构】堆（Heep）
SWsunlight的博客
05-17 1077
堆、堆的实现
数据结构_栈在括号匹配中的应用_代码
Hooray11的博客
05-17 245
【代码】数据结构_栈在括号匹配中的应用_代码。
数据结构2（初）：顺序表和链表
yi_ren_yi_xin的博客
05-17 881
数据结构顺序表和链表
Python的数据结构的方法和最佳实践
weixin_55100524的博客
05-18 693
Python 提供了丰富的数据结构，每种数据结构都有其独特的方法和最佳实践。了解并合理运用这些数据结构，对于编写高效、可维护的代码至关重要。在本文中，我们将详细探讨列表、元组、字典和集合的常用方法及其最佳实践。
数据结构栈和队列课后习题头歌
10-18
根据提供的引用内容，我可以为您解答数据结构栈和队列课后习题的相关问题。 根据引用中的内容，我们可以知道栈和队列都是线性结构，栈是一种特殊的线性表，允许插入和删除运算的一端称为栈顶，不允许插入和删除运算...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值