【数据结构与算法】之四道关于栈和队列的经典题型

微软技术分享 微软全球最有价值专家
全栈领域优质创作者
博客专家认证
2025-01-23 20:39:26

1、有效的括号

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

有效字符串需满足:

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

示例 1:
输入:s = "()"
输出:true

示例 2:
输入:s = "()[]{}"
输出:true

示例 3:
输入:s = "(]"
输出:false

提示:

  • 1 <= s.length <= 104
    
  • s 仅由括号 '()[]{}' 组成

OJ链接

** 解题代码:**

// 支持动态增长的栈
typedef char STDataType;

typedef struct Stack
{
    STDataType* a;
    int top;        // 栈顶
    int capacity;  // 容量 
}Stack;

// 初始化栈 
void StackInit(Stack* ps);

// 入栈 
void StackPush(Stack* ps, STDataType data);

// 出栈 
void StackPop(Stack* ps);

// 获取栈顶元素 
STDataType StackTop(Stack* ps);

// 获取栈中有效元素个数 
int StackSize(Stack* ps);

// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0 
bool StackEmpty(Stack* ps);

// 销毁栈 
void StackDestroy(Stack* ps);

// 初始化栈 
void StackInit(Stack* ps)
{
    assert(ps);
    ps->a=NULL;
    ps->top = 0;
    ps->capacity = 0;
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
    assert(ps);
    //判断是否需要扩容
    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)
        {
            perror("realloc fail");
            return;
        }
        ps->a = tmp;
        ps->capacity = newCapacity;
    }
    //入栈
    ps->a[ps->top++] = data;
}

// 出栈 
void StackPop(Stack* ps)
{
    assert(ps);
    assert(ps->top > 0);
    ps->top--;
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
    assert(ps);
    assert(ps->top > 0);
    return ps->a[ps->top - 1];
}

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
    assert(ps);
    return ps->top;
}

// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0 
bool StackEmpty(Stack* ps)
{
    assert(ps);
    return ps->top == 0;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
    assert(ps);
    ps->capacity = 0;
    ps->top = 0;
    free(ps->a);
    ps->a = NULL;
}

bool isValid(char* s) {
    Stack st;
    StackInit(&st);
    while(*s)
    {
        if((*s)=='('||(*s)=='['||(*s)=='{')
        {
            StackPush(&st,*s);
        }
        else
        {
            if(StackEmpty(&st))
            {
                StackDestroy(&st);
                return false;
            }
            char top=StackTop(&st);
            StackPop(&st);
            if(top=='('&&((*s)!=')')||
               top=='['&&((*s)!=']')||
               top=='{'&&((*s)!='}'))
            {
                StackDestroy(&st);
                return false;
            }
        }
        s++;
    }
    bool ret=StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}

2、用队列实现栈

请你仅使用两个队列实现一个后入先出(LIFO)的栈,并支持普通栈的全部四种操作(pushtoppop 和 empty)。

实现 MyStack 类:

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

注意:

  • 你只能使用队列的标准操作 —— 也就是 push to backpeek/pop from frontsize 和 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

提示:

  • 1 <= x <= 9
    
  • 最多调用100 次 pushpoptop 和 empty

  • 每次调用 pop 和 top 都保证栈不为空

进阶:你能否仅用一个队列来实现栈。

OJ链接

**解题代码: **

typedef int QDataType;

// 链式结构:表示队列 
typedef struct QListNode
{
    struct QListNode* next;
    QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
    QNode* head;
    QNode* tail;
    int size;
}Queue;

// 初始化队列 
void QueueInit(Queue* q)
{
    assert(q);
    q->head = q->tail = NULL;
    q->size = 0;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
    assert(q);
    QNode* newNode = (QNode*)malloc(sizeof(QNode));
    if (newNode == NULL)
    {
        perror("malloc fail!\n");
        return;
    }
    newNode->data = data;
    newNode->next=NULL;
    if (q->head == NULL)
    {
        q->head = q->tail = newNode;
    }
    else//尾插
    {
        q->tail->next = newNode;
        q->tail = newNode;
    }
    q->size++;
}

// 队头出队列 
void QueuePop(Queue* q)
{
    assert(q);
    assert(q->size > 0);//有数据才进行删除
    if (q->head == q->tail)
    {
        free(q->head);
        q->head = q->tail = NULL;
    }
    else
    {
        QNode* del = q->head;
        q->head = q->head->next;
        free(del);
        del = NULL;
    }
    q->size--;
}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
    assert(q);
    assert(q->size > 0);
    return q->head->data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
    assert(q);
    assert(q->size > 0);
    return q->tail->data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
    assert(q);
    return q->size;
}

// 检测队列是否为空
bool QueueEmpty(Queue* q)
{
    assert(q);
    return q->size == 0;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
    assert(q);
    QNode* cur = q->head;
    while (cur)
    {
        QNode* next = cur->next;
        free(cur);
        cur = next;
    }
    q->head = q->tail = NULL;
    q->size = 0;
}


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


MyStack* myStackCreate() {
    MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
    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);
    }
    //将不为空的队列中的前size-1个数据导入到空队列中
    while(QueueSize(nonEmpty)>1)
    {
        QDataType top=QueueFront(nonEmpty);//取队头元素
        QueuePop(nonEmpty);//取完出队列
        QueuePush(empty,top);//将取出的队头元素导入到空队列中
    }
    QDataType top=QueueFront(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、用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(pushpoppeekempty):

实现 MyQueue 类:

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

说明:

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to toppeek/pop from topsize, 和 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

提示:

  • 1 <= x <= 9
    
  • 最多调用 100 次 pushpoppeek 和 empty

  • 假设所有操作都是有效的 (例如,一个空的队列不会调用 pop 或者 peek 操作)

进阶:

  • 你能否实现每个操作均摊时间复杂度为 O(1) 的队列?换句话说,执行 n 个操作的总时间复杂度为 O(n) ,即使其中一个操作可能花费较长时间

OJ链接

**解题代码: **

// 支持动态增长的栈
typedef int STDataType;

typedef struct Stack
{
    STDataType* a;
    int top;        // 栈顶
    int capacity;  // 容量 
}Stack;

// 初始化栈 
void StackInit(Stack* ps);

// 入栈 
void StackPush(Stack* ps, STDataType data);

// 出栈 
void StackPop(Stack* ps);

// 获取栈顶元素 
STDataType StackTop(Stack* ps);

// 获取栈中有效元素个数 
int StackSize(Stack* ps);

// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0 
bool StackEmpty(Stack* ps);

// 销毁栈 
void StackDestroy(Stack* ps);

// 初始化栈 
void StackInit(Stack* ps)
{
    assert(ps);
    ps->a=NULL;
    ps->top = 0;
    ps->capacity = 0;
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
    assert(ps);
    //判断是否需要扩容
    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)
        {
            perror("realloc fail");
            return;
        }
        ps->a = tmp;
        ps->capacity = newCapacity;
    }
    //入栈
    ps->a[ps->top++] = data;
}

// 出栈 
void StackPop(Stack* ps)
{
    assert(ps);
    assert(ps->top > 0);
    ps->top--;
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
    assert(ps);
    assert(ps->top > 0);
    return ps->a[ps->top - 1];
}

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
    assert(ps);
    return ps->top;
}

// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0 
bool StackEmpty(Stack* ps)
{
    assert(ps);
    return ps->top == 0;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
    assert(ps);
    ps->capacity = 0;
    ps->top = 0;
    free(ps->a);
    ps->a = NULL;
}


typedef struct {
    Stack pushStack;
    Stack popStack;
} MyQueue;


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

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

int myQueuePop(MyQueue* obj) {
    int top=myQueuePeek(obj);
    StackPop(&(obj->popStack));
    return top;
}

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&(obj->popStack)))
    {
        while(!StackEmpty(&(obj->pushStack)))
        {
            STDataType top=StackTop(&(obj->pushStack));
            StackPop(&(obj->pushStack));
            StackPush(&(obj->popStack),top);
        }
    }
    return StackTop(&(obj->popStack));
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&(obj->pushStack))&&StackEmpty(&(obj->popStack));
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&(obj->pushStack));
    StackDestroy(&(obj->popStack));
    free(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

提示:

  • 所有的值都在 0 至 1000 的范围内;
  • 操作数将在 1 至 1000 的范围内;
  • 请不要使用内置的队列库。

OJ链接

**解题代码: **

typedef struct {
    int* a;
    int head;
    int tail;
    int size;//固定大小
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head==obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->tail+1)%(obj->size+1)==obj->head;
}

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

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

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->head++;
    (obj->head)%=(obj->size+1);
    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;
    }
    return obj->a[(obj->tail-1+obj->size+1)%(obj->size+1)];
}


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

文章来源: https://blog.csdn.net/2301_80221228/article/details/138809070
版权声明: 本文为博主原创文章,遵循CC 4.0 BY-SA 知识共享协议,转载请附上原文出处链接和本声明。


...全文
59 回复 打赏 收藏 转发到动态 举报
写回复
用AI写文章
回复
切换为时间正序
请发表友善的回复…
发表回复

3,166

社区成员

发帖
与我相关
我的任务
社区描述
微软技术社区为中国的开发者们提供一个技术干货传播平台,传递微软全球的技术和产品最新动态,分享各大技术方向的学习资源,同时也涵盖针对不同行业和场景的实践案例,希望可以全方位地帮助你获取更多知识和技能。
windowsmicrosoft 企业社区
社区管理员
  • 微软技术分享
  • 郑子铭
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告

微软技术社区为中国的开发者们提供一个技术干货传播平台,传递微软全球的技术和产品最新动态,分享各大技术方向的学习资源,同时也涵盖针对不同行业和场景的实践案例,希望可以全方位地帮助你获取更多知识和技能。

予力众生,成就不凡!微软致力于用技术改变世界,助力企业实现数字化转型。

试试用AI创作助手写篇文章吧