谈谈如何对栈和队列之间进行互相转换

1、使用栈实现一个队列
这个首先的借助两个栈，用栈的“先进后出”实现队列的“先进先出”的性质。

那么就要用一个进行入栈，一个进行出栈；

#include <stack>

stack<T> stack1;
stack<T> stack2;

将元素插入stack1中，此时stack1中有元素，而stack2中为空；

void TailInsert(const T &node)
{
	stack1.push(node);
}

这个时候试着从队列中删除一个元素。必须按照队列的“先进先出”性质；
但是最先进入的元素在stack1栈底，怎样才能先将它“出队”呢？这个时候就想到了“出栈”，可是出栈它也不会是第一个呀！此时我们会想到Stack2时空的，故借助stack2；
1）首先，将stack1中的元素逐个“出栈”，在每出栈一个的同时便将其“压栈”进入stack2；
2）其次，stack2中的元素会和stack1中是相反的，即最先压栈进入stack1的元素，现在在stack2中在栈顶；
3）最后，对于stack2进行“出栈"-----即最先进栈的最先出栈-----实现队列的“先进先出”；

以下是代码的实现：

T HeadDelete()
{
	if(stack2.size()<=0)
	{
	    //将stack1中的元素逐个“出栈”，在每出栈一个的同时便将其“压栈”进入stack2；
	    
		while(stack1.size()>0)
		{
			T &data=stack1.top();
			stack1.pop();
			stack2.push(data);
		}
	}
	
   //stack2中的元素会和stack1中是相反的，即最先压栈进入stack1的元素，现在在stack2中在栈顶；

	if(stack2.size()==0)
		cout<<"queue is empty"<<endl;
		
   //对于stack2先打印出栈顶元素，然后进行“出栈"-----即最先进栈的最先出栈-----实现队列的“先进  先出”；
	T head=stack2.top();
	stack2.pop();
	
	return head;
}

2、使用队列实现一个栈

这个首先的借助两个队列，用队列的“先进先出”实现栈的“先进后出”的性质。
那么就要用一个队列进行；

#include <queue>

queue<T> queue1;
queue<T> queue2;
bool 	queue1_u;
bool 	queue2_u;

向任意一个空队列中依次放入元素a、b、c；就用queue1；a是对头，c是对尾；

void HeadInsert(const T node)
{
	if(queue1_u==true)
		queue1.push(node);
	if(queue2_u==true)
		queue2.push(node);
}

出队列：根据栈的“先进后出”的性质，最后入栈的最先出栈；
c位于对尾，而我们只能从对头删除元素；故借助queue2；

1）首先，将c之前的元素依次出队列queue1，并以此入队列queue2，
2）此时删除queue1中的唯一一个元素c；
3）用同样的方法在queue1和queue2之间重复1）和2）便可实现；

void TailDelete()
{
	if(!queue1.empty()&&queue1_u==true)
	{
		while(queue1.size()!=1)
		{		
	     	//将c之前的元素依次出队列queue1，并以此入队列queue2，
			T &data=queue1.front();
			queue2.push(data);
			queue1.pop();
		}
		
        //删除queue1中的唯一一个元素c；
		queue1.pop();
		queue1_u=false;
		queue2_u=true;
		return ;
	}



	if(!queue2.empty()&&queue2_u==true)
	{
		while(queue2.size()!=1)
		{
		   //将x之前的元素依次出队列queue2，并以此入队列queue1
		   
			T &data=queue2.front();
			queue1.push(data);
			queue2.pop();
		} 
		
         //删除queue1中的唯一一个元素x；
		queue2.pop();
		queue2_u=false;
		queue1_u=true;
		return ;
	}
	cout<<"list is empty"<<endl;
}	

3、实现一个栈Stack的Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)

这个首先得借助两个栈，就要用一个进行入栈，一个进行出栈；

stack<T> stack1;
stack<T> stack2;

最先进入的元素在stack1栈底，最后进入的元素在栈顶；

1）首先，将stack1中的元素逐个“出栈",在每出栈一个的同时便将其“压栈”进入stack2；
2）其次，stack2中的元素会和stack1中是相反的，即最先压栈进入stack1的元素，现在在stack2中在栈顶；
3）最后，对于stack2进行“出栈"-----即最先进栈的最先出栈-----实现队列的“先进先出”；

	void Push(const T &node)
	{
		stack1.push(node);//将所有元素依次入栈stack1中
		
	   //逐个访问stack1中的元素，每访问一个的同时便将其“压栈”进入stack2；
		if(stack1.size()==1)
			stack2.push(stack1.top());
			
         //当stack1中栈顶元素小于stack2栈顶元素时，
         //访问stack1中的元素,同时便将其“压栈”进入stack2；
		else
		{
			if(stack1.top()<=stack2.top())
					 stack2.push(stack1.top());
		}
	}

在stack1不为空的情况下，当stack1中栈顶元素等于stack2栈顶元素时，将stack2中的元素出栈；

void Pop()
{
	if(!stack1.empty())
	{
		if(stack1.top()==stack2.top())
			stack2.pop();
		stack1.pop();//否则stack1中的元素出栈
	}
}

求最小的那个元素

T& Min()
{
	();//经过两个stack的操作后，stack2中的元素是最小的，直接访问即可；

	return stack2.top();
}