刷爆leetcode第七期

简介: 刷爆leetcode第七期

题目一 用两个栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(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 2 3 4 5

我们将这些数据迁移到另一个栈之中试试

我们可以发现 这里的数据竟然倒过来了!

那么我们取数据的顺序就变成了

1 2 3 4 5

我们发现这就刚好是跟队列删取数据的顺序一样了

所以说我们可以这样子设计这两个栈

接下来我们知道了这两个栈的基本结构了 我们来做题目试试

我们先来看第一个

第一步 初始化

我们先来看 我们创建的结构体是什么样子的

typedef struct {
    ST pushst;
    ST popst;
} MyQueue;
typedef int STDateType;
 
typedef struct Stack
{
    int* a;//存储数据的大小
    int Top;//栈顶
    int capacity;//容量大小
}ST;

这里是两个结构体的套用

MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    if(obj==NULL)
    {
        perror("malloc fail");
        return NULL;
    }
    STInit(&obj->pushst);
    STInit(&obj->popst);
    return obj;
}

要求我们这样子 返回一个指针

那么这一步很简单 我们使用动态内存开辟一块空间就好了

之后返回一个指针指向这块空间

第二步 插入

这一步我们也讲的很明白了 插入往第一个里面插

所以说我们有以下代码

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

直接这样子就可以了

第三步 删除

再来看图

我们一边取第一个栈的头元素放置到第二个栈中

一边删除第一个栈中的元素

知道第一个栈为空为止

代码表示如下

int myQueuePop(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        //倒数据
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }
    int front = STTop(&obj->popst);
    STPop(&obj->popst);
    return front;
}

第四步 返回头元素

这个很简单和删除差不多

先将所有的元素移动到第二个栈当中 返回栈的头值就可以

直接上代码

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

第五步 判断是否为空

这一步也很简单

两个都为空就是空了

直接上代码

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

第六步 释放内存

这一步要注意了!!!

我们需要先释放开辟的两个栈的内存

之后再释放我们开辟的队列的内存

代码表示如下

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


代码运行结果如下


总结

并没有什么特别的难点

写的也比较顺利

收获应该是巩固了队列和栈的基本知识

源代码

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
 
typedef int STDateType;
 
typedef struct Stack
{
    int* a;//存储数据的大小
    int Top;//栈顶
    int capacity;//容量大小
}ST;
 
void STInit(ST*ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDateType x);
void STPop(ST* ps);
int STSize(ST* ps);
bool STEmpty(ST* ps);
STDateType STTop(ST* ps);
//初始化
void STInit(ST* ps)
{
  assert(ps);
  ps->a = (STDateType*)malloc(sizeof(STDateType)*4);
  if (ps->a == NULL)
  {
    perror("malloc fail");
    return;
  }
  ps->Top = 0;//top是栈顶元素的下一个位置
  ps->capacity = 4;
}
//销毁
void STDestroy(ST* ps)
{
  assert(ps);
  free(ps->a);
  ps->capacity = 0;
  ps->Top = 0;
  ps->a = NULL;
}
//压栈
void STPush(ST* ps, STDateType x)
{
  assert(ps);
  if (ps->Top == ps->capacity)
  {
    STDateType* tmp = (STDateType*)realloc(ps->a, sizeof(STDateType) * ps->capacity * 2);
    if (tmp == NULL)
    {
      perror("realloc fail");
      return;
    }
    ps->a = tmp;
    ps->capacity *= 2;
  }
  ps->a[ps->Top] = x;
  ps->Top++;
}
//出栈
void STPop(ST* ps)
{
  assert(ps);
  assert(!STEmpty(ps));
 
   ps->Top--;
}
//个数
int STSize(ST* ps)
{
  assert(ps);
 
  return ps->Top;
}
//判断空
bool STEmpty(ST* ps)
{
  assert(ps);
 
  return ps->Top==0;
}
//栈顶的位置
STDateType STTop(ST* ps)
{
  assert(ps);
  assert(!STEmpty(ps));
 
  return ps->a[ps->Top - 1];
}
 
typedef struct {
    ST pushst;
    ST popst;
} MyQueue;
 
 
MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    if(obj==NULL)
    {
        perror("malloc fail");
        return NULL;
    }
    STInit(&obj->pushst);
    STInit(&obj->popst);
    return obj;
}
 
void myQueuePush(MyQueue* obj, int x) {
    STPush(&obj->pushst,x);
}
 
int myQueuePop(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        //倒数据
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }
    int front = STTop(&obj->popst);
    STPop(&obj->popst);
    return front;
}
 
int myQueuePeek(MyQueue* obj) {
     if(STEmpty(&obj->popst))
    {
        //倒数据
        while(!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }
    return STTop(&obj->popst);
}
 
bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
    return STEmpty(&obj->pushst)&&STEmpty(&obj->popst);
}
 
void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);
    free(obj);
    obj = NULL;
}

 

以上便是本文所有内容了,如有错误请各位大佬不吝赐教,感谢留言

目录
相关文章
|
5月前
刷爆leetcode第一期
刷爆leetcode第一期
22 1
|
5月前
刷爆leetcode第六期
刷爆leetcode第六期
18 0
|
5月前
|
测试技术 C语言
刷爆leetcode第五期
刷爆leetcode第五期
22 0
|
5月前
刷爆leetcode第八期
刷爆leetcode第八期
15 0
|
5月前
|
索引
刷爆leetcode第四期
刷爆leetcode第四期
17 0
|
5月前
刷爆leetcode第二期
刷爆leetcode第二期
26 0
|
5月前
|
索引
刷爆leetcode第三期
刷爆leetcode第三期
24 0
|
Cloud Native
【刷题日记】1037. 有效的回旋镖
本次刷题日记的第 58 篇,力扣题为:1037. 有效的回旋镖,简单
【刷题日记】1037. 有效的回旋镖
|
算法 测试技术
刷爆 LeetCode 双周赛 100,单方面宣布第一题最难
上周末是 LeetCode 第 100 场双周赛,你参加了吗?这场周赛整体没有 Hard 题,但是也没有 Easy 题。第一题国服前百名里超过一半人 wa,很少见。
124 0
刷爆leetcode第七期 0018
刷爆leetcode第七期 0018
108 0
刷爆leetcode第七期 0018