2つのスタックで1つのキュー機能を実現

1、c++実現

#include
#include
using namespace std;

/*          
  s1:    ，s2:    
    ，       s1 ，     push s2 ，  s2    pop
     ：
 （1）   B   ，     B   
 （2）   B  ，      A   ，   B ，    B   
*/
template struct Queue
{
	stack s1;
	stack s2;

	void push(T &t)
	{
		s1.push(t);
	}

	T front()
	{
		if(s2.empty())
		{
			if(s1.size()==0)
				throw;
			while(!s1.empty())
			{
				s2.push(s1.top());
				s1.pop();
			}
		}

		return s2.top();
	}
	
	void pop()
	{
		if(s2.empty())
		{
			while(!s1.empty())
			{
				s2.push(s1.top());
				s1.pop();
			}
		}
	}
};

2、c実現

/*
*         
*/
#include
#include
typedef struct stack
{
	//      
	int *a;
	//     
	int loc;
	//             
	int max;
}st;
/*
*          
*/
st *initstack(int num)
{
	st *s=(st *)malloc(sizeof(st));
	if(s==NULL)
	{
		printf("create fail!
");
		exit(1);
	}
	s->loc=0;
	s->max=num;
	s->a=(int *)malloc(sizeof(int)*num);
	if(s->a==NULL)
	{
		printf("create fail!
");
		exit(1);
	}
	return s;
}
/*
*        ( :  1   :  0)
*/
int isstackempty(st *s)
{
	//   
	if(s->loc==0)return 1;
	else return 0;
}
/*
*        ( :  1   :  0)
*/
int isstackfull(st *s)
{
	//   
	if(s->loc==s->max)return 1;
	else return 0;
}
/*
*       
*/
int getstacknum(st *s)
{
	if(isstackempty(s)==1)return 0;
	else return s->loc;
}
/*
*   
*/
void pushstack(st *s,int value)
{
	//  ,    
	if(isstackfull(s)==1)
	{
		printf("   ,    !
");
		exit(1);
	}
	s->a[s->loc]=value;
	s->loc++;
}
/*
*   
*/
int popstack(st *s)
{
	if(isstackempty(s)==1)
	{
		printf("   ,    !
");
		exit(1);
	}
	int temp=s->a[s->loc-1];
	s->loc--;
	return temp;
}
/*
*       
*/
int peekstack(st *s)
{
	if(isstackempty(s)==1)
	{
		printf("   ,        !
");
		exit(1);
	}
	int temp=s->a[s->loc-1];
	return temp;
}
/*
*                
*/
void copy(st *src,st *dest)
{
	//         
	if((src->loc+dest->loc)>dest->max)
	{
		printf("         !
");
		exit(1);
	}
	while(isstackempty(src)!=1)
	{
		int value=popstack(src);
		pushstack(dest,value);
	}
}
/*
*          
*/
void printstack(st *s)
{
	if(isstackempty(s)==1)
	{
		printf("   ,          !
");
		exit(1);
	}
	while(isstackempty(s)!=1)
	{
		int value=popstack(s);
		printf("%d--->",value);
	}
}
/*
*    (         src )
*/
void pushqueue(st *src,st *dest,int value)
{
	if(src->loc==src->max)
	{
		printf("    ,    !
");
		exit(1);
	}
	src->a[src->loc]=value;
	src->loc++;
}
/*
*    
* (  dest   ,    dest      )
* (  dest  ,src   ,   src       dest ,  dest       )
*/
int popqueue(st *src,st *dest)
{
	if(isstackempty(src)==1&&isstackempty(dest)==1)
	{
		printf("    ,    !
");
		exit(1);
	}
	if(isstackempty(dest)!=1)
	{
		int value=popstack(dest);
		return value;
	}
	else if(isstackempty(dest)==1&&isstackempty(src)!=1)
	{
		copy(src,dest);
		int value=popstack(dest);
		return value;
	}
}
int main()
{
	int num=3;
	int value=0;
	st *src=initstack(num);
	st *dest=initstack(num);
	pushstack(src,1);
	pushstack(src,2);
	value=popqueue(src,dest);
	printf("     =%d
",value);
	printf("
");
	pushstack(src,3);
	pushstack(src,4);
	pushstack(src,5);
	value=popqueue(src,dest);
	printf("     =%d
",value);
	value=popqueue(src,dest);
	printf("     =%d
",value);
	value=popqueue(src,dest);
	printf("     =%d
",value);
	value=popqueue(src,dest);
	printf("     =%d
",value);
	system("pause");
	return 0;
}