栈和队列面试题（C语言）

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

文章目录


因为C语言没有栈和队列的库，所以以下例题栈和队列均要手搓
在这里插入图片描述

1. 括号匹配问题

括号匹配问题
整体思路：如果为左括号就入栈，右括号就拿栈顶的元素进行匹配，全部匹配成功返回true，否则返回false

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);
//栈的大小
int STSize(ST* ps);
//判空
bool STEmpty(ST* ps);
//返回栈顶元素
STDatatype STTop(ST* ps);

//初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->a = (STDatatype*)malloc(sizeof(STDatatype) * 4);
	if (ps->a == NULL)
	{
		perror("STInit::malloc");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;//top是栈顶元素的下一个位置
	//ps->top=-1;//top是栈顶元素的位置
}
//销毁
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	//ps->a = NULL;
	ps->capacity = ps->top = 0;
}
//插入
void STPush(ST* ps, STDatatype x)
{
	assert(ps);
	//满了扩容
	if (ps->top == ps->capacity)
	{
		STDatatype* tmp = (STDatatype*)realloc(ps->a, sizeof(STDatatype) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("STPush::realloc");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//删除
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}
//栈的大小
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//判空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
//返回栈顶元素
STDatatype STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->a[ps->top - 1];
}

bool isValid(char * s)
{
    ST st;
    //字符串单数必定不匹配，所以直接返回false
    int n = strlen(s);
    if (n % 2 == 1) 
    {
        return false;
    }

    STInit(&st);
    while(*s)
    {
        //如果是左括号就入栈
        if(*s=='('||*s=='{'||*s=='[')
        {
            STPush(&st,*s);
        }
        else//出栈顶的元素进行比较
        {
            //栈不为空就比较
            if(!STEmpty(&st))
            {
            	//栈顶元素不匹配返回false
                if(*s==')' && STTop(&st)!='('
                ||*s=='}' && STTop(&st)!='{'
                ||*s==']' && STTop(&st)!='[')
                {
                    STDestroy(&st);
                    return false;
                }
                //匹配栈顶元素删除
                else
                {
                    STPop(&st);
                }
            }
            //栈为空就结束
            else
            {
                STDestroy(&st);
                return false;
            }
        }
        s++;
    }
    //循环结束后栈不为空则代表未全部匹配成功，返回false
    //为空返回true
    if(!STEmpty(&st))
    {
        STDestroy(&st);
        return false;
    }
    STDestroy(&st);
    return true;
}

2. 用队列实现栈

用队列实现栈
整体思想：
1.保持一个队列为空，一个队列存数据
2.出栈，把前面的数据倒入空队列（保留最后一个数据在原队列）

typedef int QDatatype;

typedef struct QNode
{
	struct QNode* next;
	QDatatype data;
}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);
//返回队列当前元素个数
int QueueSize(Queue* pq);
//判空
bool QueueEmpty(Queue* pq);
//返回头元素
QDatatype QueueFront(Queue* pq);
//返回尾元素
QDatatype QueueBack(Queue* pq);

//队列的初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}
//队列的销毁
void QueueDestroy(Queue* 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(Queue* pq, QDatatype x)
{
	assert(pq);
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
	{
		perror("QueuePush::malloc");
		return;
	}
	tmp->data = x;
	tmp->next = NULL;
	if (pq->head == NULL)
	{
		//头为空时判断尾一定要为空
		assert(pq->tail == NULL);
		pq->head = pq->tail = tmp;
	}
	else
	{
		pq->tail->next = tmp;
		pq->tail = tmp;
	}
	pq->size++;
}
//删除
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	//防止tail为野指针
	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--;
}
//返回队列当前元素个数
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}
//返回头元素
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;
}

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


MyStack* myStackCreate() {
    MyStack*pst=(MyStack*)malloc(sizeof(MyStack));
    if(pst==NULL)
    {
        perror("myStackCreate:::malloc");
        return NULL;
    }
    //已经写好了队列，直接用写好的队列进行操作
    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*empty=&obj->q1;
    Queue*nonempty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty=&obj->q2;
        nonempty=&obj->q1;
    }
    //除了最后一个数据，其他全部倒过去
    while(QueueSize(nonempty)>1)
    {
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }
    //返回并删除最后一个数据
    int top=QueueBack(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);
}

3. 用栈实现队列

用栈实现队列
整体思想：一个栈为Pushst用来入栈，一个栈为Popst用来出栈。入栈时，直接把数据Push到Pushst栈中；出栈时，当Popst为空，则把Pushst的数据全部倒过来，Popst不为空时，直接出Popst栈里的数据。



typedef int 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);
//栈的大小
int STSize(ST* ps);
//判空
bool STEmpty(ST* ps);
//返回栈顶元素
STDatatype STTop(ST* ps);

//初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->a = (STDatatype*)malloc(sizeof(STDatatype) * 4);
	if (ps->a == NULL)
	{
		perror("STInit::malloc");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;//top是栈顶元素的下一个位置
	//ps->top=-1;//top是栈顶元素的位置
}
//销毁
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	//ps->a = NULL;
	ps->capacity = ps->top = 0;
}
//插入
void STPush(ST* ps, STDatatype x)
{
	assert(ps);
	//满了扩容
	if (ps->top == ps->capacity)
	{
		STDatatype* tmp = (STDatatype*)realloc(ps->a, sizeof(STDatatype) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("STPush::realloc");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//删除
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}
//栈的大小
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//判空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
//返回栈顶元素
STDatatype STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->a[ps->top - 1];
}

typedef struct {
    ST Pushst;
    ST Popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue*pst=(MyQueue*)malloc(sizeof(MyQueue));
    if(pst==NULL)
    {
        perror("myStackCreate:::malloc");
        return NULL;
    }
    //已经写好了队列，直接用写好的队列进行操作
    STInit(&pst->Pushst);
    STInit(&pst->Popst);

    return pst;
}

void myQueuePush(MyQueue* obj, int x) {
    //直接往Pushst里入
    STPush(&obj->Pushst,x);
}

int myQueuePop(MyQueue* obj) {
    //如果Popst为空，则倒数据
    /*if(STEmpty(&obj->Popst))
    {
        while(!STEmpty(&obj->Pushst))
        {
            STPush(&obj->Popst,STTop(&obj->Pushst));
            STPop(&obj->Pushst);
        }
    }
    int ret=STTop(&obj->Popst);*/
    int ret=myQueuePeek(obj);
    STPop(&obj->Popst);
    return ret;
}

int myQueuePeek(MyQueue* obj) {
    //如果Popst为空，则倒数据
    if(STEmpty(&obj->Popst))
    {
        while(!STEmpty(&obj->Pushst))
        {
            STPush(&obj->Popst,STTop(&obj->Pushst));
            STPop(&obj->Pushst);
        }
    }
    int ret=STTop(&obj->Popst);
    return ret;
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->Popst) && STEmpty(&obj->Pushst);
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->Popst);
    STDestroy(&obj->Pushst);
    free(obj);
}

4. 设计循环队列

设计循环队列
整体思想：用数组模拟实现循环队列，多增加一个数组的容量去判空来实现循环，以取模的方式来控制头尾指针在数组内部以进行操作。

typedef struct {
    int*a;//数组
    int front;//头下标
    int rear;//尾下标
    int k;//队列长度
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //assert(obj);
    //assert(tmp);
    obj->a=(int*)malloc(sizeof(int)*(k+1));//多开一个空间用来判断空满
    obj->rear=obj->front=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;
    }
    else
    {
        obj->a[obj->rear++]=value;
        obj->rear%=obj->k+1;
    }
    return true;
}

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

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
    	//先加上数组再取模防止指针跳出数组合法范围
        return obj->a[((obj->rear-1)+obj->k+1)%(obj->k+1)];
    }
}

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

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

注意：凡是front或rear++都要进行取模判断，防止头尾指针跳出指定数组。

CC小师弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言面试题总汇（下）
ldhlsj的专栏
10-30 636
4. int func(int a) { int b; switch(a) { case 1: 30; case 2: 20; case 3: 16; default: 0 } return b; } 则func(1)=? // b定义后就没有赋值。 5: int a[3]; a[0]=0; a[1]=1; a[2]=2; int *p, *q; p=a; q=&a[2]; 则a[q-p]=a[2
栈和队列面试题（二）
z_xiao_xue的博客
08-20 567
2.使用两个栈实现一个队列。 思想：栈是先进后出的数据结构，队列是先进先出的数据结构，要用两个栈实现一个队列，就必须让两个栈实现元素的先进先出。入栈时，让需要入栈的元素全都进入S1栈中，出栈时，再把S1中的元素依次出栈，入S2栈，再把S2的栈顶元素弹出。 如下图所示： 当然，这个过程过于繁琐，有可以优化的方法 如下图所示： 代码实现： //两个栈实现一个队列 #include
栈和队列经典面试题
bit_zyx的博客
04-07 3092
目录 1、括号匹配问题 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 1、括号匹配问题 链接直达： 有效的括号 题目： 思路： 2、用队列实现栈 3、用栈实现队列 4、设计循环队列 ...
详解栈和队列面试题(C语言版)，含动图和思路分析
iwkxi的博客
03-27 2738
文章目录1.栈和队列面试题1.1[括号匹配问题](https://leetcode-cn.com/problems/valid-parentheses/)1.2. [用队列实现栈](https://leetcode-cn.com/problems/implement-stack-using-queues/) 1.栈和队列面试题 1.1括号匹配问题 //C语言实现栈 typedef char STDataType; typedef struct Stack { STDataType* a; int t
（C语言）数据结构之栈和队列面试题
博主qq1077644249
08-11 846
下一次想出栈的时候就再倒一次，也就是把q2的前n-1个元素出队并入队到q1，然后q2把剩下的那个元素出队即可，此时q2为空下一次再入栈的时候，也就不用管q1还是q2，就直接谁有元素就往谁的里面入队元素即可。每次入队的时候先要判断当先队列是否是满的，不为满，让back当前位置赋值要入队的元素，然后back正常++往后走，关键的来了再进行back=back %（k+1）操作即可实现循环。为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是最后入栈的元素。...
C语言最新面试题及答案.doc
07-14
"C语言面试题及答案" C语言面试题及答案.doc 文件中涵盖了...C语言面试题及答案.doc文件涵盖了C语言的基础知识、变量、循环语句、函数、数据类型、存储方式等方面，为学习C语言和面试C语言岗位提供了很好的参考资料。
嵌入式C语言面试题.zip
06-19
9. **实时操作系统（RTOS）**：如果面试涉及到RTOS，那么你需要了解任务调度、信号量、互斥锁、邮箱和消息队列等概念。 10. **嵌入式编程特定问题**：比如硬件接口编程（如GPIO、UART、SPI、I2C等）、固件升级、...
嵌入式C语言面试题汇总
02-26
3. 队列和栈的区别：队列先进先出，栈后进先出。 4. 不能做 switch() 的参数类型：实型。 5. 局部变量能否和全局变量重名：能，局部变量会屏蔽全局变量。 6. 如何引用一个已经定义过的全局变量：可以用引用头文件的...
宇视科技C语言面试题
02-15
13. **算法和数据结构**：虽然不是C语言的核心，但作为程序员的基本功，排序、搜索、图论、栈、队列等基础算法和数据结构的运用会被纳入考察范围。 以上就是宇视科技C语言面试题可能涵盖的主要知识点，准备面试时，...
C语言中的一些算法和面试题
03-29
C语言作为一种经典的程序设计语言,在算法和面试题方面有着广泛的应用。掌握C语言算法和面试题不仅能够加深对语言本身的理解,更能够培养逻辑思维能力和解决问题的能力,为今后的工作和面试打下坚实的基础。 在算法...
华为OD机试(C卷,200分)- 二叉树计算
欢迎来到我的博客~
07-20 605
6、递归处理左区间右区间并计算每个节点的childSum，新树的每个节点的值 = 其左右子树的所有节点值之和。左子树表示该节点左侧叶子节点为根节点的一颗新树；右子树表示该节点右侧叶子节点为根节点的一颗新树。请由该二叉树生成一个新的二叉树，它满足其树中的每个节点将包含原始树中的左子树和右子树的和。2行整数，第1行表示二叉树的中序遍历，第2行表示二叉树的前序遍历，以空格分割。1行整数，表示求和树的中序遍历，以空格分割。输出 0 3 0 7 0 2 0。2、前序数组第一个元素为根节点。1、前序数组为0，空节点。
Windows图形界面(GUI)-DLG-C/C++ - 状态栏(StatusBar)
最新发布
0xCC说逆向
07-20 271
【代码】Windows图形界面(GUI)-DLG-C/C++ - 状态栏(StatusBar)
【C语言】条件运算符详解 - 《 A ? B : C 》
EleganceJiaBao的博客
07-16 504
条件运算符（也称为三元运算符）是C语言中唯一的三元运算符。它通常用于替代简单的 if-else 语句。条件运算符的语法如下：
学懂C语言（十）： C语言位运算符（按位与、按位或、左移、右移、异或、取反）的计算过程和底层原理
martian665的专栏
07-20 319
C语言位运算符（按位与、按位或、左移、右移、异或、取反）的计算过程和底层原理
C语言——字符串两种声明初始化方式、输入输出及常见处理函数
weixin_45720999的博客
07-19 541
C语言中的字符串是一个字符数组，它以空字符（\0）作为结束标志。这意味着字符串中的字符是连续存储在内存中的，而字符串的末尾会自动添加一个\0字符来表示字符串的结束。常见的字符串定义方式有两种：字符串常量和字符串变量，字符串常量不允许被修改......
数据结构之栈的实现与排序详解与示例（C, C#, C++）
qq_35320456的博客
07-16 402
本文详细介绍了栈的排序方法，包括递归法和辅助栈法，并提供了C, C#, C++三种语言的示例。递归法利用递归将栈顶元素出栈，然后重新插入到正确的位置；辅助栈法则利用一个额外的栈来辅助排序。这两种方法都可以实现栈的排序，但辅助栈法在实际应用中更为常见，因为它避免了递归可能带来的栈溢出问题。
C语言之封装，继承，多态
chi's blog
07-17 238
在Linux内核中数量最多的就是驱动程序代码，因为硬件设备是多种多样的，每种设备都会有对应的驱动程序。Linux对上层的接口都是统一和抽象的，要保证相同的接口最终能够对应到特定的硬件设备，这就需要使用多态的技巧。如何使用c来实现同样的效果，首先肯定还是需要struct来构建父类和子类，同时如果要达到is a的效果，从内存空间来看，也就意味着父类占据了子类内存地址的最开始位置。封装的本质就是将数据和方法集中到一个对象中，c++或者java使用的是class来实现。继承可以让子类使用父类的资源，减少重复。
C语言--＞指针详解
letterljhx的博客
07-16 924
C语言-->指针详解
C语言——数组指针
weixin_45720999的博客
07-17 355
数组指针是指向一个数组的指针。在C语言中，数组名在大多数情况下会退化为指向其首元素的指针，但这并不直接等同于数组指针。
C语言面试宝典：必备知识点与陷阱
这份文档涵盖了广泛的内容，从基础概念如关键字static的作用、引用和指针的区别，到高级话题如内存管理（全局变量和局部变量的存储位置、堆栈溢出的原因）、数据结构（平衡二叉树、队列和栈的特性）和时间复杂度分析...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CC小师弟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值