比较来自世界各地的卖家的域名和 IT 服务价格

用两个队列实现堆栈

早些时候提出了类似的问题。
https://coderoad.ru/69192/
, 但这里的问题是反向的,使用两个队列作为堆栈。 问题...

Dana两个队列,标准操作 /
enqueue

,
dequeue

,
isempty

,
size

/, 用标准操作实现堆栈 /
pop

,
push

,
isempty

,
size

/.

必须是



溶液溶液。

版本



: 按元素时,堆栈必须有效; 和

版本

B

: 当元素出现时,堆栈必须有效。

我对算法感兴趣,而不是任何特定的语言实现。 但是,我欢迎我所知道的语言表达的解决方案 /
https://coderoad.ru/?tag=java
,
https://coderoad.ru/?tag=c%23
,
https://coderoad.ru/?tag=python
,
https://coderoad.ru/?tag=vb
,
https://coderoad.ru/?tag=javascript
,
https://coderoad.ru/?tag=php
/.
已邀请:

龙天

赞同来自:

版A. /有效推动/:

推:

队列队列 1

棉布:

虽然大小 queue1 多于 1, 管道从队列项目中删除 queue1 在 queue2

删除队列并返回最后一个项目 queue1, 然后切换名称 queue1 和 queue2


版本 B /有效的 pop/:

推:

队列队列 2

将所有元素放在队列中 queue1 在 queue2, 然后切换名称 queue1 和 queue2

棉布:

deqeue 经过 queue1

裸奔

赞同来自:

最简单的 /也许是唯一的/ 使其在空队列中的新项目的方法,然后删除其他项目并将其启用在以前的空队列中。 因此,后者总是在队列的开头。 这将是版本B的版本 A 除了后者之外,您只需通过从队列中删除元素来取消该进程。

步 0:


"Stack"
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+

Queue A Queue B
+---+---+---+---+---+ +---+---+---+---+---+
| | | | | | | | | | | |
+---+---+---+---+---+ +---+---+---+---+---+


步 1:


"Stack"
+---+---+---+---+---+
| 1 | | | | |
+---+---+---+---+---+

Queue A Queue B
+---+---+---+---+---+ +---+---+---+---+---+
| 1 | | | | | | | | | | |
+---+---+---+---+---+ +---+---+---+---+---+


步 2:


"Stack"
+---+---+---+---+---+
| 2 | 1 | | | |
+---+---+---+---+---+

Queue A Queue B
+---+---+---+---+---+ +---+---+---+---+---+
| | | | | | | 2 | 1 | | | |
+---+---+---+---+---+ +---+---+---+---+---+


步 3:


"Stack"
+---+---+---+---+---+
| 3 | 2 | 1 | | |
+---+---+---+---+---+

Queue A Queue B
+---+---+---+---+---+ +---+---+---+---+---+
| 3 | 2 | 1 | | | | | | | | |
+---+---+---+---+---+ +---+---+---+---+---+

詹大官人

赞同来自:

我们可以用一个队列进行:

推:

在队列中放置一个新元素。

如果一个
n

- 这是队列中的项目数,然后删除并粘贴项目
n-1

时间。

棉布:

提炼
.


push 1


front
+----+----+----+----+----+----+
| 1 | | | | | | insert 1
+----+----+----+----+----+----+


push2

front
+----+----+----+----+----+----+
| 1 | 2 | | | | | insert 2
+----+----+----+----+----+----+

front
+----+----+----+----+----+----+
| | 2 | 1 | | | | remove and insert 1
+----+----+----+----+----+----+




insert 3


front
+----+----+----+----+----+----+
| | 2 | 1 | 3 | | | insert 3
+----+----+----+----+----+----+

front
+----+----+----+----+----+----+
| | | 1 | 3 | 2 | | remove and insert 2
+----+----+----+----+----+----+

front
+----+----+----+----+----+----+
| | | | 3 | 2 | 1 | remove and insert 1
+----+----+----+----+----+----+


示例实现:


int stack_pop /queue_data *q/
{
return queue_remove /q/;
}

void stack_push /queue_data *q, int val/
{
int old_count = queue_get_element_count /q/, i;

queue_insert /q, val/;
for /i=0; i<old_count; ;="" <="" code]="" div="" i++="" q="" q,="" queue_insert="" queue_remove="" {="" }="" }[="">
<div class="answer_text">

[code]import java.util.*;

/**
*
* @author Mahmood
*/
public class StackImplUsingQueues {

Queue<integer> q1 = new LinkedList<integer>//;
Queue<integer> q2 = new LinkedList<integer>//;

public int pop// {
if /q1.peek// == null/ {
System.out.println/"The stack is empty, nothing to return"/;
int i = 0;
return i;
} else {
int pop = q1.remove//;
return pop;
}
}

public void push/int data/ {

if /q1.peek// == null/ {
q1.add/data/;
} else {
for /int i = q1.size//; i &gt; 0; i--/ {
q2.add/q1.remove///;
}
q1.add/data/;
for /int j = q2.size//; j &gt; 0; j--/ {
q1.add/q2.remove///;
}

}
}

public static void main/String[] args/ {
StackImplUsingQueues s1 = new StackImplUsingQueues//;
// Stack s1 = new Stack//;
s1.push/1/;
s1.push/2/;
s1.push/3/;
s1.push/4/;
s1.push/5/;
s1.push/6/;
s1.push/7/;
s1.push/8/;
s1.push/9/;
s1.push/10/;
// s1.push/6/;
System.out.println/"1st = " + s1.pop///;
System.out.println/"2nd = " + s1.pop///;
System.out.println/"3rd = " + s1.pop///;
System.out.println/"4th = " + s1.pop///;
System.out.println/"5th = " + s1.pop///;
System.out.println/"6th = " + s1.pop///;
System.out.println/"7th = " + s1.pop///;
System.out.println/"8th = " + s1.pop///;
System.out.println/"9th = " + s1.pop///;
System.out.println/"10th= " + s1.pop///;
}
}


</integer></integer></integer></integer></div>
<div class="answer_text">
我们可以使用一圈实现堆栈吗? 我可以使用两个队列,但考虑一个队列会更有效率。 这是代码:


public void Push/T val/
{
queLower.Enqueue/val/;
}

public T Pop//
{

if /queLower.Count == 0 /
{
Console.Write/"Stack is empty!"/;
return default/T/;

}
if /queLower.Count &gt; 0/
{
for /int i = 0; i &lt; queLower.Count - 1;i++ /
{
queLower.Enqueue/queLower.Dequeue ///;
}
}

return queLower.Dequeue//;

}


</div>
<div class="answer_text">

queue<int> q1, q2;
int i = 0;

void push/int v/ {
if/ q1.empty// &amp;&amp; q2.empty// / {
q1.push/v/;
i = 0;
}
else {
if/ i == 0 / {
while/ !q1.empty// / q2.push/q1.pop///;
q1.push/v/;
i = 1-i;
}
else {
while/ !q2.empty// / q1.push/q2.pop///;
q2.push/v/;
i = 1-i;
}
}
}

int pop// {
if/ q1.empty// &amp;&amp; q2.empty// / return -1;
if/ i == 1 / {
if/ !q1.empty// /
return q1.pop//;
else if/ !q2.empty// /
return q2.pop//;
}
else {
if/ !q2.empty// /
return q2.pop//;
else if/ !q1.empty// /
return q1.pop//;
}
}


</int></div>
<div class="answer_text">
这是我的答案,在哪里 'pop' 无效。
似乎立即想到的所有算法都有 N n大小列表的困难:您决定工作吗? 'pop' 或工作 'push'

算法在回来并继续前进的地方可能会更好
由于不需要大小计算,虽然您仍需要循环并与空相比。

您可以证明这种算法不能比速度更快地录制 N, 注意到,队列中最后一个元素的信息仅通过队列大小的知识可用,并且必须销毁数据以获取此元素,因此,第二行。

更快的唯一方法 - 它根本不使用队列。


from data_structures import queue

class stack/object/:
def __init__/self/:
q1= queue
q2= queue #only contains one item at most. a temp var. /bad?/

def push/self, item/:
q1.enque/item/ #just stick it in the first queue.

#Pop is inefficient
def pop/self/:
#'spin' the queues until q1 is ready to pop the right value.
for N 0 to self.size-1
q2.enqueue/q1.dequeue/
q1.enqueue/q2.dequeue/
return q1.dequeue//

@property
def size/self/:
return q1.size + q2.size

@property
def isempty/self/:
if self.size &gt; 0:
return True
else
return False


</div>
<div class="answer_text">
这是我的决定工作 O /1/ 在中间的情况下。 有两个队列:
in


out

. 请参阅下面的pseudocode:


PUSH/X/ = in.enqueue/X/

POP: X =
if /out.isEmpty and !in.isEmpty/
DUMP/in, out/
return out.dequeue

DUMP/A, B/ =
if /!A.isEmpty/
x = A.dequeue//
DUMP/A, B/
B.enqueue/x/


</div>
<div class="answer_text">
已经提到过的,不会一来做诀窍? 这可能不太实用,但略显滑。


push/x/:
enqueue/x/
for/queueSize - 1/
enqueue/dequeue///

pop/x/:
dequeue//


</div>
<div class="answer_text">
以下是一些简单的伪代码,单击/P./, 牧师 / 看着 O/1/:


Qpush = Qinstance//
Qpop = Qinstance//

def stack.push/item/:
Qpush.add/item/
while Qpop.peek// != null: //transfer Qpop into Qpush
Qpush.add/Qpop.remove///
swap = Qpush
Qpush = Qpop
Qpop = swap

def stack.pop//:
return Qpop.remove//

def stack.peek//:
return Qpop.peek//


</div>
<div class="answer_text">
让我们 S1 和 S2 - 这些是在实现队列时将使用的两个堆栈。


struct Stack 
{ struct Queue *Q1;
struct Queue *Q2;
}


我们遵循一个队列总是空的。

手术 Push:

无论它不为空,将元素插入其中。

检查队列是否为空 Q1 或不。 如果一个 Q1 空,然后放入其中的元素。

否则 EnQueue 元素B. Q1.


Push /struct Stack *S, int data/
{
if/isEmptyQueue/S-&gt;Q1/
EnQueue/S-&gt;Q2, data/;
else EnQueue/S-&gt;Q1, data/;
}


临时复杂性: O/1/

流行活动:

播送 n-1 队列中的元素并删除用于执行操作的最后一个队列 Pop.

如果有 Q1 不空,然后转移 n-1 元素来自 Q1 在 Q2, 接着 DeQueue 最后一个元素 Q1 并返回它。

如果有 Q2 不空,然后转移 n-1 元素来自 Q2 在 Q1, 接着 DeQueue 最后一个元素 Q2 并返回它。

`


int Pop/struct Stack *S/{
int i, size;
if/IsEmptyQueue/S-&gt;Q2//
{
size=size/S-&gt;Q1/;
i=0;
while/i<size-1 enqueue="" s-="" {="">Q2, Dequeue/S-&gt;Q1// ;
i++;
}
return DeQueue/S-&gt;Q1/;
}
else{
size=size/S-&gt;Q2/;
while/i<size-1 enqueue="" s-="">Q1, Dequeue/S-&gt;Q2// ;
i++;
}
return DeQueue/S-&gt;Q2/;
} }


临时复杂性:操作时间 pop 一样 O /n/, 每次都被称为 pop, 我们将所有项目从一个队列转移到另一个队列。
</size-1></size-1></div>
<div class="answer_text">

Q1 = [10, 15, 20, 25, 30]
Q2 = []

exp:
{
dequeue n-1 element from Q1 and enqueue into Q2: Q2 == [10, 15, 20, 25]

now Q1 dequeue gives "30" that inserted last and working as stack
}

swap Q1 and Q2 then GOTO exp


</div>
<div class="answer_text">

import java.util.LinkedList;
import java.util.Queue;

class MyStack {
Queue<integer> queue1 = new LinkedList<integer>//;
Queue<integer> queue2 = new LinkedList<integer>//;

// Push element x onto stack.
public void push/int x/ {
if/isEmpty///{
queue1.offer/x/;
}else{
if/queue1.size//&gt;0/{
queue2.offer/x/;
int size = queue1.size//;
while/size&gt;0/{
queue2.offer/queue1.poll///;
size--;
}
}else if/queue2.size//&gt;0/{
queue1.offer/x/;
int size = queue2.size//;
while/size&gt;0/{
queue1.offer/queue2.poll///;
size--;
}
}
}
}

// Removes the element on top of the stack.
public void pop// {
if/queue1.size//&gt;0/{
queue1.poll//;
}else if/queue2.size//&gt;0/{
queue2.poll//;
}
}

// Get the top element. You can make it more perfect just example
public int top// {
if/queue1.size//&gt;0/{
return queue1.peek//;
}else if/queue2.size//&gt;0/{
return queue2.peek//;
}
return 0;
}

// Return whether the stack is empty.
public boolean isEmpty// {
return queue1.isEmpty// &amp;&amp; queue2.isEmpty//;
}
}


</integer></integer></integer></integer></div>
<div class="answer_text">
这是另一种解决方案:

为了 PUSH :
- 将第一个元素添加到队列 1.
- 尝试添加第二个元素等
首先将元素放在队列中 2, 然后从队列中复制整个元素 1 在队列中 2.
-为了 POP 只需从您插入最后一个元素的队列中删除项目。

所以,


public void push/int data/{
if /queue1.isEmpty///{
queue1.enqueue/data/;
} else {
queue2.enqueue/data/;
while/!queue1.isEmpty///
Queue2.enqueue/queue1.dequeue///;
//EXCHANGE THE NAMES OF QUEUE 1 and QUEUE2


}
}


public int pop//{
int popItem=queue2.dequeue//;
return popItem;
}'


有一个问题,我无法理解如何重命名队列???
</div>
<div class="answer_text">

#include <bits stdc++.h="">
using namespace std;
queue<int>Q;
stack<int>Stk;
void PRINT/stack<int>ss , queue<int>qq/ {
while/ ss.size// / {
cout &lt;&lt; ss.top// &lt;&lt; " " ;
ss.pop//;
}
puts/""/;
while/ qq.size// / {
cout &lt;&lt; qq.front// &lt;&lt; " " ;
qq.pop//;
}
puts/"\n----------------------------------"/;
}
void POP// {
queue<int>Tmp ;
while/ Q.size// &gt; 1 / {
Tmp.push/ Q.front// /;
Q.pop//;
}
cout &lt;&lt; Q.front// &lt;&lt; " " &lt;&lt; Stk.top// &lt;&lt; endl;
Q.pop// , Stk.pop// ;
Q = Tmp ;
}
void PUSH/int x / {
Q.push/x/;
Stk.push/x/;
}
int main// {
while/ true / {
string typ ;
cin &gt;&gt; typ ;
if/ typ == "push" / {
int x ;
cin &gt;&gt; x;
PUSH/x/;
} else POP//;
PRINT/Stk,Q/;
}
}


</int></int></int></int></int></bits></div>
<div class="answer_text">
有一个非常简单的解决方案,它使用一个队列并提供与堆栈这样的功能。


public class CustomStack<t>
{
Queue<t> que = new Queue<t>//;

public void push/T t/ // STACK = LIFO / QUEUE = FIFO
{

if/ que.Count == 0/
{
que.Enqueue/t/;
}
else
{
que.Enqueue/t/;
for /int i = 0; i &lt; que.Count-1; i++/
{
var data = que.Dequeue//;

que.Enqueue/data/;
}
}

}

public void pop//
{

Console.WriteLine/"\nStack Implementation:"/;
foreach /var item in que/
{
Console.Write/"\n" + item.ToString// + "\t"/;
}

var data = que.Dequeue//;
Console.Write/"\n Dequeing :" + data/;
}

public void top//
{

Console.Write/"\n Top :" + que.Peek///;
}


}


因此 , 在上面的课程中命名 "CustomStack" 我只需检查void上的队列,如果它是空的,则插入一个,从那以后插入病房,然后删除插入物。 根据这个逻辑,第一个将持续。
示例:我插入队列中 1 现在尝试插入 2. 删除第二次 1 并再次插入,所以一切都变为相反的顺序。

谢。
</t></t></t></div>
<div class="answer_text">
这是完整的工作代码 c#

:

它是在一个队列的帮助下实现的,

推:


1. add new element.
2. Remove elements from Queue /totalsize-1/ times and add back to the Queue


棉布:


normal remove





using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StackImplimentationUsingQueue
{
class Program
{
public class Node
{
public int data;
public Node link;
}
public class Queue
{
public Node rear;
public Node front;
public int size = 0;
public void EnQueue/int data/
{
Node n = new Node//;
n.data = data;
n.link = null;
if /rear == null/
front = rear = n;
else
{
rear.link = n;
rear = n;
}
size++;
Display//;
}
public Node DeQueue//
{
Node temp = new Node//;
if /front == null/
Console.WriteLine/"Empty"/;
else
{
temp = front;
front = front.link;
size--;
}
Display//;
return temp;
}
public void Display//
{
if /size == 0/
Console.WriteLine/"Empty"/;
else
{
Console.Clear//;
Node n = front;
while /n != null/
{
Console.WriteLine/n.data/;
n = n.link;
}
}
}
}
public class Stack
{
public Queue q;
public int size = 0;
public Node top;
public Stack//
{
q = new Queue//;
}
public void Push/int data/
{
Node n = new Node//;
n.data = data;
q.EnQueue/data/;
size++;
int counter = size;
while /counter &gt; 1/
{
q.EnQueue/q.DeQueue//.data/;
counter--;
}
}
public void Pop//
{
q.DeQueue//;
size--;
}
}
static void Main/string[] args/
{
Stack s= new Stack//;
for /int i = 1; i &lt;= 3; i++/
s.Push/i/;
for /int i = 1; i &lt; 3; i++/
s.Pop//;
Console.ReadKey//;
}
}
}


</div>
<div class="answer_text">
Python 代码只使用一圈


class Queue/object/:
def __init__/self/:
self.items=[]
def enqueue/self,item/:
self.items.insert/0,item/
def dequeue/self/:
if/not self.isEmpty///:
return self.items.pop//
def isEmpty/self/:
return self.items==[]
def size/self/:
return len/self.items/



class stack/object/:
def __init__/self/:
self.q1= Queue//


def push/self, item/:
self.q1.enqueue/item/


def pop/self/:
c=self.q1.size//
while/c&gt;1/:
self.q1.enqueue/self.q1.dequeue///
c-=1
return self.q1.dequeue//



def size/self/:
return self.q1.size//


def isempty/self/:
if self.size &gt; 0:
return True
else:
return False


</div>
<div class="answer_text">
以下是一个非常简单的解决方案 Java, 支持有效的工作 push.

算法

-

宣布两个队列 q1 和 q2.

新闻操作 - 在队列中添加一个元素 Q1.

弹出队确保队列 q2 不是空的。 如果它是空的
然后从队列中删除所有元素 q1, 除了最后一个元素,还是
把它放在队列中 q2 按顺序。 删除最后一个元素 Q1 和
将其保存为毫无根据的元素。 依次改变地点 q1 和 q2. 可信
保存的弹出元素。

作品看 - 确保 2 这一季度不空。 如果它是空的
然后从队列中删除所有元素 q1, 除了最后一个元素,还是
把它放在队列中 q2 按顺序。 删除最后一个元素 Q1 和
将其保存为屏蔽元素。 把它回到队列 q2 并改变
转弯 q1 和 q2. 返回已保存的窗口元素。

以下是上述算法的代码 -


class MyStack {

java.util.Queue<integer> q1;
java.util.Queue<integer> q2;
int SIZE = 0;

/** Initialize your data structure here. */
public MyStack// {
q1 = new LinkedList<integer>//;
q2 = new LinkedList<integer>//;

}

/** Push element x onto stack. */
public void push/int x/ {
q1.add/x/;
SIZE ++;

}

/** Removes the element on top of the stack and returns that element. */
public int pop// {
ensureQ2IsNotEmpty//;
int poppedEle = q1.remove//;
SIZE--;
swapQueues//;
return poppedEle;
}

/** Get the top element. */
public int top// {
ensureQ2IsNotEmpty//;
int peekedEle = q1.remove//;
q2.add/peekedEle/;
swapQueues//;
return peekedEle;
}

/** Returns whether the stack is empty. */
public boolean empty// {
return q1.isEmpty// &amp;&amp; q2.isEmpty//;

}

/** move all elements from q1 to q2 except last element */
public void ensureQ2IsNotEmpty// {
for/int i=0; i<size-1; *="" **="" ;="" and="" i++="" public="" q1="" q1.remove="" q2="" q2.add="" queue<integer="" queues="" swap="" swapqueues="" void="" {="" }=""> temp = q1;
q1 = q2;
q2 = temp;
}
}


</size-1;></integer></integer></integer></integer></div>
<div class="answer_text">
这是我的决定..

Concept_Behind::
push/struct Stack* S,int data/

:: 此功能将第一个元素放在队列中 Q1 和 rest 在 Q2
pop/struct Stack* S/

:: 如果一个 Q2 不为空,然后转移所有元素 Q1 并返回最后一个元素 Q2
else /这意味着什么 Q2 空的 / 转移所有元素 Q2 并返回最后一个元素 Q1

Efficiency_Behind::
push/struct Stack*S,int data/

::关于/1///从一个数据中的一个房间
pop/struct Stack* S/

::关于/N///由于这是最糟糕的 n-1 流行中的信息。


#include<stdio.h>
#include<stdlib.h>
struct Queue{
int front;
int rear;
int *arr;
int size;
};
struct Stack {
struct Queue *Q1;
struct Queue *Q2;
};
struct Queue* Qconstructor/int capacity/
{
struct Queue *Q=malloc/sizeof/struct Queue//;
Q-&gt;front=Q-&gt;rear=-1;
Q-&gt;size=capacity;
Q-&gt;arr=malloc/Q-&gt;size*sizeof/int//;
return Q;
}
int isEmptyQueue/struct Queue *Q/
{
return /Q-&gt;front==-1/;
}
int isFullQueue/struct Queue *Q/
{
return //Q-&gt;rear+1/ % Q-&gt;size ==Q-&gt;front/;
}
void enqueue/struct Queue *Q,int data/
{
if/isFullQueue/Q//
{
printf/"Queue overflow\n"/;
return;}
Q-&gt;rear=Q-&gt;rear+1 % Q-&gt;size;
Q-&gt;arr[Q-&gt;rear]=data;
if/Q-&gt;front==-1/
Q-&gt;front=Q-&gt;rear;
}
int dequeue/struct Queue *Q/
{
if/isEmptyQueue/Q//{
printf/"Queue underflow\n"/;
return;
}
int data=Q-&gt;arr[Q-&gt;front];
if/Q-&gt;front==Q-&gt;rear/
Q-&gt;front=-1;
else
Q-&gt;front=Q-&gt;front+1 % Q-&gt;size;
return data;
}
///////////////////////*************main algo****************////////////////////////
struct Stack* Sconstructor/int capacity/
{
struct Stack *S=malloc/sizeof/struct Stack//;
S-&gt;Q1=Qconstructor/capacity/;
S-&gt;Q2=Qconstructor/capacity/;
return S;
}
void push/struct Stack *S,int data/
{
if/isEmptyQueue/S-&gt;Q1//
enqueue/S-&gt;Q1,data/;
else
enqueue/S-&gt;Q2,data/;
}
int pop/struct Stack *S/
{
int i,tmp;
if/!isEmptyQueue/S-&gt;Q2//{
for/i=S-&gt;Q2-&gt;front;i&lt;=S-&gt;Q2-&gt;rear;i++/{
tmp=dequeue/S-&gt;Q2/;
if/isEmptyQueue/S-&gt;Q2//
return tmp;
else
enqueue/S-&gt;Q1,tmp/;
}
}
else{
for/i=S-&gt;Q1-&gt;front;i&lt;=S-&gt;Q1-&gt;rear;i++/{
tmp=dequeue/S-&gt;Q1/;
if/isEmptyQueue/S-&gt;Q1//
return tmp;
else
enqueue/S-&gt;Q2,tmp/;
}
}
}
////////////////*************end of main algo my algo************
///////////////*************push// O/1/;;;;pop// O/n/;;;;*******/////
main//
{
int size;
printf/"Enter the number of elements in the Stack/made of 2 queue's/::\n"/;
scanf/"%d",&amp;size/;
struct Stack *S=Sconstructor/size/;
push/S,1/;
push/S,2/;
push/S,3/;
push/S,4/;
printf/"%d\n",pop/S//;
push/S,5/;
printf/"%d\n",pop/S//;
printf/"%d\n",pop/S//;
printf/"%d\n",pop/S//;
printf/"%d\n",pop/S//;
}


</stdlib.h></stdio.h></div>
<div class="answer_text">

import java.util.LinkedList;
import java.util.Queue;


public class StackQueue {

static Queue<integer> Q1 = new LinkedList<integer>//;
static Queue<integer> Q2 = new LinkedList<integer>//;
public static void main/String args[]/ {



push/24/;
push/34/;
push/4/;
push/10/;
push/1/;
push/43/;
push/21/;
System.out.println/"Popped element is "+pop///;
System.out.println/"Popped element is "+pop///;
System.out.println/"Popped element is "+pop///;


}

public static void push/int data/ {

Q1.add/data/;

}

public static int pop// {

if/Q1.isEmpty/// {
System.out.println/"Cannot pop elements , Stack is Empty !!"/;
return -1;
}
else
{
while/Q1.size// &gt; 1/ {
Q2.add/Q1.remove///;
}
int element = Q1.remove//;
Queue<integer> temp = new LinkedList<integer>//;
temp = Q1;
Q1 = Q2;
Q2 = temp;
return element;
}
}
}


</integer></integer></integer></integer></integer></integer></div>
<div class="answer_text">

#include "stdio.h"
#include "stdlib.h"

typedef struct {
int *q;
int size;
int front;
int rear;
} Queue;
typedef struct {
Queue *q1;
Queue *q2;
} Stack;

int queueIsEmpty/Queue *q/ {
if /q-&gt;front == -1 &amp;&amp; q-&gt;rear == -1/ {
printf/"\nQUEUE is EMPTY\n"/;
return 1;
}
return 0;
}
int queueIsFull/Queue *q/ {
if /q-&gt;rear == q-&gt;size-1/ {
return 1;
}
return 0;
}
int queueTop/Queue *q/ {
if /queueIsEmpty/q// {
return -1;
}
return q-&gt;q[q-&gt;front];
}
int queuePop/Queue *q/ {
if /queueIsEmpty/q// {
return -1;
}
int item = q-&gt;q[q-&gt;front];
if /q-&gt;front == q-&gt;rear/ {
q-&gt;front = q-&gt;rear = -1;
}
else {
q-&gt;front++;
}
return item;
}
void queuePush/Queue *q, int val/ {
if /queueIsFull/q// {
printf/"\nQUEUE is FULL\n"/;
return;
}
if /queueIsEmpty/q// {
q-&gt;front++;
q-&gt;rear++;
} else {
q-&gt;rear++;
}
q-&gt;q[q-&gt;rear] = val;
}
Queue *queueCreate/int maxSize/ {
Queue *q = /Queue*/malloc/sizeof/Queue//;
q-&gt;front = q-&gt;rear = -1;
q-&gt;size = maxSize;
q-&gt;q = /int*/malloc/sizeof/int/*maxSize/;
return q;
}
/* Create a stack */
void stackCreate/Stack *stack, int maxSize/ {
Stack **s = /Stack**/ stack;
*s = /Stack*/malloc/sizeof/Stack//;
/*s/-&gt;q1 = queueCreate/maxSize/;
/*s/-&gt;q2 = queueCreate/maxSize/;
}

/* Push element x onto stack */
void stackPush/Stack *stack, int element/ {
Stack **s = /Stack**/ stack;
queuePush//*s/-&gt;q2, element/;
while /!queueIsEmpty//*s/-&gt;q1// {
int item = queuePop//*s/-&gt;q1/;
queuePush//*s/-&gt;q2, item/;
}
Queue *tmp = /*s/-&gt;q1;
/*s/-&gt;q1 = /*s/-&gt;q2;
/*s/-&gt;q2 = tmp;
}

/* Removes the element on top of the stack */
void stackPop/Stack *stack/ {
Stack **s = /Stack**/ stack;
queuePop//*s/-&gt;q1/;
}

/* Get the top element */
int stackTop/Stack *stack/ {
Stack **s = /Stack**/ stack;
if /!queueIsEmpty//*s/-&gt;q1// {
return queueTop//*s/-&gt;q1/;
}
return -1;
}

/* Return whether the stack is empty */
bool stackEmpty/Stack *stack/ {
Stack **s = /Stack**/ stack;
if /queueIsEmpty//*s/-&gt;q1// {
return true;
}
return false;
}

/* Destroy the stack */
void stackDestroy/Stack *stack/ {
Stack **s = /Stack**/ stack;
free//*s/-&gt;q1/;
free//*s/-&gt;q2/;
free//*s//;
}

int main//
{
Stack *s = NULL;
stackCreate//Stack*/&amp;s, 10/;
stackPush//Stack*/&amp;s, 44/;
//stackPop//Stack*/&amp;s/;
printf/"\n%d", stackTop//Stack*/&amp;s//;
stackDestroy//Stack*/&amp;s/;
return 0;
}


</div>
</old_count;>

窦买办

赞同来自:

import java.util.*;

/**
*
* @author Mahmood
*/
public class StackImplUsingQueues {

Queue<integer> q1 = new LinkedList<integer>//;
Queue<integer> q2 = new LinkedList<integer>//;

public int pop// {
if /q1.peek// == null/ {
System.out.println/"The stack is empty, nothing to return"/;
int i = 0;
return i;
} else {
int pop = q1.remove//;
return pop;
}
}

public void push/int data/ {

if /q1.peek// == null/ {
q1.add/data/;
} else {
for /int i = q1.size//; i &gt; 0; i--/ {
q2.add/q1.remove///;
}
q1.add/data/;
for /int j = q2.size//; j &gt; 0; j--/ {
q1.add/q2.remove///;
}

}
}

public static void main/String[] args/ {
StackImplUsingQueues s1 = new StackImplUsingQueues//;
// Stack s1 = new Stack//;
s1.push/1/;
s1.push/2/;
s1.push/3/;
s1.push/4/;
s1.push/5/;
s1.push/6/;
s1.push/7/;
s1.push/8/;
s1.push/9/;
s1.push/10/;
// s1.push/6/;
System.out.println/"1st = " + s1.pop///;
System.out.println/"2nd = " + s1.pop///;
System.out.println/"3rd = " + s1.pop///;
System.out.println/"4th = " + s1.pop///;
System.out.println/"5th = " + s1.pop///;
System.out.println/"6th = " + s1.pop///;
System.out.println/"7th = " + s1.pop///;
System.out.println/"8th = " + s1.pop///;
System.out.println/"9th = " + s1.pop///;
System.out.println/"10th= " + s1.pop///;
}
}


</integer></integer></integer></integer>

莫问

赞同来自:

我们可以使用一圈实现堆栈吗? 我可以使用两个队列,但考虑一个队列会更有效率。 这是代码:


public void Push/T val/
{
queLower.Enqueue/val/;
}

public T Pop//
{

if /queLower.Count == 0 /
{
Console.Write/"Stack is empty!"/;
return default/T/;

}
if /queLower.Count > 0/
{
for /int i = 0; i < queLower.Count - 1;i++ /
{
queLower.Enqueue/queLower.Dequeue ///;
}
}

return queLower.Dequeue//;

}

知食

赞同来自:

queue<int> q1, q2;
int i = 0;

void push/int v/ {
if/ q1.empty// &amp;&amp; q2.empty// / {
q1.push/v/;
i = 0;
}
else {
if/ i == 0 / {
while/ !q1.empty// / q2.push/q1.pop///;
q1.push/v/;
i = 1-i;
}
else {
while/ !q2.empty// / q1.push/q2.pop///;
q2.push/v/;
i = 1-i;
}
}
}

int pop// {
if/ q1.empty// &amp;&amp; q2.empty// / return -1;
if/ i == 1 / {
if/ !q1.empty// /
return q1.pop//;
else if/ !q2.empty// /
return q2.pop//;
}
else {
if/ !q2.empty// /
return q2.pop//;
else if/ !q1.empty// /
return q1.pop//;
}
}


</int>

八刀丁二

赞同来自:

这是我的答案,在哪里 'pop' 无效。
似乎立即想到的所有算法都有 N n大小列表的困难:您决定工作吗? 'pop' 或工作 'push'

算法在回来并继续前进的地方可能会更好
由于不需要大小计算,虽然您仍需要循环并与空相比。

您可以证明这种算法不能比速度更快地录制 N, 注意到,队列中最后一个元素的信息仅通过队列大小的知识可用,并且必须销毁数据以获取此元素,因此,第二行。

更快的唯一方法 - 它根本不使用队列。


from data_structures import queue

class stack/object/:
def __init__/self/:
q1= queue
q2= queue #only contains one item at most. a temp var. /bad?/

def push/self, item/:
q1.enque/item/ #just stick it in the first queue.

#Pop is inefficient
def pop/self/:
#'spin' the queues until q1 is ready to pop the right value.
for N 0 to self.size-1
q2.enqueue/q1.dequeue/
q1.enqueue/q2.dequeue/
return q1.dequeue//

@property
def size/self/:
return q1.size + q2.size

@property
def isempty/self/:
if self.size > 0:
return True
else
return False

君笑尘

赞同来自:

这是我的决定工作 O /1/ 在中间的情况下。 有两个队列:
in


out

. 请参阅下面的pseudocode:


PUSH/X/ = in.enqueue/X/

POP: X =
if /out.isEmpty and !in.isEmpty/
DUMP/in, out/
return out.dequeue

DUMP/A, B/ =
if /!A.isEmpty/
x = A.dequeue//
DUMP/A, B/
B.enqueue/x/

喜特乐

赞同来自:

已经提到过的,不会一来做诀窍? 这可能不太实用,但略显滑。


push/x/:
enqueue/x/
for/queueSize - 1/
enqueue/dequeue///

pop/x/:
dequeue//

奔跑吧少年

赞同来自:

以下是一些简单的伪代码,单击/P./, 牧师 / 看着 O/1/:


Qpush = Qinstance//
Qpop = Qinstance//

def stack.push/item/:
Qpush.add/item/
while Qpop.peek// != null: //transfer Qpop into Qpush
Qpush.add/Qpop.remove///
swap = Qpush
Qpush = Qpop
Qpop = swap

def stack.pop//:
return Qpop.remove//

def stack.peek//:
return Qpop.peek//

快网

赞同来自:

让我们 S1 和 S2 - 这些是在实现队列时将使用的两个堆栈。


struct Stack 
{ struct Queue *Q1;
struct Queue *Q2;
}


我们遵循一个队列总是空的。

手术 Push:

无论它不为空,将元素插入其中。

检查队列是否为空 Q1 或不。 如果一个 Q1 空,然后放入其中的元素。

否则 EnQueue 元素B. Q1.


Push /struct Stack *S, int data/
{
if/isEmptyQueue/S->Q1/
EnQueue/S->Q2, data/;
else EnQueue/S->Q1, data/;
}


临时复杂性: O/1/

流行活动:

播送 n-1 队列中的元素并删除用于执行操作的最后一个队列 Pop.

如果有 Q1 不空,然后转移 n-1 元素来自 Q1 在 Q2, 接着 DeQueue 最后一个元素 Q1 并返回它。

如果有 Q2 不空,然后转移 n-1 元素来自 Q2 在 Q1, 接着 DeQueue 最后一个元素 Q2 并返回它。

`


int Pop/struct Stack *S/{
int i, size;
if/IsEmptyQueue/S->Q2//
{
size=size/S->Q1/;
i=0;
while/i<size-1 enqueue="" s-="" {="">Q2, Dequeue/S-&gt;Q1// ;
i++;
}
return DeQueue/S-&gt;Q1/;
}
else{
size=size/S-&gt;Q2/;
while/i<size-1 enqueue="" s-="">Q1, Dequeue/S-&gt;Q2// ;
i++;
}
return DeQueue/S-&gt;Q2/;
} }


临时复杂性:操作时间 pop 一样 O /n/, 每次都被称为 pop, 我们将所有项目从一个队列转移到另一个队列。
</size-1></size-1>

郭文康

赞同来自:

Q1 = [10, 15, 20, 25, 30]
Q2 = []

exp:
{
dequeue n-1 element from Q1 and enqueue into Q2: Q2 == [10, 15, 20, 25]

now Q1 dequeue gives "30" that inserted last and working as stack
}

swap Q1 and Q2 then GOTO exp

卫东

赞同来自:

import java.util.LinkedList;
import java.util.Queue;

class MyStack {
Queue<integer> queue1 = new LinkedList<integer>//;
Queue<integer> queue2 = new LinkedList<integer>//;

// Push element x onto stack.
public void push/int x/ {
if/isEmpty///{
queue1.offer/x/;
}else{
if/queue1.size//&gt;0/{
queue2.offer/x/;
int size = queue1.size//;
while/size&gt;0/{
queue2.offer/queue1.poll///;
size--;
}
}else if/queue2.size//&gt;0/{
queue1.offer/x/;
int size = queue2.size//;
while/size&gt;0/{
queue1.offer/queue2.poll///;
size--;
}
}
}
}

// Removes the element on top of the stack.
public void pop// {
if/queue1.size//&gt;0/{
queue1.poll//;
}else if/queue2.size//&gt;0/{
queue2.poll//;
}
}

// Get the top element. You can make it more perfect just example
public int top// {
if/queue1.size//&gt;0/{
return queue1.peek//;
}else if/queue2.size//&gt;0/{
return queue2.peek//;
}
return 0;
}

// Return whether the stack is empty.
public boolean isEmpty// {
return queue1.isEmpty// &amp;&amp; queue2.isEmpty//;
}
}


</integer></integer></integer></integer>

三叔

赞同来自:

这是另一种解决方案:

为了 PUSH :
- 将第一个元素添加到队列 1.
- 尝试添加第二个元素等
首先将元素放在队列中 2, 然后从队列中复制整个元素 1 在队列中 2.
-为了 POP 只需从您插入最后一个元素的队列中删除项目。

所以,


public void push/int data/{
if /queue1.isEmpty///{
queue1.enqueue/data/;
} else {
queue2.enqueue/data/;
while/!queue1.isEmpty///
Queue2.enqueue/queue1.dequeue///;
//EXCHANGE THE NAMES OF QUEUE 1 and QUEUE2


}
}


public int pop//{
int popItem=queue2.dequeue//;
return popItem;
}'


有一个问题,我无法理解如何重命名队列???

二哥

赞同来自:

#include <bits stdc++.h="">
using namespace std;
queue<int>Q;
stack<int>Stk;
void PRINT/stack<int>ss , queue<int>qq/ {
while/ ss.size// / {
cout &lt;&lt; ss.top// &lt;&lt; " " ;
ss.pop//;
}
puts/""/;
while/ qq.size// / {
cout &lt;&lt; qq.front// &lt;&lt; " " ;
qq.pop//;
}
puts/"\n----------------------------------"/;
}
void POP// {
queue<int>Tmp ;
while/ Q.size// &gt; 1 / {
Tmp.push/ Q.front// /;
Q.pop//;
}
cout &lt;&lt; Q.front// &lt;&lt; " " &lt;&lt; Stk.top// &lt;&lt; endl;
Q.pop// , Stk.pop// ;
Q = Tmp ;
}
void PUSH/int x / {
Q.push/x/;
Stk.push/x/;
}
int main// {
while/ true / {
string typ ;
cin &gt;&gt; typ ;
if/ typ == "push" / {
int x ;
cin &gt;&gt; x;
PUSH/x/;
} else POP//;
PRINT/Stk,Q/;
}
}


</int></int></int></int></int></bits>

冰洋

赞同来自:

有一个非常简单的解决方案,它使用一个队列并提供与堆栈这样的功能。


public class CustomStack<t>
{
Queue<t> que = new Queue<t>//;

public void push/T t/ // STACK = LIFO / QUEUE = FIFO
{

if/ que.Count == 0/
{
que.Enqueue/t/;
}
else
{
que.Enqueue/t/;
for /int i = 0; i &lt; que.Count-1; i++/
{
var data = que.Dequeue//;

que.Enqueue/data/;
}
}

}

public void pop//
{

Console.WriteLine/"\nStack Implementation:"/;
foreach /var item in que/
{
Console.Write/"\n" + item.ToString// + "\t"/;
}

var data = que.Dequeue//;
Console.Write/"\n Dequeing :" + data/;
}

public void top//
{

Console.Write/"\n Top :" + que.Peek///;
}


}


因此 , 在上面的课程中命名 "CustomStack" 我只需检查void上的队列,如果它是空的,则插入一个,从那以后插入病房,然后删除插入物。 根据这个逻辑,第一个将持续。
示例:我插入队列中 1 现在尝试插入 2. 删除第二次 1 并再次插入,所以一切都变为相反的顺序。

谢。
</t></t></t>

奔跑吧少年

赞同来自:

这是完整的工作代码 c#

:

它是在一个队列的帮助下实现的,

推:


1. add new element.
2. Remove elements from Queue /totalsize-1/ times and add back to the Queue


棉布:


normal remove





using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StackImplimentationUsingQueue
{
class Program
{
public class Node
{
public int data;
public Node link;
}
public class Queue
{
public Node rear;
public Node front;
public int size = 0;
public void EnQueue/int data/
{
Node n = new Node//;
n.data = data;
n.link = null;
if /rear == null/
front = rear = n;
else
{
rear.link = n;
rear = n;
}
size++;
Display//;
}
public Node DeQueue//
{
Node temp = new Node//;
if /front == null/
Console.WriteLine/"Empty"/;
else
{
temp = front;
front = front.link;
size--;
}
Display//;
return temp;
}
public void Display//
{
if /size == 0/
Console.WriteLine/"Empty"/;
else
{
Console.Clear//;
Node n = front;
while /n != null/
{
Console.WriteLine/n.data/;
n = n.link;
}
}
}
}
public class Stack
{
public Queue q;
public int size = 0;
public Node top;
public Stack//
{
q = new Queue//;
}
public void Push/int data/
{
Node n = new Node//;
n.data = data;
q.EnQueue/data/;
size++;
int counter = size;
while /counter > 1/
{
q.EnQueue/q.DeQueue//.data/;
counter--;
}
}
public void Pop//
{
q.DeQueue//;
size--;
}
}
static void Main/string[] args/
{
Stack s= new Stack//;
for /int i = 1; i <= 3; i++/
s.Push/i/;
for /int i = 1; i < 3; i++/
s.Pop//;
Console.ReadKey//;
}
}
}

莫问

赞同来自:

Python 代码只使用一圈


class Queue/object/:
def __init__/self/:
self.items=[]
def enqueue/self,item/:
self.items.insert/0,item/
def dequeue/self/:
if/not self.isEmpty///:
return self.items.pop//
def isEmpty/self/:
return self.items==[]
def size/self/:
return len/self.items/



class stack/object/:
def __init__/self/:
self.q1= Queue//


def push/self, item/:
self.q1.enqueue/item/


def pop/self/:
c=self.q1.size//
while/c>1/:
self.q1.enqueue/self.q1.dequeue///
c-=1
return self.q1.dequeue//



def size/self/:
return self.q1.size//


def isempty/self/:
if self.size > 0:
return True
else:
return False

风见雨下

赞同来自:

以下是一个非常简单的解决方案 Java, 支持有效的工作 push.

算法

-

宣布两个队列 q1 和 q2.

新闻操作 - 在队列中添加一个元素 Q1.

弹出队确保队列 q2 不是空的。 如果它是空的
然后从队列中删除所有元素 q1, 除了最后一个元素,还是
把它放在队列中 q2 按顺序。 删除最后一个元素 Q1 和
将其保存为毫无根据的元素。 依次改变地点 q1 和 q2. 可信
保存的弹出元素。

作品看 - 确保 2 这一季度不空。 如果它是空的
然后从队列中删除所有元素 q1, 除了最后一个元素,还是
把它放在队列中 q2 按顺序。 删除最后一个元素 Q1 和
将其保存为屏蔽元素。 把它回到队列 q2 并改变
转弯 q1 和 q2. 返回已保存的窗口元素。

以下是上述算法的代码 -


class MyStack {

java.util.Queue<integer> q1;
java.util.Queue<integer> q2;
int SIZE = 0;

/** Initialize your data structure here. */
public MyStack// {
q1 = new LinkedList<integer>//;
q2 = new LinkedList<integer>//;

}

/** Push element x onto stack. */
public void push/int x/ {
q1.add/x/;
SIZE ++;

}

/** Removes the element on top of the stack and returns that element. */
public int pop// {
ensureQ2IsNotEmpty//;
int poppedEle = q1.remove//;
SIZE--;
swapQueues//;
return poppedEle;
}

/** Get the top element. */
public int top// {
ensureQ2IsNotEmpty//;
int peekedEle = q1.remove//;
q2.add/peekedEle/;
swapQueues//;
return peekedEle;
}

/** Returns whether the stack is empty. */
public boolean empty// {
return q1.isEmpty// &amp;&amp; q2.isEmpty//;

}

/** move all elements from q1 to q2 except last element */
public void ensureQ2IsNotEmpty// {
for/int i=0; i<size-1; *="" **="" ;="" and="" i++="" public="" q1="" q1.remove="" q2="" q2.add="" queue<integer="" queues="" swap="" swapqueues="" void="" {="" }=""> temp = q1;
q1 = q2;
q2 = temp;
}
}


</size-1;></integer></integer></integer></integer>

莫问

赞同来自:

这是我的决定..

Concept_Behind::
push/struct Stack* S,int data/

:: 此功能将第一个元素放在队列中 Q1 和 rest 在 Q2
pop/struct Stack* S/

:: 如果一个 Q2 不为空,然后转移所有元素 Q1 并返回最后一个元素 Q2
else /这意味着什么 Q2 空的 / 转移所有元素 Q2 并返回最后一个元素 Q1

Efficiency_Behind::
push/struct Stack*S,int data/

::关于/1///从一个数据中的一个房间
pop/struct Stack* S/

::关于/N///由于这是最糟糕的 n-1 流行中的信息。


#include<stdio.h>
#include<stdlib.h>
struct Queue{
int front;
int rear;
int *arr;
int size;
};
struct Stack {
struct Queue *Q1;
struct Queue *Q2;
};
struct Queue* Qconstructor/int capacity/
{
struct Queue *Q=malloc/sizeof/struct Queue//;
Q-&gt;front=Q-&gt;rear=-1;
Q-&gt;size=capacity;
Q-&gt;arr=malloc/Q-&gt;size*sizeof/int//;
return Q;
}
int isEmptyQueue/struct Queue *Q/
{
return /Q-&gt;front==-1/;
}
int isFullQueue/struct Queue *Q/
{
return //Q-&gt;rear+1/ % Q-&gt;size ==Q-&gt;front/;
}
void enqueue/struct Queue *Q,int data/
{
if/isFullQueue/Q//
{
printf/"Queue overflow\n"/;
return;}
Q-&gt;rear=Q-&gt;rear+1 % Q-&gt;size;
Q-&gt;arr[Q-&gt;rear]=data;
if/Q-&gt;front==-1/
Q-&gt;front=Q-&gt;rear;
}
int dequeue/struct Queue *Q/
{
if/isEmptyQueue/Q//{
printf/"Queue underflow\n"/;
return;
}
int data=Q-&gt;arr[Q-&gt;front];
if/Q-&gt;front==Q-&gt;rear/
Q-&gt;front=-1;
else
Q-&gt;front=Q-&gt;front+1 % Q-&gt;size;
return data;
}
///////////////////////*************main algo****************////////////////////////
struct Stack* Sconstructor/int capacity/
{
struct Stack *S=malloc/sizeof/struct Stack//;
S-&gt;Q1=Qconstructor/capacity/;
S-&gt;Q2=Qconstructor/capacity/;
return S;
}
void push/struct Stack *S,int data/
{
if/isEmptyQueue/S-&gt;Q1//
enqueue/S-&gt;Q1,data/;
else
enqueue/S-&gt;Q2,data/;
}
int pop/struct Stack *S/
{
int i,tmp;
if/!isEmptyQueue/S-&gt;Q2//{
for/i=S-&gt;Q2-&gt;front;i&lt;=S-&gt;Q2-&gt;rear;i++/{
tmp=dequeue/S-&gt;Q2/;
if/isEmptyQueue/S-&gt;Q2//
return tmp;
else
enqueue/S-&gt;Q1,tmp/;
}
}
else{
for/i=S-&gt;Q1-&gt;front;i&lt;=S-&gt;Q1-&gt;rear;i++/{
tmp=dequeue/S-&gt;Q1/;
if/isEmptyQueue/S-&gt;Q1//
return tmp;
else
enqueue/S-&gt;Q2,tmp/;
}
}
}
////////////////*************end of main algo my algo************
///////////////*************push// O/1/;;;;pop// O/n/;;;;*******/////
main//
{
int size;
printf/"Enter the number of elements in the Stack/made of 2 queue's/::\n"/;
scanf/"%d",&amp;size/;
struct Stack *S=Sconstructor/size/;
push/S,1/;
push/S,2/;
push/S,3/;
push/S,4/;
printf/"%d\n",pop/S//;
push/S,5/;
printf/"%d\n",pop/S//;
printf/"%d\n",pop/S//;
printf/"%d\n",pop/S//;
printf/"%d\n",pop/S//;
}


</stdlib.h></stdio.h>

董宝中

赞同来自:

import java.util.LinkedList;
import java.util.Queue;


public class StackQueue {

static Queue<integer> Q1 = new LinkedList<integer>//;
static Queue<integer> Q2 = new LinkedList<integer>//;
public static void main/String args[]/ {



push/24/;
push/34/;
push/4/;
push/10/;
push/1/;
push/43/;
push/21/;
System.out.println/"Popped element is "+pop///;
System.out.println/"Popped element is "+pop///;
System.out.println/"Popped element is "+pop///;


}

public static void push/int data/ {

Q1.add/data/;

}

public static int pop// {

if/Q1.isEmpty/// {
System.out.println/"Cannot pop elements , Stack is Empty !!"/;
return -1;
}
else
{
while/Q1.size// &gt; 1/ {
Q2.add/Q1.remove///;
}
int element = Q1.remove//;
Queue<integer> temp = new LinkedList<integer>//;
temp = Q1;
Q1 = Q2;
Q2 = temp;
return element;
}
}
}


</integer></integer></integer></integer></integer></integer>

石油百科

赞同来自:

#include "stdio.h"
#include "stdlib.h"

typedef struct {
int *q;
int size;
int front;
int rear;
} Queue;
typedef struct {
Queue *q1;
Queue *q2;
} Stack;

int queueIsEmpty/Queue *q/ {
if /q->front == -1 && q->rear == -1/ {
printf/"\nQUEUE is EMPTY\n"/;
return 1;
}
return 0;
}
int queueIsFull/Queue *q/ {
if /q->rear == q->size-1/ {
return 1;
}
return 0;
}
int queueTop/Queue *q/ {
if /queueIsEmpty/q// {
return -1;
}
return q->q[q->front];
}
int queuePop/Queue *q/ {
if /queueIsEmpty/q// {
return -1;
}
int item = q->q[q->front];
if /q->front == q->rear/ {
q->front = q->rear = -1;
}
else {
q->front++;
}
return item;
}
void queuePush/Queue *q, int val/ {
if /queueIsFull/q// {
printf/"\nQUEUE is FULL\n"/;
return;
}
if /queueIsEmpty/q// {
q->front++;
q->rear++;
} else {
q->rear++;
}
q->q[q->rear] = val;
}
Queue *queueCreate/int maxSize/ {
Queue *q = /Queue*/malloc/sizeof/Queue//;
q->front = q->rear = -1;
q->size = maxSize;
q->q = /int*/malloc/sizeof/int/*maxSize/;
return q;
}
/* Create a stack */
void stackCreate/Stack *stack, int maxSize/ {
Stack **s = /Stack**/ stack;
*s = /Stack*/malloc/sizeof/Stack//;
/*s/->q1 = queueCreate/maxSize/;
/*s/->q2 = queueCreate/maxSize/;
}

/* Push element x onto stack */
void stackPush/Stack *stack, int element/ {
Stack **s = /Stack**/ stack;
queuePush//*s/->q2, element/;
while /!queueIsEmpty//*s/->q1// {
int item = queuePop//*s/->q1/;
queuePush//*s/->q2, item/;
}
Queue *tmp = /*s/->q1;
/*s/->q1 = /*s/->q2;
/*s/->q2 = tmp;
}

/* Removes the element on top of the stack */
void stackPop/Stack *stack/ {
Stack **s = /Stack**/ stack;
queuePop//*s/->q1/;
}

/* Get the top element */
int stackTop/Stack *stack/ {
Stack **s = /Stack**/ stack;
if /!queueIsEmpty//*s/->q1// {
return queueTop//*s/->q1/;
}
return -1;
}

/* Return whether the stack is empty */
bool stackEmpty/Stack *stack/ {
Stack **s = /Stack**/ stack;
if /queueIsEmpty//*s/->q1// {
return true;
}
return false;
}

/* Destroy the stack */
void stackDestroy/Stack *stack/ {
Stack **s = /Stack**/ stack;
free//*s/->q1/;
free//*s/->q2/;
free//*s//;
}

int main//
{
Stack *s = NULL;
stackCreate//Stack*/&s, 10/;
stackPush//Stack*/&s, 44/;
//stackPop//Stack*/&s/;
printf/"\n%d", stackTop//Stack*/&s//;
stackDestroy//Stack*/&s/;
return 0;
}

要回复问题请先登录注册