栈和队列OJ总结

一个不是程序员的程序员*

已于 2023-09-26 17:15:28 修改

阅读量65

点赞数 1

文章标签：数据结构 c语言力扣算法

于 2023-09-19 10:49:59 首次发布

本文链接：https://blog.csdn.net/m0_71253709/article/details/133016317

版权

背景

通过对经典编程题练习总结，培养解题思维，锻炼解题能力。

一、题目大纲

1 有效的括号

题目描述
题目：给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
1、左括号必须用相同类型的右括号闭合。
2、左括号必须以正确的顺序闭合。
3、每个右括号都有一个对应的相同类型的左括号。
Example:

思路

有效的括号OJ链接
1、遍历字符串，左括号入栈，右括号进行匹配（晚入栈的括号先匹配）
2、注意：数量要匹配，右括号比左括号多时，要单独处理

code （调用自己写的栈接口）

bool isValid(char * s){
    ST ps;
    STInit(&ps);              //初始化栈
    while(*s != '\0')         //注意是'\0'
    {   
      if(                     //左括号入栈
			(*s == '(')
			||(*s == '{')
			||(*s == '[')
		)
        {
            STPush(&ps,*s);
        }
        else                     //右括号进行匹配
        {
			//数量不匹配，右括号比左括号多
            if(STEmpty(&ps))    //STEmpty返回值为bool 0 -1都为假呀
            {
							STDestroy(&ps);
              return false;
            }

			//左括号与右括号匹配				
            if(
                ((STTop(&ps) == '(')&&(*s == ')'))
              ||((STTop(&ps) == '{')&&(*s == '}'))
              ||((STTop(&ps) == '[')&&(*s == ']'))
            )
            {
              	STPop(&ps);   //匹配成功出栈顶
            }
            else
			{                //否则的话没能匹配到，返回false
                STDestroy(&ps);
                return false;
            }       
        }
        ++s;
    }
	
	//如果栈为空说明都匹配了 返回true
    if(STEmpty(&ps))
    {
			STDestroy(&ps);
			return true;
    }
    else
		{
			STDestroy(&ps);
			return false;
    }
 
}

2 用队列实现栈

题目描述
题目：请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

思路

用队列实现栈
入队列：入不为空的队列，如果两个队列都为空，则可以任意入一个队列
出队列：将不为空的队列中前N-1个元素依次尾插（入）到空队列中，删除剩余元素。
Notice: 入队列在栈上的表现为入栈，通过两个队列入出队列，最终要达到删除栈顶元素的效果。

code:

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

//初始化队列
MyStack* myStackCreate() {
    MyStack* stack = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&stack->q1);
    QueueInit(&stack->q2);
    return stack;
}

void myStackPush(MyStack* obj, int x) {
    //往不为空的队列中尾插数据
    if(QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q2, x);
    }
    else
    {
        QueuePush(&obj->q1, x);
    }
}

int myStackPop(MyStack* obj) {
    Que* empty = &obj->q1;
    Que* nonempty = &obj->q2;
    if(QueueEmpty(&obj->q2))
    {
        nonempty = &obj->q1;
        empty = &obj->q2;
    }
    while(QueueSize(nonempty)-1>0)
    {
        //将非空队列中的前size-1个元素插你到空队列中
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }

    int topval = QueueFront(nonempty);
		QueuePop(nonempty);   //返回栈顶元素，pop最后一个数据
    return topval;
    
}

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

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

3 用栈实现队列

题目描述
题目：请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

思路
用栈实现队列
在这里插入图片描述

code

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


MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));  //初始化队列，其实就是初始化两个栈，因为是用栈实现队列
    STInit(&q->pushst);
    STInit(&q->popst);
		return q;
}

void myQueuePush(MyQueue* obj, int x) {
    STPush(&obj->pushst, x);    //注意STPush（）第一个形参是一个指针，所以这里的pushst要取地址传入
}

int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
		//如果popst栈不为空,倒数据到popst栈
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst,STTop(&obj->pushst));  //将pushst栈中的数据倒入到popst栈中
			STPop(&obj->pushst);
        }

    }


		//放回栈顶元素
    return STTop(&obj->popst);
}

int myQueuePop(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }

    }
			int front = myQueuePeek(obj);   //po栈顶元素之气先保存栈顶元素到front
			STPop(&obj->popst);
			return front;      //返回栈顶元素

}


bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->pushst)&&STEmpty(&obj->popst);   //popst与pushst栈均为空才说明这个队列为空
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->popst);           //先局部释放然后整体释放
    STDestroy(&obj->pushst);
    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

4 循环队列

题目描述
题目：设计你的循环队列实现。循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
实现 MyQueue 类：
MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。
说明：
所有的值都在 0 至 1000 的范围内；
操作数将在 1 至 1000 的范围内；
请不要使用内置的队列库。

思路
循环队列
在这里插入图片描述

code

typedef struct {
     int* arr;
     int k;
     int front;
     int rear;
} MyCircularQueue;

//初始化
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->arr = (int*)malloc(sizeof(int)*(k+1));
    obj->k = k;
    obj->front = 0;
    obj->rear = 0;
    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;
    obj->arr[obj->rear] = value;//每尾插一个数据，尾指针rear往后移动一位。
    ++(obj->rear);
    obj->rear%=obj->k+1;
    return true;
}

//删除数据
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj)) 
        return false;
    ++(obj->front);      //每删除一个数据，头指针front向后移动一位。
    obj->front %= obj->k+1;
    return true;
}

//找到队首元素
int myCircularQueueFront(MyCircularQueue* obj) {
        if(myCircularQueueIsEmpty(obj)) 
        return -1;
        return obj->arr[obj->front];
}

//找到队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj)) 
    {
        return -1;
    }
    else
    {   //当数组为满的时候要进行单独处理
        return obj->arr[(obj->rear + obj->k)%(obj->k+1)];
    }
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->arr);
    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);
*/