OJ题之栈和队列(C语言版)

前言

各位读者朋友们大家好！前几期我们讲完了栈和队列这两个数据结构，大家可以跳转链接回顾链接: link，这期我们来讲一下几个栈和队列的OJ题。

1. 有效括号

这是力扣的20题，链接在这：link

给定一个括号字符串，让我们判断这些括号是否匹配。像“([{}])”这样的是匹配的，而这样的“((]]”是不匹配的，那么这个题该怎么解呢？
我们使用栈这一数据结构来做。当是左括号的时候将左括号压进栈中，当遇到右括号时，我们将栈顶的左括号取出，并且将它pop掉。如果匹配就继续后续的匹配，当不能匹配成功时，就返回结束程序。
因为我们使用C语言来实现，所以我们要先写一个栈出来，然后再写要写的接口。栈的代码实现在link这个链接中，我就不再实现了。现在我们来写题目。

因为括号要匹配成功，那么肯定是成对出现的，所以我们可以先用strlen函数求出给定的字符串的长度，如果是奇数，那么就直接返回false。

int len = strlen(s);
    if(len % 2 != 0)
    {
        return false;
    }

到了这里，字符串肯定是成对的了，现在我们要开始对括号进行匹配了，因为是一整个字符串，所以我们用循环来解决，当字符串的字符是\0时，循环结束。在循环中，我们实现左括号入队列和右括号匹配的功能。

//左括号入队列
while (*s)
{
    //左括号入队列
    if (*s == '(' || *s == '[' || *s == '{')
    {
        STPush(&st, *s);
    }
    else//右括号
    {
        if (STEmpty(&st))//如果队列是空，就是')'']''}'这几种情况不会匹配成功
        {
            return false;
        }
        char ret = STTop(&st);//取栈顶的左括号
        STPop(&st);//删除栈顶的左括号
        //左括号和右括号匹配，不成功就返回false
        if (*s == ')' && ret != '(')
            return false;
        if (*s == ']' && ret != '[')
            return false;
        if (*s == '}' && ret != '{')
            return false;
    }
    s++;
}

当程序走完循环后，我们就可以return true了。但是提交后发现报错了

我们走读代码发现，提供的样例没有给我们右括号，我们写的程序也就没有进行匹配，而实际上，如果全部匹配成功的话，走完循环栈应该是空的

所以在最后，我们只需判断返回栈是否为空即可。

这个题就写完了。

二. 用队列实现栈

这是力扣的225题，链接: link

我们要实现下面这些接口，同样要我们写一个队列的数据结构，再来写下面的接口。

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

MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&(pst->q1));
    QueueInit(&(pst->q2));
    return pst;
}

栈这一数据结构是先进后出，而队列是先进先出的数据结构。要借助两个队列来实现栈，我们需要保持一个栈始终为空，来倒数据。入数据往非空的队列中入。

我们将q1中的前k-个数据倒到q2中，剩下最后一个数据也就是最后一个入队列的数据，让这个数据先出来，也就实现了栈的后进先出。

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 else结构
    if (!QueueEmpty(&obj->q1))
    {
        empty = &(obj->q2);
        nonEmpty = &(obj->q1);
    }
    while (QueueSize(nonEmpty) > 1)//将非空队列中的前K-1个数据倒到空队列中
    {
        QueuePush(empty, QueueFront(nonEmpty));
        QueuePop(nonEmpty);
    }
    int 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));
}

释放栈

我们要将q1和q2的节点也释放掉，所以直接调用队列的销毁函数

void myStackFree(MyStack* obj) {
    QueueDestroy(&(obj->q1));
    QueueDestroy(&(obj->q2));
    free(obj);
}

最后再将整个栈指向的空间释放就好了。

三. 用栈实现队列

这是力扣的232题，链接: link

这里我们要用两个栈来实现队列,栈是后进先出，队列是先进先出。

这里的两个栈我们一个用来入数据，一个用来出数据，而不是和上面队列实现栈，保持一个队列始终为空。因为数据在入pushst时是1 2 3 4，在入popst时，顺序变成了4 3 2 1，而队列入两个队列都是保持1 2 3 4的顺序不变。
这里我们要实现一下接口：

我们一一来写。

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

MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->pushst);
    STInit(&obj->popst);
    return obj;
}

对于Push我们只需向pushst中插入元素杰克，也就是直接调用STPush函数。

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

对于

• int pop() 从队列的开头移除并返回元素
• int peek() 返回队列开头的元素
• 这两个接口我们可以在一起写

先写 peek这个接口，我们只需返回popst的栈顶元素即可，但是在popst为空时，我们需要将pushst中的元素倒到popst中。

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

对于pop这个接口，我们只需返回peek接口的返回值，然后再将栈顶元素pop即可。

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

判空接口，两个栈都为空为真

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&(obj->popst)) && STEmpty(&(obj->pushst));
}

释放接口，我们要将两个栈释放掉，并且将动态申请来的obj的内存释放掉。

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);
    free(obj);
}

这样这道OJ题就过了。

四. 循环队列

这是力扣的622题，链接: link

之前队列我们是使用链表实现的，这里我们使用顺序表比链表更方便。
现在我们来实现这些接口：

typedef struct {
    int* array;
    int head;
    int tail;
    int k;
} MyCircularQueue;

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

这里我们给array开k+1个空间的原因是因为这样更方便判断队列是满是空。

当只有k个空间时，为空和满的情况都是head == tail,因为tail在超出空间大小时会回绕回来。当我们多开一块空间时，这个问题就会被解决。

因为接口需要用到判空和判满这两个接口，所以我们先来实现这两个接口：
判空很简单，只需判断head和tail是否相等即可，

根据图片分析，判满只需要判断(tail+1)%(k+1)是否和head相等即可。

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

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

现在开始写插入元素接口：我们在插入元素后将tail++即可，但是下面这种情况，我们要将tail回绕回去，因此，要将tail %= (k+1)。

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

删除数据，同样是为了规避删到尾没有回绕，我们将head %= k+1。

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

返回头部数据只需返回array[head]即可。

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->array[obj->head];
}

返回队尾数据，对于一般情况只需要返回tail-1位置处的值即可，但是对于下面情况：

我们需要返回红框中的值作为下标返回，当然也可以使用三目操作符进行条件判断。

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->array[((obj->tail - 1) + (obj->k + 1)) % (obj-> k + 1)];
    //return obj->tail==0? obj->array[k] : obj->array[obj->tail - 1];
}

释放仅需释放array和obj即可。

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

提交一下

过了！！！

结语

以上我们就讲完了栈和队列的四道OJ题，希望对大家有帮助，欢迎大家批评指正！