[数据结构]有些事不见不知道——栈和队列刷题：有效的括号、用栈实现队列、用队列实现栈、循环队列

最新推荐文章于 2024-07-09 18:04:44 发布

Елена_

最新推荐文章于 2024-07-09 18:04:44 发布

阅读量1.3k

点赞数 84

分类专栏：每天刷题，快乐到家。 C语言入土之路文章标签： c语言数据结构栈和队列

本文链接：https://blog.csdn.net/m0_62945323/article/details/124335902

版权

C语言入土之路同时被 2 个专栏收录

18 篇文章 2 订阅

订阅专栏

每天刷题，快乐到家。

10 篇文章 0 订阅

订阅专栏

人见人爱目录君

有效的括号
- 分析时间
- 代码
用栈实现队列
用队列实现栈
设计循环队列
一些栈和队列的选择题
最后

菜鸡大学生的数据结构——刷题篇5

磕磕绊绊终于到了栈和队列，菜鸡大学生在水完一篇文章之后心情极佳鸡血上头，决定对栈和队列的题目进行一波制裁。

结果痛心地发现栈和队列这些数据结构c语言是没有现成的库的，它们的代码还得自己手敲一遍，遂，cv。

有效的括号

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

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

分析时间

经常看我博客的好兄弟们肯定知道，菜鸡大学生的做题习惯是先给出大概思路之后再写题。

这题该这么盘呢？

我们康康示例，发现右括号一定要与最近的左括号匹配起来。
那么我们可以把左括号存到栈里面，遇到右括号就进行匹配，成功就出栈，失败就返回false。

好——

特殊情况时间：

一开始就是右括号栈为空导致出错。
左右括号数量不对等。

解决方案：

遇到右括号先判断栈是不是空。
最后判断栈是不是空。

代码

栈的代码可以去之前博客自取——

bool isValid(char * s){
    ST st;
    StackInit(&st);
    char* cur=s;
    while(*cur)
    {
        if((*cur=='(')||(*cur=='[')||(*cur=='{'))
        {
            StackPush(&st,*cur);
            ++cur;
        }
        else
        {
            if(StackEmpty(&st))
                return false;
            char top=StackTop(&st);
            if((*cur==')'&&top=='(')||(*cur==']'&&top=='[')||(*cur=='}'&&top=='{'))
            {
                StackPop(&st);
                ++cur;
            }
            else
            {
                StackDestory(&st);
                return false;
            }
        }
    }
    if(StackEmpty(&st))
    {
        StackDestory(&st);
        return true;
    }
    else
    {
        StackDestory(&st);
        return false;
    }
}

用栈实现队列

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

实现 MyQueue 类：

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

在写这道题的时候我们先把这个队列准备好：

typedef struct {
   ST pushST;
   ST popST;
} MyQueue;

然后是初始化，只要把这俩栈分别初始化就行。

MyQueue* myQueueCreate() {
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));

    assert(obj);
	
    StackInit(&obj->pushST);
    StackInit(&obj->popST);

    return obj;
}

接着是push和pop。
这俩玩意怎么写呢？

push的话我们只要把数据放到pushST里面，pop的时候如果popST为空，就把pushST里面的数据全部放到popST里面。
此时popST里面的数据正好是颠倒的，只要向后依次出数据就好了。

不为空就直接出数据。

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);

    StackPush(&obj->pushST,x);
}

int myQueuePop(MyQueue* obj) {
    assert(obj);

    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }

    int front=StackTop(&obj->popST);
    StackPop(&obj->popST);

    return front;
}

peek就更简单了。
就是pop的简化版本。
复制粘贴大法好。

int myQueuePeek(MyQueue* obj) {
    assert(obj);

    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }

    int front=StackTop(&obj->popST);

    return front;
}

empty呢？
两个栈都是空就表示队列是空。

bool myQueueEmpty(MyQueue* obj) {
    assert(obj);

    return StackEmpty(&obj->popST)&&StackEmpty(&obj->pushST);
}

最后的free函数。
先free两个栈，最后free掉队列。

void myQueueFree(MyQueue* obj) {
    assert(obj);

    StackDestory(&obj->popST);
    StackDestory(&obj->pushST);

    free(obj);
}

解决！

用队列实现栈

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

实现 MyStack 类：

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

是差不多的题目呢。
那么，先建栈吧。

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

MyStack* myStackCreate() {
    MyStack* obj=(MyStack*)malloc(sizeof(MyStack));

    assert(obj);
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);

    return obj;
}

push到空队列里面去，原因在pop里面讲。

void myStackPush(MyStack* obj, int x) {
    assert(obj);
    
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

开始pop：
我们要先把非空的队列里面的内容放到空队列里面去，直到剩下最后一个。
然后直接把最后一个push出去就好。

看图更好理解一些：>

int myStackPop(MyStack* obj) {
    assert(obj);

    Queue* emptyq=&obj->q1;
    Queue* nonemptyq=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyq=&obj->q2;
        nonemptyq=&obj->q1;
    }

    while(QueueSize(nonemptyq)>1)
    {
        QueuePush(emptyq,QueueFront(nonemptyq));
        QueuePop(nonemptyq);
    }

    int ret=QueueFront(nonemptyq);
    QueuePop(nonemptyq);
    return ret;
}

栈顶直接返回非空队列的队尾就好。

int myStackTop(MyStack* obj) {
    assert(obj);
    
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

剩下的操作和上一题是一样的。

bool myStackEmpty(MyStack* obj) {
    assert(obj);

    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    assert(obj);

    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);

    free(obj);
}

好耶！

设计循环队列

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

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

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

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

喜闻乐见的分析环节

为了能使tail==front能够区分是空队列还是满队列，我们一般会开辟k+1个空间。

此时

空队列就是tail==front，满队列就是tail+1=front。
添加tail就往前走一步，删除front就往前走一步。

画图真的能看的很清楚，我感觉都不需要讲什么了hh。

代码实现

数组版本

有了之前的思路我们就可以写代码了。
我们一个函数一个函数写。

循环队列本体以及初始化，
很多都是之前写过的~

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

MyCircularQueue* myCircularQueueCreate(int k) {
   MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));

   obj->arr=(int*)malloc(sizeof(int)*(k+1));
   obj->k=k;
   obj->front=obj->tail=0;

   return obj;
}

插入和修改：
和图片描述的差不多，但是要注意数组这玩意不是循环的，
当tail为k时，增加数据要手动把tail改成0,front同理。
也不要忘了判断一下队列是不是空/满。

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
        return false;

    obj->arr[obj->tail]=value;
    if(obj->tail==obj->k)
    {
        obj->tail=0;
    }
    else
    {
        obj->tail++;
    }
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return false;

    if(obj->front==obj->k)
    {
        obj->front=0;
    }
    else
    {
        obj->front++;
    }
    return true;
}

队头队尾元素，插入删除的青春版。
对头元素直接返回。
队尾元素返回tail的前一个，
如果tail在第一个位置说明队尾元素在最后一个。

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;

    return obj->arr[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;

    if(obj->tail==0)
    {
        return obj->arr[obj->k];
    } 
    else
    {
        return obj->arr[obj->tail-1];
    }
}

空和满分析有讲。
不谈。

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    if(obj->tail==obj->k&&obj->front==0)
    {
        return true;
    }
    else
    {
        return obj->front==obj->tail+1;
    }
}

销毁。

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

链表版本

大体思路和数组差不多，但是比数组复杂一些。

本体以及初始化：
复杂了许多。
由于链表之间是不连续的，所以我们要存下链表的头和尾位置。

typedef struct SListNode{
    int data;
	struct SListNode* next;
	struct SListNode* prev;
}SListNode;

typedef struct {
    SListNode * SList;
    SListNode * front;
    SListNode * tail;
    SListNode * SLfront;
    SListNode * SLtail;
} MyCircularQueue;

初始化我们要建好一整个完整的双链表，该连的都要连上。
一开始SLfront，front和tail都在第一个节点。
SLtail在最后一个节点。
为了方便里面的值随便赋个0吧。

//建立新节点
SListNode* BuySListNode(int x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	newnode->data = x;
	newnode->next = newnode;
	newnode->prev = newnode;
	return newnode;
}

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* newnode=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    SListNode* head=BuySListNode(0);
    
    newnode->SList=head;
    newnode->front=head;
    newnode->tail=head;
    newnode->SLfront=head;

    SListNode* cur=head;

    for(int i=0;i<k;i++)
    {
        SListNode* node=BuySListNode(0);
        cur->next=node;
        node->prev=cur;
        cur=node;
    }

    cur->next=head;
    head->prev=cur;
    
    newnode->SLtail=cur;

    return newnode;
}

插入删除队头队尾空满函数和数组版本是一个道理，不细讲。

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
 if(myCircularQueueIsFull(obj))
        return false;

    obj->tail->data=value;
    if(obj->tail->next==obj->SLfront)
    {
        obj->tail=obj->SLfront;
    }
    else
    {
        obj->tail=obj->tail->next;
    }
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return false;

    if(obj->front->next==obj->SLfront)
    {
        obj->front=obj->SLfront;;
    }
    else
    {
        obj->front=obj->front->next;
    }
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
  if(myCircularQueueIsEmpty(obj))
        return -1;

    return obj->front->data;
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;

    if(obj->tail==obj->SLfront)
    {
        return obj->SLtail->data;
    } 
    else
    {
        return obj->tail->prev->data;
    }
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
  if(obj->tail==obj->SLtail&&obj->front==obj->SLfront)
    {
        return true;
    }
    else
    {
        return obj->front==obj->tail->next;
    }
}

销毁函数，由于是链表还得专门写个链表销毁函数…
啊——为什么不用数组呢，好麻烦。

void ListDestory(SListNode* phead)
{
	assert(phead);

	SListNode* cur = phead->next;
	SListNode* next = cur->next;
	while (next!=phead)
	{

		free(cur);
		cur = next;
		next = next->next;
	}
	free(cur);
	free(phead);
    phead=NULL;
}

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

一些栈和队列的选择题

一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（）。
A. 12345ABCDE
B. EDCBA54321
C. ABCDE12345
D. 54321EDCBA

栈的特点是后进先出，怎么入的就倒着出，选B。

若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A. 1,4,3,2
B. 2,3,4,1
C. 3,1,4,2
D. 3,4,2,1

A选项，1入栈，1出栈，2，3，4入栈，4，3，2出栈，可以。
B选项，1，2入栈，2出栈，3入栈，3出栈，4入栈，4出栈，1出栈，可以。
C选项，1，2，3入栈，3出栈，由于2还没有出栈，1不可能出栈，错误。
D选项，1，2，3入栈，3出栈，4入栈，4出栈，2，1出栈，可以。

循环队列的存储空间为 Q(1:100) ，初始状态为 front=rear=100 。经过一系列正常的入队与退队操作
后， front=rear=99 ，则循环队列中的元素个数为（）
A. 1
B. 2
C. 99
D. 0或者100

front=rear,有可能是满队列也可能是空队列，选D。

以下( )不是队列的基本运算？
A. 从队尾插入一个新元素
B. 从队列中删除第i个元素
C. 判断一个队列是否为空
D. 读取队头元素的值

这道题不会的建议看一下队列的概念，选B。

现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N。其队内有效长度为？(假设队头不存放数据)
A. (rear - front + N) % N + 1
B. (rear - front + N) % N
C. (rear - front) % (N + 1)
D. (rear - front + N) % (N - 1)

遇到这种题目怎么办？举个栗子吧！

我们可能遇见这两种情况： rear在前或者front在前。
先带几个数字试试看，再来推一下公式：(rear - front + N) % N
选B。

最后

这周的画。
画图工作量明显少了，挺高兴的。

队列终于结束辣，下面就是二叉树惹！
其实不是，先出十大排序。

Елена_

关注

84
点赞
踩
50

收藏

觉得还不错? 一键收藏
打赏
131
评论
[数据结构]有些事不见不知道——栈和队列刷题：有效的括号、用栈实现队列、用队列实现栈、循环队列

人见人爱目录君有效的括号分析时间代码用栈实现队列用队列实现栈设计循环队列喜闻乐见的分析环节代码实现数组版本链表版本一些栈和队列的选择题最后菜鸡大学生的数据结构——刷题篇5磕磕绊绊终于到了栈和队列，菜鸡大学生在水完一篇文章之后心情极佳鸡血上头，决定对栈和队列的题目进行一波制裁。结果痛心地发现栈和队列这些数据结构c语言是没有现成的库的，它们的代码还得自己手敲一遍，遂，cv。有效的括号给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。有效字符串需满足
复制链接

扫一扫