Implement a queue with two stacks [C language]

Problem description ：

Consider using two stacks to implement a special structure like queues

---

Problem analysis ：

We rely on two stacks to realize the queue , It must be used to store the data of joining the team , One is used to get out of the stack , Here we mainly focus on these issues ：

• When can the queue leave ？
• When the queue is empty ？
• When can you join the queue ？
• When is the queue full ？
  Understanding these problems can easily solve the problem

Here's the answer （ This is not a pure code description , Just explain the problem ）：

---

Implementation code ：

Here is the definition and implementation of stack , And the specific code of realizing the queue with two stacks ：

// Stack structure definition and method declaration 

#define INITSIZE 5

typedef int ElemType;

typedef struct Stack
{
    
	ElemType data[INITSIZE];
	int top;

}Stack;

void InitStack(Stack *st,  int init_size);


bool  Empty(Stack *st);

bool  Push(Stack *st, ElemType value);

bool  Pop(Stack *st);

bool Top(Stack *st, ElemType *reval);

void DestroyStack(Stack *st);

// Method implementation of stack 

#include "stack.h"
#include <stdio.h>
#include <stdlib.h>

void InitStack(Stack *st,  int init_size)
{
    
	if(st==NULL) exit(0);

	st->top =0;
}

bool  Empty(Stack *st)
{
    
	if(st==NULL) exit(0);

	return st->top ==0;
}

bool Full(Stack *st)
{
    
	if(st==NULL) exit(0);

	return st->top ==INITSIZE;
}
bool  Push(Stack *st, ElemType value)
{
    
	if(st==NULL) exit(0);
	if(Full(st)) return false;

	st->data [st->top ++]=value;
	return true;
}

bool  Pop(Stack *st)
{
    
	if(st==NULL) exit(0);

	if(Empty(st)) return false;

	st->top --;
	return true;
}

bool Top(Stack *st, ElemType *reval)
{
    
	if(st==NULL) exit(0);

	*reval=st->data[st->top];
	return true;
}

void DestroyStack(Stack *st)
{
    
	if(st==NULL) exit(0);

	while(!Empty(st))
	{
    
		Pop(st);
	}
}

// Queue structure definition and method implementation 

typedef struct Queue
{
    
	Stack enter;
	Stack out;

}que;

void Init_que(que *q)
{
    
	if(q==NULL) exit(0);
	InitStack(&(q->enter),10); // Initialize a stack to store queued elements 
	InitStack(&(q->out),10);  // Initialize a stack to queue out 
}

bool Empty_que(que *q)
{
    
	if(q==NULL) exit(0);

	if(Empty(&q->enter) && Empty(&q->out))
		return true;
	else
		return false;
}

bool Full_que(que *q)
{
    
	if(q==NULL) exit(0);

	if(!Empty(&q->out) && Full(&q->enter))
		return true;
	else 
		return false;
}

bool Push_que(que *q,ElemType value)
{
    
	if(q==NULL) exit(0);

	if(Full_que(q)) return false;//  The team is full 

	if(Full(&q->enter))
	{
    
		ElemType val;
		while(!Empty(&q->enter))
		{
    
			Top(&q->enter,&val);
			Pop(&q->enter);
			Push(&q->out,val);
		}
	}
	Push(&q->enter,value);
	return true;
}

static bool Pop_que(que *q)
{
    
	if(q==NULL) exit(0);

	if(Empty_que(q)) return false;// Team space 

	if(Empty(&q->out))
	{
    
		ElemType val;
		while(!Empty(&q->enter))
		{
    
			Top(&q->enter,&val);
			Pop(&q->enter);
			Push(&q->out,val);
		}
	}
	Pop(&q->out);
	return true;
}

static bool Top_que(que *q,ElemType *revalue)
{
    
	if(q==NULL) exit(0);

	if(Empty_que(q)) return false;

	if(Empty(&q->out))
	{
    
		ElemType val;
		while(!Empty(&q->enter))
		{
    
			Top(&q->enter,&val);
			Pop(&q->enter);
			Push(&q->out,val);
		}
	}
	Top(&q->out,revalue);
	return true;
}

static void Destory_que(que *q)
{
    
	if(q==NULL) exit(0);

	DestroyStack(&q->enter);
	DestroyStack(&q->out);
}