（C语言版）力扣（LeetCode）栈和队列面试题

已于 2023-08-06 17:47:58 修改
阅读量1.2k 收藏 34
点赞数 42
分类专栏： OJ专栏 文章标签： leetcode c语言 算法
于 2023-05-13 15:37:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingxzq/article/details/130653993
版权

在这里插入图片描述

栈和队列面试题

20. 有效的括号

题目

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

有效字符串需满足：

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

题目链接：有效的括号

解法一：建立栈解决

代码如下：

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

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void StackDestroy(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->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = realloc(ps->a, sizeof(STDataType)*newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(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))
            {
                StackDestroy(&st);
                return false;
            }

            STDataType top = StackTop(&st);
            StackPop(&st);
            if((*s == '}') && top != '{'
            || (*s == ']') && top != '['
            || (*s == ')') && top != '(')
            {
                StackDestroy(&st);
                return false;
            }
            else
            {
                ++s;
            }
        }
    }
    bool ret=StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}

在C语言中，因为没有现成的栈可以调用，所以这里首先我们建立一个栈结构及各种操作函数建立，以便于这里的函数实现进行调用，这里我们首先建立一个栈st，初始化栈st，第一层while循环判定数组中有没有元素，进入循环后如果首元素为左括号入栈，并将指针位置后移一位，再看else语句，如果栈为空，说明上一段条件语句没执行，直接返回false，不执行这句，说明栈中有元素，则先将栈顶值记录，再删除栈顶元素，再进行括号匹配，如果s此时指向的是右括号并且top不等于左括号，说明不匹配，等于就将指针位置后移再进行匹配，最后遍历完，如果栈为空，则都匹配，否则就不匹配。这种写法代码虽然长，但是相对来说很好理解。
如下图：
在这里插入图片描述

解法二：数组模拟栈解决

代码如下：

char pairs(char a)
{
    if(a==')') return '(';
    if(a=='}') return '{';
    if(a==']') return '[';
    return 0;
}
bool isValid(char * s){
    int n=strlen(s);
    if(n%2==1)
        return false;
    int stk[n],i=0,top=0;
    for(i=0;i<n;i++)
    {
        char ch=pairs(s[i]);
        if(ch)
        {
        if(top==0||stk[top-1]!=ch)
            return false;
        top--;
        }
        else
            stk[top++]=s[i];
    }
    return top==0;
}

这里我们创建一个pairs函数进行返回匹配，如果a是右括号则返回左括号，否则返回0，再看我们的主调函数，我们首先记录字符串长度，如果长度为奇数，直接返回false，如果没进入条件语句，则执行下面语句，首先我们建立字符串长度的数组stk，然后就是一个for循环，循环次数为字符串长度（防止最坏情况，全为左括号），首先记录第一个字符调用pairs函数进行匹配，如果是左括号，返回0；进入else语句，stk首元素记录第一个字符，top+1，再进行第二次循环，如果为右括号，则ch记录为左括号，进行匹配，如果相同，top-1，不相同则直接返回false，循环结束，如果top等于0，则返回ture，否则为false，其实这种写法原理和上面是一样的，只不过编写形式不一样。
如下图：
在这里插入图片描述

225. 用队列实现栈

题目

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

实现 MyStack 类：

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

注意
你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

题目链接：用队列实现栈

解法：两个队列实现栈

代码如下：

typedef struct {
    int queue1[100];
    int queue2[100];
    int front1;
    int front2;
    int rear1;
    int rear2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* stack=malloc(sizeof(MyStack));
    stack->front1=0;
    stack->front2=0;
    stack->rear1=0;
    stack->rear2=0;
    return stack;
}

void myStackPush(MyStack* obj, int x) {
    obj->queue1[(obj->rear1)++]=x;
}

int myStackPop(MyStack* obj) {
    int front1=obj->front1;
    int front2=obj->front2;
    int rear1=obj->rear1;
    int rear2=obj->rear2;
    while(rear1-front1>1)
    {
        obj->queue2[rear2++]=obj->queue1[front1++];
    }
    int top=obj->queue1[front1++];
    while(front2!=rear2)
    {
        obj->queue1[rear1++]=obj->queue2[front2++];
    }
    obj->front1=front1;
    obj->front2=front2;
    obj->rear1=rear1;
    obj->rear2=rear2;

    return top;
}

int myStackTop(MyStack* obj) {
    return obj->queue1[obj->rear1-1];
}

bool myStackEmpty(MyStack* obj) {
    return obj->queue1[obj->front1]==obj->queue2[obj->front2];
}

void myStackFree(MyStack* obj) {
    obj->front1=obj->front2=obj->rear1=obj->rear2=0;
}

具体思路如下图：
请添加图片描述
入栈
请添加图片描述
入栈
请添加图片描述

请添加图片描述
请添加图片描述
出栈
请添加图片描述

232. 用栈实现队列

题目

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

解法：两个栈实现队列

代码如下：

typedef struct {
    int* stk;
    int stksize;
    int stkcapacity;
}Stack;

Stack* createStack(int capacity)
{
    Stack* ret=malloc(sizeof(Stack));
    ret->stk=malloc(sizeof(int)*capacity);
    ret->stksize=0;
    ret->stkcapacity=capacity;
    return ret;
}

void stackpush(Stack* obj,int x)
{
    obj->stk[obj->stksize++]=x;
}

void stackpop(Stack* obj)
{
    obj->stksize--;
}

int stacktop(Stack* obj)
{
    return obj->stk[obj->stksize-1];
}

bool stackempty(Stack* obj)
{
    return obj->stksize==0;
}

void stackfree(Stack* obj)
{
    free(obj->stk);
}

typedef struct {
    Stack* inqueue;
    Stack* outqueue;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* ret=malloc(sizeof(MyQueue));
    ret->inqueue=createStack(100);
    ret->outqueue=createStack(100);
    return ret;
}

void inout(MyQueue* obj)
{
    while(!stackempty(obj->inqueue))
    {
        stackpush(obj->outqueue,stacktop(obj->inqueue));
        stackpop(obj->inqueue);
    }
}

void myQueuePush(MyQueue* obj, int x) {
    //stackpush(obj->inqueue,x);
    obj->inqueue->stk[obj->inqueue->stksize++]=x;
}

int myQueuePop(MyQueue* obj) {
    if(stackempty(obj->outqueue))
    {
        inout(obj);
    }
    int x=stacktop(obj->outqueue);
    stackpop(obj->outqueue);
    return x;
}

int myQueuePeek(MyQueue* obj) {
    if(stackempty(obj->outqueue))
    {
        inout(obj);
    }
    return stacktop(obj->outqueue);
}

bool myQueueEmpty(MyQueue* obj) {
    return (stackempty(obj->inqueue)&&stackempty(obj->outqueue));
}

void myQueueFree(MyQueue* obj) {
    stackfree(obj->inqueue);
    stackfree(obj->outqueue);
}

具体思路如下图：
在这里插入图片描述

622. 设计循环队列

题目

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。

题目链接：设计循环队列

解法一：数组

代码如下：

typedef struct {
    int front;//队首
    int rear;//队尾
    int capacity;//容量
    int* elem;//元素
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* ret=malloc(sizeof(MyCircularQueue));
    ret->capacity=k+1;
    ret->elem=malloc(sizeof(int)*ret->capacity);
    ret->front=ret->rear=0;
    return ret;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if((obj->rear+1)%obj->capacity==obj->front)
        return false;
    obj->elem[obj->rear]=value;
    obj->rear=(obj->rear+1)%obj->capacity;
    return true;
}

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

int myCircularQueueFront(MyCircularQueue* obj) {
    if(obj->front==obj->rear)
        return -1;
    return obj->elem[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(obj->front==obj->rear)
        return -1;
    return obj->elem[(obj->rear-1+obj->capacity)%obj->capacity];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1)%obj->capacity==obj->front;
}

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

首先是队列结构体的建立，然后是队列初始化创建，和普通队列不同的是这里的capacity是给定值k+1，这里的用处在后面的函数会体现。

入队列：首先判定队尾下标+1模上容量等于队首下标，说明队列已经满了，返回false。入队为队尾值为下标，更新队尾值为+1模上容量，而不是直接++。

出队列：题目要求是直接删除，返回逻辑值，所以这里直接删除队首值对应下标元素，同样是队首值+1模上容量，实际此时并没删除，但是等到队尾值对应下标访问该位置入队列时会直接覆盖，而且此时这个位置也不是合法位置，所以不需要直接将其删除。

返回队首值：题目要求队列为空返回-1，只有队首等于队尾时，队列才为空，否则直接返回队首值对应下标元素即为队首。

返回队尾值：为空和上面一样，否则返回队尾值-1加上容量值再%上容量，很多人看不懂这句，举个例子，假设这时队列是满的，那么如果队尾值为0，减去1的话为负值，再去取余数就出现了越界，而且返回值是错的。

返回队列是否为空：返回队首队尾是否相等即可

返回队列是否已满：队尾值+1模上容量如果等于front，那就满了

讲到这你会发现容量的初始值设定非常的奇妙，它是循环队列思路的关键。

解法二：链表

代码如下：

typedef struct {
    struct ListNode *head;//队首指针
    struct ListNode *tail;//队尾指针
    int capacity;//容量
    int size;//长度
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue *obj = (MyCircularQueue *)malloc(sizeof(MyCircularQueue));
    obj->capacity = k;
    obj->size = 0;
    obj->head = obj->tail = NULL;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (obj->size >= obj->capacity) {
        return false;
    }
    struct ListNode *node = (struct ListNode *)malloc(sizeof(struct ListNode));
    node->val = value;
    node->next = NULL;
    if (!obj->head) {
        obj->head = obj->tail = node;
    } else {
        obj->tail->next = node;
        obj->tail = node;
    }
    obj->size++;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (obj->size == 0) {
        return false;
    }
    struct ListNode *node = obj->head;
    obj->head = obj->head->next;  
    obj->size--;
    free(node);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (obj->size == 0) {
        return -1;
    }
    return obj->head->val;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (obj->size == 0) {
        return -1;
    }
    return obj->tail->val;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->size == 0;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->size == obj->capacity;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    for (struct ListNode *curr = obj->head; curr;) {
        struct ListNode *node = curr;
        curr = curr->next;
        free(node);
    }
    free(obj);
}

这种写法是使用双向循环链表的写法，个人觉得这种写法比上面的要更好理解
首先是队列结构体的建立和初始化队列

入队列：如果长度等于容量队列已满，返回false，这里插入分两种情况，第一种是第一次插入时，首位指针都指向该元素结点，之后每次插入为第二种情况，一直挪动尾指针即可，插入成功，size+1，返回true

出队列：如果size为0，返回false，头指针指向下一结点，size-1，返回true

返回队首值：直接返回队首指针指向元素即为队首。

返回队尾值：直接返回队尾指针指向元素即为队尾。

返回队列是否为空：返回队首size是否为0。

返回队列是否已满：size等于capacity就满了。

结语

这里的解法代码部分来自力扣官方和作者自己的解法，作者只是进行了详细的剖析和部分改动方便大家理解和提升自己，学会多角度观察问题，解决问题。

有兴趣的小伙伴可以关注作者，如果觉得内容不错，请给个一键三连吧，蟹蟹你哟！！！
制作不易，如有不正之处敬请指出
感谢大家的来访，UU们的观看是我坚持下去的动力
在时间的催化剂下，让我们彼此都成为更优秀的人吧！！！

爱学习的鱼佬
关注
  • 42
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 34
    评论
专栏目录
力扣(LeetCode)面试150道题及题解整理
03-28
这份资源整理了力扣（LeetCode）面试中的150道题目，以及它们的详细解答。这些题目涵盖了各种算法和数据结构的应用，包括但不限于数组、链表、树、图、动态规划、贪心算法等。通过这份整理，你可以系统地学习和掌握...
【C语言刷题——Leetcode12道题】带你起飞，飞进垃圾堆
热门推荐
weixin_60478154的博客
06-24 1万+
刷题之——Leetcode12道简单题，通过这12道简单题，让你对Leetcode有所新的理解，增强自己的做题能力。下面，直接进入我们的题目。👇这道题Leetcode难度归类为中等，但是我感觉我们撑一撑应该还是能做得出来的（bushi）：这里的变量为了方便说明就使用我做题过程中命名的名字了🌹解题思路：首先，我们定义一个变量（eor）初始化为0去遍历按位异或数组中的所有元素，此时得到的是只出现一次的两个元素的二进制异或结果。然后去对二进制的结果进行处理：对于两个不同的数字，异或出来的二进制结果中为1的话说..
LeetCode题库-1~10（C语言）
最新发布
qq_52167875的博客
02-04 1416
s 由英文字母（大写和小写）、数字（0-9）、’ ‘、’+‘、’-’ 和 ‘.’ 组成。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。p 只包含从 a-z 的小写字母，以及字符 . 和 *。s 由英文字母（小写和大写）、‘,’ 和 ‘.’ 组成。的链表，表示两个非负的整数。请你将两个数相加，并以相同形式返回一个表示和的链表。的方式存储的，并且每个节点只能存储。
【C语言刷题——Leetcode10道简单题】
weixin_60478154的博客
06-11 2513
C语言——Leetcode10道简单题
（C语言版）力扣（LeetCode）面试题 17.04. 消失的数字5种解法
立志做一个高产且细节博主
04-12 1715
（C语言版）力扣（LeetCode）面试题 17.04. 消失的数字5种解法
【leetcode】001.两数之和（C语言/C++，超详细）
慕雪华年的博客
10-31 1万+
文章目录两数之和 leetcode-001题目要求实现步骤1.模板中四个值的意义2.在数组中找到两个连续的元素3.判断相加是否等于target4.返回元素下标代码示例1static的作用*returnSize是什么？代码示例2什么是malloc函数？malloc使用后free释放总结 两数之和 leetcode-001 题目来源leetcode 如下图所示 右侧给出了题目的基本模板 /** * Note: The returned array must be malloced, assume calle
力扣Leetcode试题选编(第三卷)
08-29
程序人攻关打怪必备手册，700多页，还不够你学的？
力扣Leetcode试题选编(第二卷)
08-29
程序员认证必备
Leetcode Top100题目和答案(C#完整版 面试必备).pdf
10-30
**大中小企业都在使用：**常常会直接或者间接使用力扣（LeetCode） 的题目资源，依然慢慢成为考核技术能力和思维方式的黄金标准。 **支持 13+ 种汇编语言：**Ruby, Swift, Kotlin, C, C++, Java, Python, ...
leetcode中文版-LeetCode:力扣（LeetCode）的习题练习
06-29
leetcode中文版 这是我力扣(LeetCode)的解题思路记录 欢迎大家浏览，这里的解题思路是我看到题目后真实的想法，包括了对问题的解析和尝试，当然也包含了错误的解析和错误的尝试（滑稽） 基础是python的版本，正好...
leetcode题库-codelife:C、算法、leetcode、foroffer
06-29
leetcode题库 常见数据结构和算法，面试题的实现。主要采用C语言实现 leetcode leetcode是题目解法，按照题目的编号进行命名，文件开头注明了题目名称和链接。 algorthms algorthms是一些算法和数据结构的练习 interview interview是我在面试中遇到的一些算法题 foroffer foroffer是《剑指offer》中一些题 docs 相关算法记录、总结 算法专注月 对于数据结构和算法的训练要持续的进行，不然很容易忘记 月 专注事项 2019年12月 图算法，实现基本的图表示和遍历算法 2020年01月 图算法，实现最短路径和最大流相关算法 2020年02月 树算法，利用B+树实现小型数据库 2020年03月 树算法，实现java hashmap结构，涉及红黑树，数组和链表
leetcode题目解答
05-11
较为详细的leetcode题目解析，C++编写，其他语言的可以不用下载
LEETCode题目和解答
01-08
leetcode所有题目和解答，是java版本的，但是也包括c语言版本，包括程序和题解，并且含有算法精髓，花了两个多月粗略看完的，分享给想刷题的你们。
LeetCode数据结构_C语言题解系列-树
wzbbbb的博客
04-29 103
LeetCode数据结构_C语言题解系列-树
LeetCode数据结构_C语言题解系列-数组II&动态规划
wzbbbb的博客
04-13 463
LeetCode_C语言题解系列-数组II
leetcode-C语言代码练习
baron-周贺贺-代码改变世界ctw
01-04 2385
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1] /** * Note: The returned array must be malloced, assume caller call
一、C语言编程LeetCode数据结构题
qq_43751506的博客
06-27 398
使用C语言编程数据结构题目
2023华为od机试C卷【山脉的个数】C语言实现
MISAYAONE的博客
11-14 504
给定一个数组，数组中的每个元素代表该位置的海拔高度。0表示平地，>=1时表示属于某个山峰，山峰的定义为当某个位置的左右海拔均小于自己的海拔时，该位置为山峰。数组起始位置计算时可只满足一边的条件。
力扣经典面试题150道第88python
12-14
在LeetCode上，您可以找到各种Python编程的经典面试题，例如“两数之和”、“反转链表”、“二叉树的最大深度”等等。您可以通过提交代码来检验您的解题思路和代码实现是否正确。 如果您想了解更多关于LeetCode的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱学习的鱼佬

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

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

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

打赏作者

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

抵扣说明：

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

余额充值