<Programming Algorithm> two stacks implement a queue

. 1 #include <the iostream>
 2  the using  namespace STD;
 . 3  
. 4 typedef struct the Node
 . 5  {
 . 6      int NUM;
 . 7      the Node * pNext;
 . 8  } Stack, Queue;
 . 9  
10  // stack corresponding to stack the head of the linked list insertion 
. 11 Stack * stack_push (** PtoP Stack, int NUM)
 12 is  {
 13 is      Stack * • pNode = (Stack *) the malloc ( the sizeof (Stack));
 14      pNode-> NUM = NUM;
 15      pNode-> pNext = NULL;
16 
17     pNode->pNext = *pTop;
18     *pTop = pNode;
19     
20     return *pTop;
21 }
22 
23 int stack_pop(Stack** pTop)
24 {
25     if((*pTop) == NULL) return -1;
26 
27     Stack* pPop = *pTop;
28     int num = pPop->num;
29     
30     *pTop = (*pTop)->pNext;
31     free(pPop);
32     pPop =NULL;
 33 is      
34 is      return NUM;
 35  }
 36  
37 [  void PrintStack (Stack * PtoP)
 38 is  {
 39      COUT << " current stack elements: " << pTop-> NUM << endl;
 40  }
 41 is  
42 is  // queue into the stack 
43 is Queue * queue_push (stack pTop1 **, ** pTop2 stack, int NUM)
 44 is  {
 45      // first determines whether there are elements stack 2 is pushed back if the entire stack. 1 
46 is      IF ((* pTop2)! = NULL)
 47      {
 48          the while ((* pTop2)! =NULL)
 49          {
 50              stack_push (pTop1, stack_pop (pTop2));
 51 is          }
 52 is      }
 53 is  
54 is      // existing elements have all been in a stack or the stack is empty 1
 55      // directly onto the stack 
56 is      stack_push (pTop1, NUM) ;
 57 is  
58      return (Queue * ) pTop1;
 59  }
 60  
61 is  int queue_pop (stack pTop1 **, ** stack pTop2)
 62 is  {
 63 is      // determines a stack if there are no elements to put all the stack elements 1 are after 2 pushed onto the stack pop 
64      IF ((* pTop1)! = NULL)
 65      {
 66         the while (! (* pTop1) = NULL)
 67          {
 68              stack_push (pTop2, stack_pop (pTop1));
 69          }
 70      }
 71 is  
72      return stack_pop (pTop2);
 73 is  }
 74  
75  int main ()
 76  {
 77      Stack * pTop1 = NULL; // to stack into 
78      stack pTop2 * = NULL; // for the stack 
79      / * stack_push (& PtoP,. 1);
 80      stack_push (& PtoP, 2);
 81      stack_push (& PtoP,. 3);
 82      stack_push (& pTop, 4);
83      PrintStack (PtoP);
 84      COUT << "pop stack elements:" << stack_pop (& PtoP) << endl;
 85      COUT << "pop stack elements:" << stack_pop (& PtoP) << endl;
 86      COUT << "pop stack elements:" << stack_pop (& PtoP) << endl;
 87      COUT << "pop stack elements:" << stack_pop (& PtoP) << endl;
 88      COUT << "pop stack elements: "<< stack_pop (& PtoP) << endl; * / 
89      queue_push (& pTop1, & pTop2, . 1 );
 90      queue_push (& pTop1, & pTop2, 2 );
 91 is      queue_push (& pTop1, & pTop2,3);
92     queue_push(&pTop1,&pTop2,4);
93     queue_pop(&pTop1,&pTop2);
94     queue_pop(&pTop1,&pTop2);
95 
96     system("pause");
97     return 0;
98 }