两个队列实现一个栈

最新推荐文章于 2021-05-23 12:12:07 发布
原创 最新推荐文章于 2021-05-23 12:12:07 发布 · 408 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

题目：用两个队列模拟一个栈，即用两个队列的出队和入队操作，来实现栈的出栈和入栈操作。

思路：稍微画下草图，便不难想出该题的解决方法，思路如下：

假设有两个队列Q1和Q2，当二者都为空时，入栈操作可以用入队操作来模拟，可以随便选一个空队列，假设选Q1进行入栈操作，现在假设a,b,c依次入栈了（即依次进入队列Q1），这时如果想模拟出栈操作，则需要将c出栈，因为在栈顶，这时候可以考虑用空队列Q2，将a，b依次从Q1中出队，而后进入队列Q2，将Q1的最后一个元素c出队即可，此时Q1变为了空队列，Q2中有两个元素，队头元素为a，队尾元素为b，接下来如果再执行入栈操作，则需要将元素进入到Q1和Q2中的非空队列，即进入Q2队列，出栈的话，就跟前面的一样，将Q2除最后一个元素外全部出队，并依次进入队列Q1，再将Q2的最后一个元素出队即可。

实现代码如下：

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/*
用两个队列模拟入栈操作
*/
void push(PQUEUE pS1,PQUEUE pS2, int val)
{
     if (is_empty(pS2))
         en_queue(pS1, val);
     else
         en_queue(pS2, val);
}
 
/*
用两个队列模拟出栈操作
*/
bool pop(PQUEUE pS1,PQUEUE pS2, int *pData)
{
     if (is_empty(pS1) && is_empty(pS2))
         return false ;
 
     int DelData;
     if (!is_empty(pS2))
     {
         int len = length(pS2);
         while (len-- > 1 )
         {
             de_queue(pS2,&DelData);
             en_queue(pS1,DelData);
         }
         //将队列的最后一个元素出队，作为出栈元素
         de_queue(pS2,pData);
         return true ;
     }
     if (!is_empty(pS1))
     {
         int len = length(pS1);
         while (len-- > 1 )
         {
             de_queue(pS1,&DelData);
             en_queue(pS2,DelData);
         }
         //将队列的最后一个元素出队，作为出栈元素
         de_queue(pS1,pData);
         return true ;
     }
}

完整的代码（用的以前写的链式队列）如下：

 

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
/*******************************************************************
题目：用两个队列模拟一个栈
*******************************************************************/
 
#include<stdio.h>
#include<stdlib.h>
 
typedef struct Node
{
     int data;
     struct Node *pNext;
}NODE,*PNODE;
 
typedef struct Queue
{
     PNODE front;  //队头指针
     PNODE rear;   //队尾指针
}QUEUE,*PQUEUE;
 
PQUEUE create_queue();
bool is_empty(PQUEUE);
void en_queue(PQUEUE, int );
bool de_queue(PQUEUE, int *);
void destroy_queue(PQUEUE);
void traverse_queue(PQUEUE);
int length(PQUEUE);
void push(PQUEUE,PQUEUE, int );
bool pop(PQUEUE,PQUEUE, int *);
 
int main()
{
     int pData;         //用来保存出队的元素值
 
     //创建队列并进行入队测试
     PQUEUE pS1 = create_queue();
     PQUEUE pS2 = create_queue();
     push(pS1,pS2, 4 );
     push(pS1,pS2, 5 );
     printf(the length of pS1: %d
,length(pS1));
     printf(the length of pS2: %d
,length(pS2));
     if (pop(pS1,pS2,&pData))
         printf(%d is pop out
,pData);
     else
         printf(Stack is empty,can not pop
);
     printf(the length of pS1: %d
,length(pS1));
     printf(the length of pS2: %d
,length(pS2));
     push(pS1,pS2, 6 );
     printf(the length of pS1: %d
,length(pS1));
     printf(the length of pS2: %d
,length(pS2));
     push(pS1,pS2, 7 );
     printf(the length of pS1: %d
,length(pS1));
     printf(the length of pS2: %d
,length(pS2));
     if (pop(pS1,pS2,&pData))
         printf(%d is pop out
,pData);
     else
         printf(Stack is empty,can not pop
);
     printf(the length of pS1: %d
,length(pS1));
     printf(the length of pS2: %d
,length(pS2)); 
     if (pop(pS1,pS2,&pData))
         printf(%d is pop out
,pData);
     else
         printf(Stack is empty,can not pop
);
     printf(the length of pS1: %d
,length(pS1));
     printf(the length of pS2: %d
,length(pS2));
     if (pop(pS1,pS2,&pData))
         printf(%d is pop out
,pData);
     else
         printf(Stack is empty,can not pop
);
     printf(the length of pS1: %d
,length(pS1));
     printf(the length of pS2: %d
,length(pS2));
     if (pop(pS1,pS2,&pData))
         printf(%d is pop out
,pData);
     else
         printf(Stack is empty,can not pop
);
 
     return 0 ;
}
 
/*
创建一个空队列，队头指针和队尾指针都指向头结点，
头结点中不存放数据，只存放指针
*/
PQUEUE create_queue()
{
     PQUEUE pS = (PQUEUE)malloc(sizeof(Queue));
     pS->front = (PNODE)malloc(sizeof(NODE));
     if (!pS || !pS->front)
     {
         printf(pS or front malloc failed!!);
         exit(- 1 );
     }
     else
     {
         pS->rear = pS->front;
         pS->front->pNext = NULL;
     }
     return pS;
}
 
/*
判断队列是否为空
*/
bool is_empty(PQUEUE pS)
{
     if (pS->front == pS->rear)
         return true ;
     else
         return false ;
}
 
/*
进队函数，从队尾进队，队头指针保持不变
*/
void en_queue(PQUEUE pS, int e)
{
     PNODE pNew = (PNODE)malloc(sizeof(NODE));
     if (!pNew)
     {
         printf(pNew malloc failed);
         exit(- 1 );
     }
     else
     {
         pNew->data = e;
         pNew->pNext = NULL;
         pS->rear->pNext = pNew;
         pS->rear = pNew;
     }
     return ;
}
 
/*
出队函数，从队头出队，队尾指针保持不变，但当最后一个元素出队时，
需要对队尾指针重新赋值，使其指向头结点
*/
bool de_queue(PQUEUE pS, int *pData)
{
     if (is_empty(pS))
         return false ;
     else
     {
         PNODE p = pS->front->pNext;
         *pData = p->data;
         pS->front->pNext = p->pNext;
 
         //这里是队列头元素出队的特殊情况，一般情况下，删除队头元素时
         //仅需修改头结点中的指针，但当队列中最后一个元素被删除时，
         //队列尾指针也丢失了，因此需对队尾指针重新赋值（指向头结点）。
         if (pS->rear == p)        
             pS->rear = pS->front;
         free(p);
     }
     return true ;
}
 
/*
遍历队列，从对头向队尾依次输出队中的元素
*/
void traverse_queue(PQUEUE pS)
{
     if (is_empty(pS))
         printf(there is no data in the queue!
);
     else
     {  
         PNODE pCurrent = pS->front->pNext;
         printf(Now datas int the queue are:
);
         while (pCurrent)
         {
             printf(%d ,pCurrent->data);
             pCurrent = pCurrent->pNext;
         }
         printf(
);
     }
     return ;
}
 
/*
求队列的长度
*/
int length(PQUEUE pS)
{
     int count = 0 ;
     PNODE pCurrent = pS->front->pNext;
     while (pCurrent)
     {
         count++;
         pCurrent = pCurrent->pNext;
     }
     return count;
}
 
/*
销毁队列,头结点也被销毁,最后也将pS节点销毁，并将其指向为空，避免垂直指针的产生
*/
void destroy_queue(PQUEUE pS)
{
     if (is_empty(pS))
         return ;
     else
     {
         while (pS->front)
         {
             pS->rear = pS->front->pNext;
             free(pS->front);
             pS->front = pS->rear;
         }
     }
     free(pS);
     pS = 0 ;
     return ;
}
 
/*
用两个队列模拟入栈操作
*/
void push(PQUEUE pS1,PQUEUE pS2, int val)
{
     if (is_empty(pS2))
         en_queue(pS1, val);
     else
         en_queue(pS2, val);
}
 
/*
用两个队列模拟出栈操作
*/
bool pop(PQUEUE pS1,PQUEUE pS2, int *pData)
{
     if (is_empty(pS1) && is_empty(pS2))
         return false ;
 
     int DelData;
     if (!is_empty(pS2))
     {
         int len = length(pS2);
         while (len-- > 1 )
         {
             de_queue(pS2,&DelData);
             en_queue(pS1,DelData);
         }
         //将队列的最后一个元素出队，作为出栈元素
         de_queue(pS2,pData);
         return true ;
     }
     if (!is_empty(pS1))
     {
         int len = length(pS1);
         while (len-- > 1 )
         {
             de_queue(pS1,&DelData);
             en_queue(pS2,DelData);
         }
         //将队列的最后一个元素出队，作为出栈元素
         de_queue(pS1,pData);
         return true ;
     }
}</stdlib.h></stdio.h>

测试结果：

 

/
如何用两个队列实现一个栈及其性能分析
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-31 1064
在计算机科学中，栈（Stack）和队列（Queue）是两种常见的数据结构，它们各自有着独特的操作方式和应用场景。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。在某些特定场景下，我们可能需要使用一种数据结构来实现另一种数据结构的功能。本文将详细探讨如何使用两个队列来实现一个栈，并分析相关栈操作的运行时间。
用两个队列实现一个栈
hang_1994的博客
10-25 3177
我们通过一系列栈的压入和弹出操作来分析用两个队列模拟一个栈的过程。如图(a)所示，我们先往栈内压入一个元素A。由于两个队列现在都是空的，我们可以选择把A插入两个队列的任意一个。不妨插入queue1。接下来继续往栈内压入B、C两个元素，我们把它们都插入queue1。这个时候queue1包含3个元素A、B和C，其中A位于队列的头部，C位于队列的尾部。 　　现在我们考虑从栈内弹出一个元素。根据栈的后入...
【剑指offer】两个队列实现一个栈
兰亭风雨的专栏
05-06 9329
转载请注明出处：    题目：用两个队列模拟一个栈，即用两个队列的出队和入队操作，来实现栈的出栈和入栈操作。    思路：稍微画下草图，便不难想出该题的解决方法，思路如下：    假设有两个队列Q1和Q2，当二者都为空时，入栈操作可以用入队操作来模拟，可以随便选一个空队列，假设选Q1进行入栈操作，现在假设a,b,c依次入栈了（即依次进入队列Q1），这时如果想模拟出栈操作，则需要将c出栈，因为在栈顶
通过两个队列实现一个栈（C语言）
小心眼儿猫的博客
04-16 9788
stackBy2Queue.h文件 #pragma once #define max_size 1000 typedef char DataType; typedef struct Queue { DataType data[max_size]; int head; int tail; //队列中有效元素个数 int size; }Queue; ...
JS实现利用两个队列表示一个栈的方法
11-27
通过巧妙地操作这两个队列，我们可以实现栈的基本操作，如push（入栈）和pop（出栈）。 首先，我们需要理解栈和队列的基本操作。栈的操作包括： 1. push：将元素添加到栈顶。 2. pop：移除栈顶元素并返回其值。 3. ...
两个队列实现一个栈思路c语言,利用栈实现队列(C语言实现)
weixin_42514107的博客
05-23 869
在上一篇这里主要实现的是：利用栈来实现队列基本思路：1，创建两个栈2，两个栈合并起来组装成一个队列，分别取名为instack,outstack，用于进队列，出队列3，比如有1,2,3,4,5 需要进入队列，先将这一串数压入instack栈中，假设压入顺序为1,2,3,4,5(1为栈底)，再将instack中的数据移入outstack中，出栈顺序为：5,4,3,2,1. 那么入outsatck的时...
两个队列实现一个栈思路c语言,两个栈实现队列功能C语言实现能运行！
weixin_30424461的博客
05-23 287
#include#includetypedefstructsq{char*ps;inttop;intMaxsize;}stack;voidinitstack(stack*s,intms){s->ps=(char*)malloc(ms*sizeof(char));s->top=-1;s->Maxsize=ms;};voidpush(stack*s,charva...
数据结构 两个队列实现一个栈
最新发布
09-20
<think> 首先，用户查询的是“如何使用两个队列实现一个栈”。参考了提供的引用，我需要基于这些信息来构建回答。 引用摘要： - [^1]: 提到两个栈实现一个队列，但用户需要相反：两个队列实现一个栈。 - [^2]: 描述了使用两个队列实现栈的基本方法：从一个队列移动到另一个队列来模拟栈的后进先出。 - [^3]: 提供了队列元素个数的计算，但没有直接关于实现栈。 - [^4]: 详细描述了用两个队列实现栈的方法，包括代码框架。 - [^5]: 解释了如何用两个队列实现栈，强调移动数据的过程。 关键点： - 栈是后进先出（LIFO），队列是先进先出（FIFO）。 - 用两个队列模拟栈时，需要确保插入和删除操作符合LIFO。 - 常见方法：有一个主队列（如q1）存放数据，另一个辅助队列（q2）临时存储数据。 - 插入（Push）：直接加到主队列中。 - 删除（Pop）：将主队列的前n-1个元素移到辅助队列，删除最后一个元素（即栈顶），然后交换队列角色。 - 引用[^4]和[^5]提供了具体步骤。 回答结构： 1. **引言**：简要解释问题和方法。 2. **原理概述**：描述两个队列如何协作实现栈的行为。 3. **详细步骤**： - Push操作：简单地将元素添加到主队列。 - Pop操作：移出元素时，需要移除最后添加的元素；这通过移动队列元素来实现。 - Top操作：获取栈顶元素，类似Pop但不移除。 - Size和Empty：计算队列大小或检查是否为空。 4. **代码示例**：提供一个简单的代码实现，基于引用[^4]的框架。 5. **注意事项**：讨论性能和优化。 6. **相关问题**：生成相关问题作为结尾。 系统指令： - 使用中文回答。 - 行内数学表达式用$...$格式，但这里可能不涉及数学表达式。如果有变量，如队列大小，用$...$。 - 独立公式用$$...$$，但同样可能不涉及。 - 回答结构清晰。 - 引用的段落末尾自然地添加引用标识，如[^1]。 - 生成相关问题。 用户需求：基于引用，回答如何用两个队列实现一个栈。引用[^4]和[^5]是最相关的。 确保真实性：参考标准数据结构知识。两个队列实现栈是经典问题。 代码语言：用户之前的问题有Python代码，但引用中提到了C++，所以我可以用Python或伪代码来保持一致性。用户没有指定，所以用Python作为通用语言。 最终回答大纲： - 开头：介绍问题。 - 核心实现： - Push方法。 - Pop方法。 - 其他方法如Top、Size。 - 代码示例。 - 结束：总结和问题。 </think> ### 如何使用两个队列实现一个栈 在计算机科学中，栈遵循后进先出（LIFO）原则，队列遵循先进先出（FIFO）原则。使用两个队列（例如命名为 `q1` 和 `q2`）实现一个栈的关键在于模拟 LIFO 行为：插入（Push）时直接添加元素，删除（Pop）时需移除最后添加的元素（即最近的栈顶）。核心思想是利用队列的 FIFO 特性，通过移动元素来暴露最后一个元素作为栈顶。参考引用[^4]和[^5]，以下是详细步骤和实现方法。 #### 实现原理 - **队列角色分配**： - `q1` 作为主队列，用于存储数据。 - `q2` 作为辅助队列，用于临时中转元素。 - Push 操作直接向 `q1` 添加元素。 - Pop 操作时，需将 `q1` 的前 $n-1$ 个元素移动到 `q2$ ，保留最后一个元素作为栈顶移除，然后交换 `q1` 和 `q2` 的角色（确保 `q1` 始终是主队列）[^4][^5]。 - **复杂度分析**： - Push 操作：时间复杂度 $O(1)$，因为直接入队。 - Pop 操作：时间复杂度 $O(n)$，因为需要移动 $n-1$ 个元素。 - Top 操作：类似 Pop，但不移除元素，复杂度 $O(n)$。 - Size 和 Empty：基于两个队列的总大小计算，复杂度 $O(1)$[^3]。 #### 详细步骤 1. **Push 操作（插入元素）**： - 直接将新元素添加到主队列 `q1` 中。 - 示例：将元素 `x` 推入栈时，调用 `q1.push(x)`。 - 目的：保持元素顺序，但不改变队列的 FIFO 特性。 2. **Pop 操作（删除元素）**： - 将 `q1` 中的前 $n-1$ 个元素逐个移动到 `q2`（辅助队列）。 - 移除 `q1` 的最后一个元素（即栈顶元素）。 - 交换 `q1` 和 `q2` 的角色： `q2` 成为新主队列， `q1` 清空备用。 - 目的：通过移动元素暴露最后的元素作为栈顶[^2][^5]。 - 示例：如果 `q1` 的元素序列为 `[a, b, c, d]`，移动前 3 个到 `q2`，移除 `d`（栈顶），然后 `q2` 成为新 `q1`。 3. **Top 操作（获取栈顶元素）**： - 类似 Pop 操作：移动 `q1` 的前 $n-1$ 个元素到 `q2`，但不移除最后一个元素。 - 读取最后一个元素的值，然后还原队列状态（将元素移回 `q1`）。 - 目的：避免真正移除元素，只查询栈顶[^4]。 4. **Size 和 Empty 操作**： - Size：返回 `q1.size() + q2.size()`。 - Empty：检查两个队列是否都为空[^3]。 #### 代码实现（Python 示例） 参考引用[^4]，以下是使用两个队列实现栈的完整代码框架。代码基于 Python，使用 `collections.deque` 模拟队列。 ```python from collections import deque class StackWithTwoQueues: def __init__(self): self.q1 = deque() # 主队列 self.q2 = deque() # 辅助队列 def push(self, x): """插入元素：直接添加到主队列""" self.q1.append(x) def pop(self): """删除栈顶元素：移动前 n-1 个元素，移除最后一个元素，交换队列角色""" if self.empty(): return None # 移动 q1 的前 n-1 个元素到 q2 while len(self.q1) > 1: self.q2.append(self.q1.popleft()) # 移除并返回栈顶元素（q1 的最后一个元素） top = self.q1.pop() # 交换 q1 和 q2 角色 self.q1, self.q2 = self.q2, self.q1 # 现在 q2 为空，成为新辅助队列 return top def top(self): """获取栈顶元素：类似 pop，但不移除""" if self.empty(): return None # 移动前 n-1 个元素到 q2 while len(self.q1) > 1: self.q2.append(self.q1.popleft()) top = self.q1[0] # 读取栈顶元素 # 将所有元素移回 q1 以还原状态 self.q2.append(self.q1.popleft()) self.q1, self.q2 = self.q2, self.q1 # 交换角色 return top def size(self): """栈大小：两个队列元素之和""" return len(self.q1) + len(self.q2) def empty(self): """检查栈是否为空""" return self.size() == 0 # 示例用法 s = StackWithTwoQueues() s.push(1) s.push(2) s.push(3) print(s.pop()) # 输出: 3 (栈顶元素) print(s.top()) # 输出: 2 (新栈顶元素) print(s.size()) # 输出: 2 ``` #### 注意事项 - **性能优化**：Pop 和 Top 操作的时间复杂度为 $O(n)$，不适合高频删除场景。优化方法包括使用单个队列的变体或缓存栈顶元素[^5]。 - **正确性保证**：每次 Pop 后需交换队列角色，以避免数据不一致。 - **应用场景**：该方法常用于算法面试题或教学示例，实际开发中优先使用原生栈结构，除非有特定约束（如语言不支持栈库）[^1][^4]。 这种方法通过巧妙的数据移动，确保了栈的 LIFO 行为，尽管有性能开销，但逻辑清晰易懂[^5]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值