两个栈S1和S2来模拟一个队列

请利用两个栈S1和S2来模拟一个队列。

已知栈的四个运算定义如下：
Init(ST): 初始化ST栈，初始化完成后的栈为空，没有任何元素；
Push(ST,x): 元素x入ST栈；
Pop(ST,x): ST栈顶元素出栈，赋给变量x；
IsEmpty(ST): 判ST栈是否为空。

那么如何利用栈的运算来实现该队列的四个运算：
InitQueue: 初始化队列，初始化完成后的队列为空，没有任何元素；
EnQueue: 插入一个元素入队列；
DeQueue: 删除一个元素出队列；
IsEmptyQueue: 判队列是否为空。

算法说明：
栈的特点是后进先出，队列的特点是先进先出。所以，用两个栈S1和S2模拟一个队列时，
S1作输入栈，逐个元素压栈，以此模拟队列元素的入队。当需要出队时，将栈S1退栈并逐
个压入栈S2中，S1中最先入栈的元素，在S2中处于栈顶。S2退栈，相当于队列的出队，实
现了先进先出。

实现要求：
1、要求两个栈S1和S2的长度都是5，也就是说队列最多可以存放10个元素，超过10个元素需要返回失败。
2、EnQueue、DeQueue、IsEmptyQueue的返回值请严格按照说明返回，不可以随意变更。
3、请按照算法说明实现该算法，不要采用其他方式实现队列。
请严格按照上述要求实现，否则将导致用例执行失败。

推荐实现步骤：
1、首先实现栈的算法，也就是栈的四个操作。
2、然后参考算法说明，通过对两个栈的操作来模拟一个队列。

StructSize.h

#ifndef _STRUCT_SIZE_H
#define _STRUCT_SIZE_H

#define SUCCESS  0

#define STACK_MAX_SIZE 5
typedef int ElemType; 

typedef struct ST
{
 ElemType data[STACK_MAX_SIZE];  //存放数据
 int top;                       //栈顶指针
}myStack;

int InitQueue(void);
int EnQueue(int elem);
int DeQueue(int* elem);
int IsEmptyQueue(void);

#endif

 

#include "StructSize.h"

myStack g_myStack1,g_myStack2;

//初始化ST栈，初始化完成后的栈为空，没有任何元素；
int InitSt(struct ST* S)
{
  S->top = -1;
  return SUCCESS;
}

//元素x入ST栈；
int Push(struct ST* S, int x)
{
  if( S->top >= STACK_MAX_SIZE - 1 )
 {
  return 1;
 }
 else
 {
  S->top++;
  S->data[S->top] = x;
  return SUCCESS;
 }
}

//ST栈顶元素出栈，赋给变量x；
int Pop(struct ST* S, int* x)
{
    if( S->top <= -1 )
 {
  return 1;
 }
 else
 {
  *x = S->data[S->top];
  S->top--;
  return SUCCESS;
 }
}

//判ST栈是否为空。
int IsEmpty(struct ST* S)
{
     if( -1 == S->top )
 {
  return 1;
 }
 return 0;
}

//初始化队列，初始化完成后的队列为空，没有任何元素；
int InitQueue(void)
{
     InitSt(&g_myStack1);

     InitSt(&g_myStack2);

 return SUCCESS;
}

//将元素Elem插入队列，若入队列成功返回0，否则返回1。
int EnQueue(int Elem)
{
  int Result = 1;
 if( g_myStack1.top >= STACK_MAX_SIZE - 1 )
 {
  if ( g_myStack2.top >= STACK_MAX_SIZE - 1 )
  {
   return 1;
  }
  else
  {
   while( g_myStack2.top < STACK_MAX_SIZE - 1)
   {
    int topData;
    Result = Pop(&g_myStack1,&topData);
    if( SUCCESS == Result )
    {
     Result = Push(&g_myStack2,topData);
    }
   }
   if( SUCCESS == Result )
   {
    Result = Push(&g_myStack1,Elem);
   }
  }
 }
 else
 {
  Result = Push(&g_myStack1,Elem);
 }
 return Result;
}

//从队列中取出一个元素放入pElem，若出队列成功返回0，否则返回1。
int DeQueue(int* pElem)
{
    int Result = 1;
 if(IsEmpty(&g_myStack1) && IsEmpty(&g_myStack2))
 {
  return 1;
 }
 else
 {
  if(IsEmpty(&g_myStack2))
  {
   int topData;
   while(!IsEmpty(&g_myStack1))
   {
    Result = Pop(&g_myStack1,&topData);
    if ( SUCCESS == Result )
    {
     Result = Push(&g_myStack2,topData);
    }
   }
   if ( SUCCESS == Result )
   {
    Result = Pop(&g_myStack2,pElem);
   }
  }
  else
  {
   Result = Pop(&g_myStack2,pElem);
  }
 }
 return Result;
}

//判用队列是否为空，如果是空则返回1，如果不是空则返回0。
int IsEmptyQueue(void)
{
    if(IsEmpty(&g_myStack1) && IsEmpty(&g_myStack2))
  return 1;
 return SUCCESS;
}