刷题笔记(栈和队列篇)(跑路人笔记)2

简介: 刷题笔记(栈和队列篇)(跑路人笔记)

用队列实现栈

用队列实现栈.

其实和用栈实现队列及其的相似🐱‍🐉.能看懂第一题的可以用这道题来试验一下自己的学习成功.

用队列实现栈相对用栈实现队列要效率低一些.

大致思路

通过两个队列来实现栈.

队列实现栈.

队列打入顺序为

12345时读取数据时12345

但是我们的栈要的顺序是54321.

两个队列时我们用和上一题同样的思路是不行的.

但是我们可以留下一个数据比如

p1存放12345.

p2存放:无.

将p1的元素的除最后一个元素放入到p2中

操作后如下

p1: 5

p2: 1234

然后我们将p1的值给出就可👍.


队列的代码

typedef int QDatetype;
typedef struct QueueNode
{
  int date;
  struct QueueNode* next;
}QNode;
typedef struct Queue
{
  QNode* head;
  QNode* tail;
}Queue;
void QueueInit(Queue* pq)
{
  assert(pq);
  pq->head = pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
  assert(pq);
  QNode* cur = pq->head;
  while (cur)
  {
    QNode* next = cur->next;
    free(cur);
    cur = next;
  }
  pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq,QDatetype x)
{
  if (pq->tail == NULL)
  {
    pq->head = pq->tail = (QNode*)malloc(sizeof(QNode));
    if (pq->tail == NULL)
    {
      exit(-1);
    }
    pq->head->date = x;
    pq->tail->next = NULL;
  }
  else
  {
    QNode* tail = pq->tail;
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
      printf("ʧ\n");
      exit(-1);
    }
    newnode->date = x;
    newnode->next = NULL;
    tail->next = newnode;
    pq->tail = newnode;
  }
}
void QueuePop(Queue* pq)
{
  assert(pq);
  if (pq->head == pq->tail)
  {
    free(pq->head);
    pq->head = pq->tail = NULL;
  }
  else
  {
    QNode* next = pq->head->next;
    free(pq->head);
    pq->head = next;
  }
}
bool QueueEmpty(Queue* pq)
{
  assert(pq);
  return pq->head == NULL;
}
size_t QueueSize(Queue* pq)
{
  assert(pq);
  QNode* cur = pq->head;
  size_t size = 0;
  while (cur)
  {
    size++;
    cur = cur->next;
  }
  return size;
}
QDatetype QueueFront(Queue* pq)
{
  assert(pq);
  assert(pq->head);
  return pq->head->date;
}
QDatetype QueueBack(Queue* pq)
{
  assert(pq);
  assert(pq->tail);
  return pq->tail->date;
}

这部分是我手搓的队列,用不习惯的可以改改👍.

正确代码

typedef struct 
{
    Queue p1;
    Queue p2;
} MyStack;
MyStack* myStackCreate() 
{
    MyStack* ST = (MyStack*)malloc(sizeof(MyStack));
    assert(ST);
    QueueInit(&ST->p1);
    QueueInit(&ST->p2);
    return ST;
}
void myStackPush(MyStack* obj, int x) 
{
    if(!QueueEmpty(&obj->p1))
    {
        QueuePush(&obj->p1,x);
    }
    else
    {
        QueuePush(&obj->p2,x);
    }
}
int myStackPop(MyStack* obj)
{
    Queue* empty = &obj->p1;
    Queue* nonEmpty = &obj->p2;
    if(!QueueEmpty(empty))
    {
        empty = &obj->p2;
        nonEmpty = &obj->p1;
    }
    while(QueueSize(nonEmpty)>1)
    {
        int num = QueueFront(nonEmpty);
        QueuePush(empty,num);
        QueuePop(nonEmpty);
    }
    int ret = QueueFront(nonEmpty);
    QueuePop(nonEmpty);
    return ret;
}
int myStackTop(MyStack* obj) 
{
    if(!QueueEmpty(&obj->p1))
    {
       return QueueBack(&obj->p1);
    }
    else
    {
        return QueueBack(&obj->p2);
    }
}
bool myStackEmpty(MyStack* obj) 
{
    if(QueueEmpty(&obj->p1)&&QueueEmpty(&obj->p2))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
void myStackFree(MyStack* obj) 
{
    QueueDestory(&obj->p1);
    QueueDestory(&obj->p2);
    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);
*/

函数思想讲解和注意事项

typedef struct 
{
    Queue p1;
    Queue p2;
} MyStack;
MyStack* myStackCreate() 
{
    MyStack* ST = (MyStack*)malloc(sizeof(MyStack));
    assert(ST);
    QueueInit(&ST->p1);
    QueueInit(&ST->p2);
    return ST;
}

结构体

结构体里装着两个队列时设计好的结构类型.

MyStack* myStackCreate()

这个函数还是简单的初始化两个队列和结构体的栈类型变量的实现

void myStackPush(MyStack* obj, int x) 
{
    if(!QueueEmpty(&obj->p1))
    {
        QueuePush(&obj->p1,x);
    }
    else
    {
        QueuePush(&obj->p2,x);
    }
}
int myStackPop(MyStack* obj)
{
    Queue* empty = &obj->p1;
    Queue* nonEmpty = &obj->p2;
    if(!QueueEmpty(empty))
    {
        empty = &obj->p2;
        nonEmpty = &obj->p1;
    }
    while(QueueSize(nonEmpty)>1)
    {
        int num = QueueFront(nonEmpty);
        QueuePush(empty,num);
        QueuePop(nonEmpty);
    }
    int ret = QueueFront(nonEmpty);
    QueuePop(nonEmpty);
    return ret;
}

栈的推送


推送的时候我们要保证一个队列是空的这样才能达到我们想要的目的.

所以我们用if条件句来判断那个队列不为空,不为空就将元素放到他那里这样就就可以保证一个队列是完全空的了.


为啥要保证一个队列是空的呢?

在pop的时候就知道了


原先的思路就是将有元素的队列内的除倒数第一个元素外都转移到另一个空的队列中.

然后将最后一个元素返回,再删除去最后的元素.这样我们的队列就又有一个为空了,可以循环使用下去了.

注意事项

我们要得到空和非空的队列假设是p1然后再通过if来判断是p1还是p2

记得将最后一个元素pop掉哦~.

int myStackTop(MyStack* obj) 
{
    if(!QueueEmpty(&obj->p1))
    {
       return QueueBack(&obj->p1);
    }
    else
    {
        return QueueBack(&obj->p2);
    }
}
bool myStackEmpty(MyStack* obj) 
{
    if(QueueEmpty(&obj->p1)&&QueueEmpty(&obj->p2))
    {
        return true;
    }
    else
    {
        return false;
    }
}
void myStackFree(MyStack* obj) 
{
    QueueDestory(&obj->p1);
    QueueDestory(&obj->p2);
    free(obj);
}


栈顶元素的获得

其实很简单直接看非空队列的队尾数就好👍

判断是否为空

两个队列都为空及为空,否则就不为空.

队列摧毁

将两个队列都摧毁后free掉obj即可👍.

结尾

舒文想要机器人呜呜呜呜呜呜呜呜呜呜😭😭😭😭😭

相关文章
|
4天前
栈的几个经典应用,真的绝了
文章总结了栈的几个经典应用场景,包括使用两个栈来实现队列的功能以及利用栈进行对称匹配,并通过LeetCode上的题目示例展示了栈在实际问题中的应用。
栈的几个经典应用,真的绝了
|
1天前
|
负载均衡 网络协议 安全
DKDP用户态协议栈-kni
DKDP用户态协议栈-kni
|
1天前
|
负载均衡 网络协议 安全
DPDK用户态协议栈-KNI
DPDK用户态协议栈-KNI
|
1天前
|
测试技术
【初阶数据结构篇】栈的实现(附源码)
在每一个方法的第一排都使用assert宏来判断ps是否为空(避免使用时传入空指针,后续解引用都会报错)。
|
1天前
|
测试技术
【初阶数据结构篇】队列的实现(赋源码)
首先队列和栈一样,不能进行遍历和随机访问,必须将队头出数据才能访问下一个,这样遍历求个数是不规范的。
【数据结构】栈和队列
【数据结构】栈和队列
|
6天前
|
算法 C语言 C++
【practise】栈的压入和弹出序列
【practise】栈的压入和弹出序列
|
6天前
|
C语言
用栈实现将一个十进制数值转换成八进制数值。即用该十进制数值除以8,并保留其余数;重复此操作,直到该十进制数值为0为止。最后将所有的余数反向输出就是所对应的八进制数值
这篇文章展示了如何使用栈(包括顺序栈和链栈)实现将十进制数值转换成八进制数值的方法,通过C语言编程演示了两种栈的实现方式和使用场景。
用栈实现将一个十进制数值转换成八进制数值。即用该十进制数值除以8,并保留其余数;重复此操作,直到该十进制数值为0为止。最后将所有的余数反向输出就是所对应的八进制数值
|
5天前
|
存储 网络协议 Linux
用户态协议栈06-TCP三次握手
用户态协议栈06-TCP三次握手
|
8天前
|
存储
数据结构——栈(Stack)
栈(Stack)是一种常见且重要的数据结构,它遵循后进先出(Last-In-First-Out, LIFO)的原则,即最后加入的元素会是第一个被移除的。
24 4