【数据结构入门】栈和队列的OJ题

屁股割了还要学2025-08-11 19:15

目录

[1. 有效的括号](#1. 有效的括号)

分析：

代码：

[2. 用队列实现栈](#2. 用队列实现栈)

分析：

代码：

[3. 用栈实现队列](#3. 用栈实现队列)

分析：

代码：

[4. 设计循环队列](#4. 设计循环队列)

思路：

代码：

定义循环队列结构体：

初始化结构体对象：

判断双向队列是否为空

判断双向队列是否是满的

双向队列入队

双向队列出队

获取头指针的元素

获取最后一个元素

内存清空

1. 有效的括号

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

有效字符串需满足：

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

示例 1：

**输入：**s = "()"

**输出：**true

示例 2：

**输入：**s = "()[]{}"

**输出：**true

示例 3：

**输入：**s = "(]"

**输出：**false

示例 4：

**输入：**s = "([])"

**输出：**true

示例 5：

**输入：**s = "([)]"

**输出：**false

分析：

这里由于是用C语言来oj，所以需要提前写好一个栈。

每一次循环判断当前元素是否是左括号，如果是左括号那么就入栈，如果不是左括号就判断当前元素和栈顶元素是否相同，相同就出栈，如果不相同就直接返回false；

需要注意的一点是如果此时字符串只有一个左括号，那么循环就会压入一个栈元素，就会停止，此时还需要判断栈是否为空，如果为空，那么就返回true，不为空，说明左括号比右括号多，没有完全配对成功；那么只有一个右括号就会直接在循环内返回false。

代码：

cpp 复制代码 
typedef char dataType;
typedef struct Stack 
{
	dataType* _a; // 用数组来实现
	int _top;// 栈的数据的个数、栈顶元素下表
	int _capacity; // 栈的容量
}Stack;

// 初始化
void InitStack(Stack* stk);
// 销毁
void DestroyStack(Stack* stk);
// 入栈
void PushStack(Stack* stk,dataType x);
// 出栈
void PopStack(Stack* stk);
// 栈的元素个数
int SizeStack(Stack* stk);
// 栈是否为空
int isEmpty(Stack* stk);
// 获取栈顶数据
dataType getTop(Stack* stk);
// 初始化
void InitStack(Stack* stk)
{
	assert(stk);
	stk->_a = malloc(sizeof(dataType) * 4);
	stk->_capacity = 4;
	stk->_top = 0;// 栈顶元素下标为0
}
// 销毁
void DestroyStack(Stack* stk)
{
	assert(stk);
	free(stk->_a);
	stk->_a = NULL;
	stk->_capacity = stk->_top = 0;
}
// 入栈
void PushStack(Stack* stk, dataType x)
{
	assert(stk);
	if (stk->_capacity == stk->_top) // 容量和栈元素个数相等，就扩容
	{
		stk->_capacity *= 2;
		dataType* tmp = (dataType*)realloc(stk->_a, sizeof(dataType) * stk->_capacity);
		if (tmp == NULL)
		{
			printf("内存不足！");
			exit(-1);
		}
		else
		{
			stk->_a = tmp;
		}
	}
	// 正常插入
	stk->_a[stk->_top] = x;
	stk->_top++;

}
// 出栈
void PopStack(Stack* stk)
{
	assert(stk);
	assert(stk->_top > 0);// 有元素才能删除
	stk->_top--;
}
// 栈的元素个数
int SizeStack(Stack* stk) 
{
	assert(stk);
	return stk->_top;
}
// 栈是否为空
int isEmpty(Stack* stk) 
{
	assert(stk);
	return stk->_top == 0 ? 1 : 0; // 没有元素就是空
}
// 获取栈顶数据
dataType getTop(Stack* stk) 
{ 
	assert(stk);
	if (stk->_top > 0)
	{
		return stk->_a[stk->_top - 1];
	}
	else 
	{
		return -1;
	}
}

bool isValid(char* s) {
    char* curr = s; 
    Stack stk;
    InitStack(&stk);
        while(*curr != '\0')
        {
           if((*curr) == '[' || (*curr) == '{' || (*curr) == '(')       // 前括号
           {
                PushStack(&stk,*curr);
           }else
           {
            // 反括号
            if((*curr) == ']' && getTop(&stk) == '[')
            {
                PopStack(&stk);
            }else if((*curr) == '}' && getTop(&stk) == '{')
            {
                PopStack(&stk);
            }else if((*curr) == ')' && getTop(&stk) == '(')
            {
               PopStack(&stk);
            }else
            {
                // 匹配就出栈，不匹配返回false
                DestroyStack(&stk);
                return false;
            }
           }
            curr++;
        }
        


          if(isEmpty(&stk))
        {
            DestroyStack(&stk);
            return true;
        }else
        {
            DestroyStack(&stk);
            return false;
        }


}

2. 用队列实现栈

请你仅使用两个队列实现一个后入先出（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（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

复制代码 
输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

分析：

使用两个队列即可

入栈：随便选择一个不为空的队列入队即可。

出栈：出队到只剩一个节点为止，将那个节点出队。

获取栈顶元素：获取不为空的队列的tail即可。

判空：两个队列为空，栈为空。

初始化栈：创建堆空间给栈，初始化两个队列，返回栈指针。

释放空间：由于C++没有检测内存泄露的手段，所以此模块不写oj也不会报错；如果要写的话，那么先释放队列的空间，可以使用destroy接口，释放完毕，free栈空间。

由于是c语言实现，所以需要提前实现队列。

代码：

cpp 复制代码 
typedef int dataType;

typedef struct QueueNode {
    dataType data;
    struct QueueNode* next;
} QueueNode;

typedef struct Queue {
    QueueNode* head;
    QueueNode* tail;
} Queue;

void QueInit(Queue* pq);
void QueDestroy(Queue* pq);
void QuePush(Queue* pq, dataType x);
void QuePop(Queue* pq);
dataType QueFront(Queue* pq);
dataType QueBack(Queue* pq);
int isEmpty(Queue* pq);
int QueSize(Queue* pq);

void QueInit(Queue* pq) {
    assert(pq);
    pq->head = pq->tail = NULL;
}

void QueDestroy(Queue* pq) {
    assert(pq);
    QueueNode* curr = pq->head;
    while (curr) {
        QueueNode* next = curr->next;
        free(curr);
        curr = next;
    }
    pq->head = pq->tail = NULL;
}

void QuePush(Queue* pq, dataType x) {
    assert(pq);
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->data = x;
    newNode->next = NULL;
    if (pq->head == NULL) // 如果队列为空，插入一个节点
    {
        pq->head = pq->tail = newNode;
    } else {
        pq->tail->next = newNode; // 队列不为空，tail插入节点
        pq->tail = newNode;
    }
}
void QuePop(Queue* pq) {
    assert(pq);
    assert(pq->head);

    QueueNode* next = pq->head->next;
    free(pq->head);
    pq->head = next;
    if (pq->head == NULL) {
        // tail   head == NULL，删除的过程中，删除到最后一个的时候需要将tail置空
        pq->tail = NULL;
    }
}
dataType QueFront(Queue* pq) {
    assert(pq);
    assert(pq->head);
    return pq->head->data;
}
dataType QueBack(Queue* pq) {
    assert(pq);
    assert(pq->tail);
    return pq->tail->data;
}
int isEmpty(Queue* pq) {
    assert(pq);
    if (pq->head == NULL) {
        return 1;
    } else {
        return 0;
    }
}
int QueSize(Queue* pq) {
    assert(pq);
    QueueNode* curr = pq->head;
    int size = 0;
    while (curr) {
        curr = curr->next;
        size++;
    }
    return size;
}
// 内部使用两个队列即可
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

MyStack* myStackCreate() {
    MyStack* stk = (MyStack*)malloc(sizeof(MyStack));
    // 两个队列初始化
    QueInit(&stk->q1);
    QueInit(&stk->q2);
    return stk;
}

void myStackPush(MyStack* obj, int x) {
    if (!isEmpty(&obj->q1)) // 哪个队列不为空就进去
    {
        QuePush(&obj->q1, x);
    } else {
        QuePush(&obj->q2, x);
    }
}

int myStackPop(MyStack* obj) {
    // 默认q1为空
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;
    if(isEmpty( &obj->q2))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }
    while(QueSize(nonempty) > 1)
    {
        QuePush(empty,QueFront(nonempty));
        QuePop(nonempty);
    }
    // 此时nonemty的队列就剩1个
    int ret = nonempty->head->data;
    QuePop(nonempty);
    return ret;
}

int myStackTop(MyStack* obj) {
    if (!isEmpty(&obj->q1)) {

        return obj->q1.tail->data;
    } else {

        return obj->q2.tail->data;
    }
}

bool myStackEmpty(MyStack* obj) {
    if (isEmpty(&obj->q1) == 1 && isEmpty(&obj->q2) == 1) {
        return true;
    } else {
        return false;
    }
}

void myStackFree(MyStack* obj) {
    QueDestroy(&obj->q1);
    QueDestroy(&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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

复制代码 
输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

分析：

这里可以用两个栈来实现队列，stk1、stk2。

入队：stk1用来压入数据，每次进队列的时候可以直接将数据放入stk1中。

出队：将stk1进行出栈，每一次出栈的元素再入栈到stk2，这样我们发现元素就会进行逆置，此时再出栈stk2就把队列的第一个元素就删除了。

peek：和出队类似，不过这里只是把stk2的栈顶元素进行返回而不是删除。

判空：判断两个栈均不为空。

复用：peek的本质是将stk1的内容转移到stk2，返回stk2的栈顶元素，所以出队的时候可以先调用peek，将stk2的首元素保存，然后再弹出stk2的栈顶元素，最后返回保存的stk2的之前的栈顶元素。

释放内存：先释放两个栈，再free队列。

代码：

cpp 复制代码 
typedef int dataType;
typedef struct Stack {
    int* _a;       // 用数组来实现
    int _top;      // 栈的数据的个数、栈顶元素下表
    int _capacity; // 栈的容量
} Stack;

// 初始化
void InitStack(Stack* stk) {
    assert(stk);
    stk->_a = malloc(sizeof(dataType) * 4);
    stk->_capacity = 4;
    stk->_top = 0; // 栈顶元素下标为0
}
// 销毁
void DestroyStack(Stack* stk) {
    assert(stk);
    free(stk->_a);
    stk->_a = NULL;
    stk->_capacity = stk->_top = 0;
}
// 入栈
void PushStack(Stack* stk, dataType x) {
    assert(stk);
    if (stk->_capacity == stk->_top) // 容量和栈元素个数相等，就扩容
    {
        stk->_capacity *= 2;
        dataType* tmp =
            (dataType*)realloc(stk->_a, sizeof(dataType) * stk->_capacity);
        if (tmp == NULL) {
            printf("内存不足！");
            exit(-1);
        } else {
            stk->_a = tmp;
        }
    }
    // 正常插入
    stk->_a[stk->_top] = x;
    stk->_top++;
}
// 出栈
void PopStack(Stack* stk) {
    assert(stk);
    assert(stk->_top > 0); // 有元素才能删除
    stk->_top--;
}
// 栈的元素个数
int SizeStack(Stack* stk) {
    assert(stk);
    return stk->_top;
}
// 栈是否为空
int isEmpty(Stack* stk) {
    assert(stk);
    return stk->_top == 0 ? 1 : 0; // 没有元素就是空
}
// 获取栈顶数据
dataType getTop(Stack* stk) {
    assert(stk);
    if (stk->_top > 0) {
        return stk->_a[stk->_top - 1];
    } else {
        return -1;
    }
}

typedef struct {
    // 两个栈
    Stack stk1;
    Stack stk2;

} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* ret = (MyQueue*)malloc(sizeof(MyQueue));
    InitStack(&ret->stk1);
    InitStack(&ret->stk2);
    return ret;
}

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


int myQueuePeek(MyQueue* obj) {
    if(!isEmpty(&obj->stk2))
    {
        return getTop(&obj->stk2);// stk2有值就说明，stk1一定没有值，已经转换完毕
    }
     while (!isEmpty(&obj->stk1)) 
     {
        PushStack(&obj->stk2, getTop(&obj->stk1));
        PopStack(&obj->stk1);
     }
    
    int ret = getTop(&obj->stk2);
    return ret;
}

int myQueuePop(MyQueue* obj) {
    
   
    int ret = myQueuePeek(obj); //把stk1所有元素导入到stk2
    PopStack(&obj->stk2);
    return ret;
}



bool myQueueEmpty(MyQueue* obj) {
    if (isEmpty(&obj->stk1) && isEmpty(&obj->stk2)) {
        return true;
    } else {
        return false;
    }
}

void myQueueFree(MyQueue* obj) {
    DestroyStack(&obj->stk1);
    DestroyStack(&obj->stk2);
    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（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为"环形缓冲器"。

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

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

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

示例：

复制代码 
MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4

思路：

此题使用数组进行实现，使用两个指针，一个指针是rear，当插入数据的时候需要后移指针，一个指针是front，当删除一个数据的时候，需要后移指针，这样一来就会出现问题：

①当循环队列为空的时候：rear == front：

②当删除、增加几个元素的时候，此时rear == front

也就是说没有办法确定当rear和front相等的时候，此时是队列满还是队列空。

解决方法：

多留一个位置，例如如果队列是4个位置，那么实际上要开辟5个位置：

此时（rear + 1） % 实际长度 == front的下标（即1），说明此时的队列是满的；

如果rear == front说明此时队列是空的。

如此以来就区分了当指针相同的时候遇到的两种情况，注意这里的空，并不是一个固定的位置。

这里的首尾相接是这么处理的：当front或者rear走到数组的末端，需要向下继续走的时候，这时候会跳转到数组的首位（通过%数组的真实长度实现）。

代码：

定义循环队列结构体：

int数组a，头结点的下标front，尾结点的下标rear，实际的数据个数k；

cpp 复制代码 
typedef struct {
    // 定义堆上的数组，头指针尾指针
    int* a;
    int front;
    int rear;
    int k;
} MyCircularQueue;

初始化结构体对象：

对于a来说：需要k+1个int的空间，这里需要多出一个空间什么也不存放，具体理由已经在上面分心过了；

对于front和rear来说：全部置为0，此时rear == front说明此时没有一个元素；

**对于k来说：**由于形参传入k，所以直接将形参的k赋值即可。

cpp 复制代码 
// k是实际存储的数据个数
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* ret = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    ret->a = (int*)malloc(sizeof(int) * (k + 1)); // 多开一个
    ret->front = 0;
    ret->rear = 0;
    ret->k = k;
    return ret;
}

判断双向队列是否为空

如果rear == front就是空，返回true，不然返回false。

cpp 复制代码 
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->rear == obj->front;
}

判断双向队列是否是满的

如果（rear + 1）% （k+1） == front说明是满的。这是因为rear只会指向那个空的空间，如果再+1就直接指向front说明数组是满的。

cpp 复制代码 
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear + 1) % (obj->k + 1) == obj->front;
}

双向队列入队

首先使用上面定义的方法如果队列已满，就直接返回false；

如果队列没有满，那么就对a数组下标为rear的地方插入元素，并且将rear后移一位，后移的时候，rear有可能越界，此时需要将rear进行%（k+1），使其落在k+1上面。

cpp 复制代码 
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj)) // 满了就不能插入
    {
        return false;
    }
    // 不满就在rear处增加数据
    obj->a[obj->rear] = value;
    obj->rear++; // 若此时超出k+1，需要进行修正到k+1之内
    obj->rear %= (obj->k + 1);
    return true;
}

双向队列出队

首先使用上面定义的方法判断数组是空的话，就直接返回false；

如果队列不为空，此时直接将front后移一位即可，此时也需要注意越界的问题，这里将front+1之后进行%（k+1）即可。

cpp 复制代码 
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj)) {
        return false; // 队列为空就删除失败
    }
    // 删除队列移动front
    obj->front++;
    obj->front %= (obj->k + 1);
    return true;
}

获取头指针的元素

直接返回a数组下标为front的元素即可。

获取最后一个元素

若此时链表不为空的情况下，rear始终指向不存放数据的那个空间：

所以此时只需要访问rear-1下标的数据即可，那么有一个特殊情况需要处理，当rear为0的时候，rear-1会发生越界，这里需要单独判断，当rear=0的时候，此时需要返回下标为k的元素（最后一个）。

cpp 复制代码 
int myCircularQueueRear(MyCircularQueue* obj) {
    // 获取队尾数据，队列为空，返回-1
    if (myCircularQueueIsEmpty(obj)) {
        return -1;
    } else {
        if (obj->rear == 0) {
            return obj->a[obj->k]; // 小坑，若rear此时为0，此处越界
        } else {
            return obj->a[obj->rear - 1]; // 正常就直接取值
        }
    }
}

内存清空

先清空结构体内的数组，在清空结构体

cpp 复制代码 
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}
热门推荐
01UV安装并设置国内源02全球最强模型Grok4，国内已可免费使用！（附教程）03Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code04[已解决]VSCode右键菜单消失恢复05🚀Cursor CLI+GPT-5保姆级教程+编程能力测评！Cursor CLI零成本免费使用GPT-5！Claude Code的劲敌来了！从安装到实战演示06GPT-5 使用限制与国内升级全攻略（免费 / Plus / Pro）【2025 最新】07KGG转MP3工具|非KGM文件|解密音频082025最新国内服务器可用docker源仓库地址大全（2025年8月更新）09OpenAI重返开源！GPT-OSS本地部署完全指南10Cursor 终端“卡死/无响应”问题的解法