化栈为队及化队为栈

最新推荐文章于 2022-02-19 14:34:16 发布
最新推荐文章于 2022-02-19 14:34:16 发布
阅读量224 收藏 1
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41548145/article/details/105741060
版权

文章目录

队列的实现

思路：用链表实现队列，先定义一个结构体QNode，里面存放数据域和指针域，因为队列只在队头和队尾进行操作，可以让两个指针分别指向队头和队尾，所以再定义一个结构体Queue里面存放两个QNode结构体的指针——front和_rear，让这两个结构体一个指向链表的头一个指向尾。然后通过Queue这个结构体里面的两个指针来对队列进行各种操作。

还是上图吧

在这里插入图片描述

代码的实现

在这里插入图片描述

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <malloc.h>

// 链式结构：表示队列 
typedef int QDataType;
typedef struct QNode
{ 
    struct QNode* _pNext; 
    QDataType _data; 
}QNode; 
 
// 队列的结构 
typedef struct Queue 
{ 
  QNode* _front; 
  QNode * _rear; 
}Queue; 
 
// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->_front=q->_rear=NULL;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
   QNode* newnode=(QNode*)malloc(sizeof(QNode));
   newnode->_data=data;
   newnode->_pNext=NULL;
   if(q->_rear==NULL)
   {
	   q->_rear= q->_front=newnode;
   }
   else
   {
	   q->_rear->_pNext=newnode;
	   q->_rear=newnode;
   }
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	
	QNode *p=q->_front->_pNext;
	free(q->_front);
	q->_front=p;
	if(q->_front==NULL)
	{
		q->_rear=NULL;
	}
}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);

		return q->_front->_data;

}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	
	return q->_rear->_data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	int count=0;
	QNode*p=q->_front;

	while(p!=NULL)
	{
		p=p->_pNext;
		++count;
	}
	return count;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->_front==NULL? 1:0;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	QNode *p=q->_front;
	while(p!=NULL) 
	{
		QNode *next=p->_pNext;
		free(p);
		p=next;
	}
	q->_front=q->_rear=NULL;
}

void QueuePrint(Queue *q)
{
	assert(q);
	QNode *cur=q->_front;
	while(cur!=NULL)
	{
		printf("%d  ",(cur->_data));
		cur=cur->_pNext;
	}
	printf("\n");
}

void test()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
    QueuePush(&q, 3);
    QueuePush(&q, 5);
   // QueuePop(&q);
    QueuePrint(&q);
    printf("队头的元素： %d\n",QueueFront(&q));
	printf("队尾的元素： %d\n",QueueBack(&q));
	printf("队列中元素个数：%d\n",QueueSize(&q));
	 QueueDestroy(& q);
	printf("1：空 0：非空 队列是否为空 %d\n",QueueEmpty(&q));
}
int main()
{
	test();
	return 0;
}

栈的实现

栈的实现

两个栈实现队列

思路：这里就只讲一下push和pop吧，栈是后进先出，而队列是先进先出，所以要想用栈实现队列可以定义两个栈，一个是push的一个是pop的，入数据进入push栈，出数据从pop栈出，如果pop栈为空，则将push栈里面的数据出栈然后入栈到pop中去。。。。。似乎说的有点绕

在这里插入图片描述

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack 
{    STDataType* myarr;  
int _top;       // 栈顶  
int _capacity;  // 容量 
}Stack;
void StackInit(Stack* ps)//创建空数组
{
	assert(ps);
	ps->_capacity = 10;
	ps->_top = 0;
	ps->myarr = (STDataType*)malloc(sizeof(STDataType)*ps->_capacity);
	//if (ps->myarr == NULL)
	//	return NULL;
}
void StackCapacity(Stack* ps)//扩容
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		if (ps->myarr == 0)
			ps->_capacity = 2;
		ps->myarr= (STDataType *)realloc(ps->myarr, ps->_capacity*sizeof(STDataType)* 2);
		ps->_capacity = ps->_capacity * 2;

	}
}

void StackPush(Stack* ps, STDataType x)//入栈
{
	assert(ps);
	StackCapacity(ps);
	ps->myarr[ps->_top] = x;
	ps->_top++;
}
void Stackprint(Stack *ps)//打印栈
{
	assert(ps);
	Stack *p = ps;
	for (int i = 0; i < ps->_top; i++)
	{
		printf("%d  ", ps->myarr[i]);

	}printf("\n");
}
void StackPop(Stack* ps)//出栈
{
	assert(ps);
	if (ps->_top == 0)
	{
		//printf("栈为空\n");
		return;
	}
	//STDataType  s=ps->myarr[ps->_top-1];
	(ps->_top)--;
    
    
}
void StackEmpty(Stack* ps)//清空栈
{
	assert(ps);
	ps->_capacity = 0;
	ps->_top = 0;
	free(ps->myarr);
	//if (ps->_top == 0)
		//printf("栈为空");

}
int StackSize(Stack* ps)//输出栈的大小
{
	assert(ps); 
	
	 //printf("栈的长度为%d\n",ps->_top);
     return ps->_top;
}
STDataType StackTop(Stack* ps)
{
	assert(ps);
	/*if (ps->_top == 0)
	{
		printf("栈为空\n");
		return ;
	}*/
	//printf("栈顶的内容%d\n", ps->myarr[ps->_top-1]);
    return ps->myarr[ps->_top-1];
	
}


typedef struct {
Stack s1;//push
Stack s2;//pop
} MyQueue;

/** Initialize your data structure here. */

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

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
 StackPush(&obj->s1,x);

}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
 //如果s2(pop)栈为空，则需要将s1里面的数据倒过来，然后pop
 if(StackSize(&obj->s2)==0)
 {
     while(StackSize(&obj->s1)>0)
     {
         StackPush(&obj->s2,StackTop(&obj->s1));
         StackPop(&obj->s1);
     }
    
 }

 
     STDataType s=StackTop(&obj->s2);
      StackPop(&obj->s2);
 
 return s;
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
  if(StackSize(&obj->s2)==0)
 {
     while(StackSize(&obj->s1)>0)
     {
         StackPush(&obj->s2,StackTop(&obj->s1));
         StackPop(&obj->s1);
     }
    
 }
return StackTop(&obj->s2);
}

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
return StackSize(&(obj->s1))==0&&StackSize(&(obj->s2))==0;
}

void myQueueFree(MyQueue* obj) {
   StackEmpty(&(obj->s1));
   StackEmpty(&(obj->s2));
}

两个队列实现栈

定义两个队列，一个是空队列empty一个是有数据的队列noempty，入栈是将数据存放到有数据的队列，出栈是需要将noempty里面除了队尾的元素，其他都要放到empty中，然后将noempty里面的元素出队列。

在这里插入图片描述

// 链式结构：表示队列 
typedef int QDataType;
typedef struct QNode
{ 
    struct QNode* _pNext; 
    QDataType _data; 
}QNode; 
 
// 队列的结构 
typedef struct Queue 
{ 
  QNode* _front; 
  QNode * _rear; 
}Queue; 
 
// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->_front=q->_rear=NULL;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
   QNode* newnode=(QNode*)malloc(sizeof(QNode));
   newnode->_data=data;
   newnode->_pNext=NULL;
   if(q->_rear==NULL)
   {
	   q->_rear= q->_front=newnode;
   }
   else
   {
	   q->_rear->_pNext=newnode;
	   q->_rear=newnode;
   }
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	
	QNode *p=q->_front->_pNext;
	free(q->_front);
	q->_front=p;
	if(q->_front==NULL)
	{
		q->_rear=NULL;
	}
}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);

		return q->_front->_data;

}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	
	return q->_rear->_data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	int count=0;
	QNode*p=q->_front;

	while(p!=NULL)
	{
		p=p->_pNext;
		++count;
	}
	return count;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->_front==NULL? 1:0;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	QNode *p=q->_front;
	while(p!=NULL) 
	{
		QNode *next=p->_pNext;
		free(p);
		p=next;
	}
	q->_front=q->_rear=NULL;
}

typedef struct {
//定义两个队列
Queue q1;
Queue q2;
} MyStack;

/** Initialize your data structure here. */

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

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
  
  if(QueueEmpty(&(obj->q1))==1)//q1为空
  {
     QueuePush(&(obj->q2),x);
  }
  else
  {
      QueuePush(&(obj->q1),x);
  }
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
  
 Queue* empty=&obj->q1;
Queue* noempty=&obj->q2;
  if(QueueEmpty(&(obj->q1))==0)//q1不为空
  {
      empty=&obj->q2;
      noempty=&obj->q1;
  }
  
  while(QueueSize((noempty))>1)
  {
      QueuePush((empty),QueueFront((noempty)));
      QueuePop((noempty));

  }
 int q=QueueFront(noempty);
   QueuePop(noempty);
  return q;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
    
    
Queue empty=obj->q1;
Queue noempty=obj->q2;
  if(QueueEmpty(&(obj->q1))==0)//q1不为空
  {
      empty=obj->q2;
      noempty=obj->q1;
  }
  return QueueBack(&(noempty));
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
 return QueueEmpty(&(obj->q1))&&QueueEmpty(&(obj->q2));
}

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

}
蓝海萤
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode —— 面试题 03.04. 化栈为队
fightfightfightf的博客
06-21 189
实现一个MyQueue类，该类用两个栈来实现一个队列。 示例： MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.pop(); // 返回 1 queue.empty(); // 返回 false 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/implement-queue-using-stacks-lcci 著作
【LeetCode击败99%+】化栈为队
Java技术工坊
01-08 148
题目 实现一个MyQueue类，该类用两个栈来实现一个队列。 示例： MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.pop(); // 返回 1 queue.empty(); // 返回 false 说明： 你只能使用标准的栈操作 – 也就是只有 push to top, peek/pop from top, size 和 is empty 操作是合法的。 你
化栈为队
qq_40742888的博客
02-27 134
将栈化为队列 我的想法是 1、判断后一个队列里面是否有存值，若是有，栈顶即队首 2、判断第一个栈是否有存值，若是有，栈顶即队尾 class MyQueue { private: stack c_first; stack d_second; public: /** Initialize your data structure here. */ MyQueue() { } /** Push elem...
化栈为队（Java实现）
热门推荐
卜大爷的博客
11-14 2万+
化栈为队 题目 面试题 03.04. 化栈为队 实现一个MyQueue类，该类用两个栈来实现一个队列。 示例： MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.pop(); // 返回 1 queue.empty(); // 返回 false 分析 该题的思路和《用两个栈实现队列（Java实现）》一样。不过这里要注意一点，可以在pop()的时候，复用peek的逻辑。 代码
化栈为队列
along_000的博客
02-19 683
化栈为队题目解决思路代码说明 题目 （1）实现一个MyQueue类，该类用两个栈来实现一个队列。 （2）示例如下： MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.pop(); // 返回 1 queue.empty(); // 返回 false （3）说明 你只能使用标准的栈操作 – 也就是只有 push to top, peek/pop from top, size
实现协议栈自动化测试.pdf
11-17
实现协议栈自动化测试.pdf
ZigBee协议栈初始化网络启动流程.doc
06-20
ZigBee 协议栈初始化网络启动流程 ZigBee 协议栈初始化网络启动流程是指 ZigBee 协议栈在网络启动时的初始化过程。该过程主要包括协调器的组网、终端设备和路由设备发现网络以及加入网络等步骤。 1. 协调器的组网 ...
javascript栈可视化.rar
06-21
包含javascript栈可视化，可点击操作入栈、出栈、使用CSS3动画语法，具有动画演示,内容包含所需图片等资源。
MangoDowner#clear-leetcode#面试题03.04.化栈为队1
07-25
1、go里面没有栈这个数据结构，可以用数组模拟 2、既然是用栈模拟队列，就不能有按索引直接访问数组元素的操作，直接访问数组模拟的栈最后一个元素，也就是栈顶元素
python栈的基本定义与使用方法示例【初始化、赋值、入栈、出栈等】
09-18
self.top = None # 初始化栈，top初始为空 ``` 接着，我们定义了三个基本的栈操作方法： 1. `peek()`：获取栈顶元素但不移除。如果栈为空，返回`None`。 2. `push(node)`：将给定的节点（值）入栈。如果节点非空...
化栈为队Java版（力扣）
『愚』的博客
01-05 2646
化栈为队 实现一个MyQueue类，该类用两个栈来实现一个队列。 示例： MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.pop(); // 返回 1 queue.empty(); // 返回 false 说明： 你只能使用标准的栈操作 – 也就是只有 push to top, peek/pop from top, size 和 is empty 操作是合法的。 你所使用的
LeetCode 【栈】面试题 03.04. 化栈为队 （简单）
Mr. Stone's Blog
08-07 275
算法小白开始刷题，本文包含了自己的思考过程，所以内容可能比较冗余，如需思路，可直接看文章后面的 优化解法。 题目链接：https://leetcode-cn.com/problems/implement-queue-using-stacks-lcci/ 题目 实现一个MyQueue类，该类用两个栈来实现一个队列。 示例： MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.po
面试金典 03.04. 化栈为队
sunlanchang的博客
03-02 269
Description 实现一个MyQueue类，该类用两个栈来实现一个队列。 示例： MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.pop(); // 返回 1 queue.empty(); // 返回 false 说明： 你只能使用标准的栈操作 --...
leetcode：面试题 03.04. 化栈为队
OceanStar的博客
05-13 225
题目来源 https://leetcode-cn.com/problems/implement-queue-using-stacks-lcci/ 题目描述 题目解析 两个栈： 一个读栈rStack 一个写栈wStack 当push时 直接往wStack压入元素 当pop时：(一个空的队列不会调用 pop 或者 peek 操作) 如果rStack为空，将wStack的元素全部压入rStack， 然后rStack.pop第一个元素 如果rStack不为空，rStack.pop第一个元素 当peek时：
面试题 03.04. 化栈为队
tianlanl10的博客
06-08 200
实现一个MyQueue类，该类用两个栈来实现一个队列。 示例： MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.pop(); // 返回 1 queue.empty(); // 返回 false 说明： 你只能使用标准的栈操作 -- 也就是只有 push to top, peek/pop from top, size 和 is empty...
面试题 03.05. 化栈为队
yeyueyouhun的博客
03-02 167
实现一个MyQueue类，该类用两个栈来实现一个队列。 class MyQueue { public: /** Initialize your data structure here. */ stack<int> st1; stack<int> st2; MyQueue() { } ...
为双向栈设计初始化 入栈 出栈
最新发布
05-05
双向栈通常由两个栈组成，一个栈从左端入栈，另一个栈从右端入栈。...如果栈已满或栈为空，则会显示错误消息。 这个双向栈的实现可以轻松地扩展到其他数据类型和操作，例如查找元素和获取栈的大小。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值