两个栈实现一个队列

题目描述：

用两个栈来实现一个队列，完成队列的Push和Pop操作。
队列中的元素为int类型。

输入：

每个输入文件包含一个测试样例。
对于每个测试样例，第一行输入一个n(1<=n<=100000)，代表队列操作的个数。
接下来的n行，每行输入一个队列操作：
1. PUSH X 向队列中push一个整数x(x>=0)
2. POP 从队列中pop一个数。

输出：

对应每个测试案例，打印所有pop操作中从队列pop中的数字。如果执行pop操作时，队列为空，则打印-1。

样例输入：

3
PUSH 10
POP
POP

样例输出：

10
-1

  AC代码如下：

[cpp] view plain copy print ?

1. #include<stdio.h>  
2. #include<stdlib.h>  
3. #include<string.h>  
4. #include<stdbool.h>  
5.   
6. typedef struct Node  
7. {  
8.     int data;  
9.     struct Node *pNext;  
10. }NODE,*PNODE;  
11.   
12. typedef struct Stack  
13. {  
14.     PNODE pTop;  
15.     PNODE pBottom;  
16. }STACK,*PSTACK;  
17.   
18. PSTACK create_stack();  
19. void push_stack(PSTACK,int);  
20. void traverse_stack(PSTACK);  
21. bool pop_stack(PSTACK,int *);  
22. bool is_empty(PSTACK);  
23. void clear_stack(PSTACK);  
24. void enter_Queue(PSTACK,int);  
25. bool delete_Queue(PSTACK,PSTACK,int *);  
26.   
27. int main()  
28. {     
29.     int n;      //保存操纵的个数  
30.     int data;   //保存输入的要push的元素  
31.     int pData;  //保存pop出来的元素  
32.     char *push = "PUSH";  
33.     char *pop = "POP";  
34.     char input[5];  
35.     int data_pop;  
36.   
37.     //创建两个空栈  
38.     PSTACK pS1 = create_stack();  
39.     PSTACK pS2 = create_stack();  
40.     scanf("%d",&n);  
41.     while(n-->0)  
42.     {  
43.         scanf("%s",input);  
44.         if(strcmp(input,push) == 0)  
45.         {  
46.             scanf("%d",&data);  
47.             enter_Queue(pS1,data);  
48.         }  
49.         if(strcmp(input,pop) == 0)  
50.         {  
51.             if(delete_Queue(pS1,pS2,&pData))  
52.                 printf("%d\n",pData);  
53.             else  
54.                 printf("-1\n");  
55.         }  
56.     }  
57.   
58.     clear_stack(pS1);  
59.     clear_stack(pS2);  
60.     return 0;  
61. }  
62.   
63. /* 
64. 创建一个空栈,并返回指向该栈的指针 
65. */  
66. PSTACK create_stack()  
67. {  
68.     PSTACK pS = (PSTACK)malloc(sizeof(STACK));  
69.     pS->pTop = (PNODE)malloc(sizeof(NODE));  
70.     if(NULL==pS || NULL==pS->pTop)  
71.     {  
72.        printf("malloc failed");  
73.        exit(-1);  
74.     }     
75.     else  
76.     {  
77.        pS->pBottom = pS->pTop;  
78.        pS->pBottom->pNext = NULL;  
79.     }  
80.       
81.     return pS;  
82. }  
83.   
84. /* 
85. 判断该栈是否为空 
86. */  
87. bool is_empty(PSTACK pS)  
88. {  
89.     if(pS->pTop == pS->pBottom)  
90.        return true;  
91.     else  
92.        return false;  
93. }  
94.   
95. /* 
96. 向pS指针指向的栈中压入数据val 
97. */  
98. void push_stack(PSTACK pS,int val)  
99. {  
100.     PNODE pNew = (PNODE)malloc(sizeof(NODE));  
101.     if(NULL==pNew)  
102.     {  
103.        printf("malloc failed");  
104.        exit(-1);  
105.     }     
106.     else  
107.     {  
108.        pNew->data = val;  
109.        pNew->pNext = pS->pTop;  
110.        pS->pTop = pNew;  
111.     }     
112.     return ;  
113. }  
114.   
115. /* 
116. 从栈中推出数据，并将推出的数据保存在pData指针所指向的位置 
117. */  
118. bool pop_stack(PSTACK pS,int *pData)  
119. {  
120.     if(is_empty(pS))  
121.        return false;  
122.     else  
123.     {  
124.        PNODE p = pS->pTop;  
125.        *pData = p->data;  
126.        pS->pTop = p->pNext;  
127.        free(p);  
128.        p = NULL;  
129.        return true;  
130.     }  
131. }  
132.   
133. /* 
134. 清空栈，即将其还原为空栈 
135. */  
136. void clear_stack(PSTACK pS)  
137. {  
138.     if(is_empty(pS))  
139.        return ;  
140.     else  
141.     {  
142.        PNODE p = pS->pTop;  
143.        PNODE r = NULL;  
144.        while(p != pS->pBottom)  
145.        {  
146.             r = p->pNext;  
147.             free(p);  
148.             p = r;  
149.        }  
150.        pS->pTop = pS->pBottom;  
151.     }  
152. }  
153.   
154. /* 
155. 用两个栈模拟入队 
156. */  
157. void enter_Queue(PSTACK pS1,int val)  
158. {  
159.     push_stack(pS1,val);  
160. }  
161.   
162. /* 
163. 用两个栈模拟出队 
164. */  
165. bool delete_Queue(PSTACK pS1,PSTACK pS2,int *pData)  
166. {  
167.     if(is_empty(pS1) && is_empty(pS2))  
168.         return false;  
169.     if(!is_empty(pS2))  
170.         pop_stack(pS2,pData);  
171.     else if(!is_empty(pS1))  
172.     {  
173.         while(!is_empty(pS1))  
174.         {  
175.             int pS1_popData;  
176.             pop_stack(pS1,&pS1_popData);  
177.             push_stack(pS2,pS1_popData);  
178.         }  
179.         pop_stack(pS2,pData);  
180.     }  
181.     return true;  
182. }  

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>

typedef struct Node
{
	int data;
	struct Node *pNext;
}NODE,*PNODE;

typedef struct Stack
{
	PNODE pTop;
	PNODE pBottom;
}STACK,*PSTACK;

PSTACK create_stack();
void push_stack(PSTACK,int);
void traverse_stack(PSTACK);
bool pop_stack(PSTACK,int *);
bool is_empty(PSTACK);
void clear_stack(PSTACK);
void enter_Queue(PSTACK,int);
bool delete_Queue(PSTACK,PSTACK,int *);

int main()
{	
	int n;		//保存操纵的个数
	int data;	//保存输入的要push的元素
	int pData;	//保存pop出来的元素
	char *push = "PUSH";
	char *pop = "POP";
	char input[5];
	int data_pop;

	//创建两个空栈
	PSTACK pS1 = create_stack();
	PSTACK pS2 = create_stack();
	scanf("%d",&n);
	while(n-->0)
	{
		scanf("%s",input);
		if(strcmp(input,push) == 0)
		{
			scanf("%d",&data);
			enter_Queue(pS1,data);
		}
		if(strcmp(input,pop) == 0)
		{
			if(delete_Queue(pS1,pS2,&pData))
				printf("%d\n",pData);
			else
				printf("-1\n");
		}
	}

	clear_stack(pS1);
	clear_stack(pS2);
	return 0;
}

/*
创建一个空栈,并返回指向该栈的指针
*/
PSTACK create_stack()
{
	PSTACK pS = (PSTACK)malloc(sizeof(STACK));
	pS->pTop = (PNODE)malloc(sizeof(NODE));
	if(NULL==pS || NULL==pS->pTop)
	{
	   printf("malloc failed");
	   exit(-1);
	}	
	else
	{
	   pS->pBottom = pS->pTop;
	   pS->pBottom->pNext = NULL;
	}
	
	return pS;
}

/*
判断该栈是否为空
*/
bool is_empty(PSTACK pS)
{
	if(pS->pTop == pS->pBottom)
	   return true;
    else
	   return false;
}

/*
向pS指针指向的栈中压入数据val
*/
void push_stack(PSTACK pS,int val)
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	if(NULL==pNew)
	{
	   printf("malloc failed");
	   exit(-1);
	}	
	else
	{
	   pNew->data = val;
	   pNew->pNext = pS->pTop;
	   pS->pTop = pNew;
	}	
	return ;
}

/*
从栈中推出数据，并将推出的数据保存在pData指针所指向的位置
*/
bool pop_stack(PSTACK pS,int *pData)
{
	if(is_empty(pS))
	   return false;
	else
	{
	   PNODE p = pS->pTop;
	   *pData = p->data;
	   pS->pTop = p->pNext;
	   free(p);
	   p = NULL;
	   return true;
	}
}

/*
清空栈，即将其还原为空栈
*/
void clear_stack(PSTACK pS)
{
	if(is_empty(pS))
	   return ;
	else
	{
	   PNODE p = pS->pTop;
	   PNODE r = NULL;
	   while(p != pS->pBottom)
	   {
			r = p->pNext;
			free(p);
			p = r;
	   }
	   pS->pTop = pS->pBottom;
   	}
}

/*
用两个栈模拟入队
*/
void enter_Queue(PSTACK pS1,int val)
{
	push_stack(pS1,val);
}

/*
用两个栈模拟出队
*/
bool delete_Queue(PSTACK pS1,PSTACK pS2,int *pData)
{
	if(is_empty(pS1) && is_empty(pS2))
		return false;
	if(!is_empty(pS2))
		pop_stack(pS2,pData);
	else if(!is_empty(pS1))
	{
		while(!is_empty(pS1))
		{
			int pS1_popData;
			pop_stack(pS1,&pS1_popData);
			push_stack(pS2,pS1_popData);
		}
		pop_stack(pS2,pData);
	}
	return true;
}

/**************************************************************

     Problem: 1512

     User: mmc_maodun

     Language: C

     Result: Accepted

     Time:80 ms

     Memory:1836 kb

****************************************************************/