用俩个自己实现的队列实现一个栈

队列：FIFO（先进先出）：尾部进，头部出（一端进，另一端出）

栈：LIFO（后进先出）：只从一端进出

队列和栈都是线性表，下面用俩个队列实现一个栈

 俩个队列实现一个栈，最重要的地方在于入栈和出栈；

假如已经入一些数据在Queue1中：

 可以看到，入栈的时候只往其中一个队列中入队就行；

在模拟栈的过程中，永远只有一个队列中有数据，有一个队列为空。

如果要获取栈顶元素，就是取队列的[Rear-1]的元素，下面介绍完出栈还有一种获取栈顶元素的方法。

这样的话，出栈就不能用Queue1来出队了，出栈出的是Queue1中的Rear的数据，但是队列出队出的是Front的数据，这块就用到了第二个队列：

 可以将Queue1中的前n-1个数据依次出队然后入队到Queue2当中；n就是Queue1的有效长度

执行完之后，Queue1的Front和Rear都指向的是最后一个入队也就是入栈的元素，在进行出栈也就是出队即可。

之后如果再要入栈，就往有数据的队列里面入。也就是先判断第一个队列是否为空，为空的话就直接向第二个队列里入，不为空的话就往第一个队列入值就行。

这就是出栈操作；

获取栈顶元素也可以使用这种方法，不过最后多了一步将元素获取完之后出队，再入队到右边第二个队列当中，不能因为获取了栈顶元素二Pop掉它

入栈操作如下：

 由于队列的代码已经是写好的，所以实现起来一直去调用函数就行：

以下是完整代码：

队列的代码：

typedef int ELEM_TYPE;
const ELEM_TYPE SIZE = 11;

typedef struct Queue
{
	ELEM_TYPE* data;
	int front;
	int rear;
};
void Init_Queue(Queue& qu)
{
	qu.data = new ELEM_TYPE[SIZE]{};
	qu.front = 0;
	qu.rear = 0;
}

bool Push_Queue(Queue& qu, ELEM_TYPE val)
{
	if (IsFull(qu))
	{
		return false;
	}
	qu.data[qu.rear] = val;
	qu.rear = (qu.rear + 1) % SIZE;
	return true;
}


bool Pop_Queue(Queue& qu)
{
	if (IsEmpty(qu))
	{
		return false;
	}
	qu.data[qu.front] = 0;
	qu.front=(qu.front+1)%SIZE;
	return true;
}

bool IsFull(Queue& qu)
{
	return (qu.rear + 1) % SIZE == qu.front;
}


bool IsEmpty(Queue& qu)
{
	return qu.front == qu.rear;
}

const ELEM_TYPE& Get_Front(Queue& qu)
{
	return qu.data[qu.front];
}

void Show_Queue(Queue& qu)
{
	for (int i = 0; i < Get_Size(qu); ++i)
	{
		cout << qu.data[(qu.front + i)%SIZE]<<"    ";
	}
	cout << endl;
}

const int& Get_Size(Queue& qu)
{
	return (qu.rear-qu.front+SIZE)%SIZE;
}

void Delete_Queue(Queue& qu)
{
	delete[]qu.data;
	qu.front = 0;
	qu.rear = 0;
}

俩个队列实现一个栈的代码：

struct My_Stack
{
	Queue q1;
	Queue q2;
};
void Init_My_Stack(My_Stack& ps)
{
	Init_Queue(ps.q1);
	Init_Queue(ps.q2);
}

bool Push_My_Stack(My_Stack& ps, ELEM_TYPE val)
{
	if (!IsEmpty(ps.q1))
	{
		Push_Queue(ps.q1,val);
	}
	else
	{
		Push_Queue(ps.q2, val);
	}
	return true;
}

bool Pop_My_Stack(My_Stack& ps)
{
	if (IsEmpty(ps.q1) && IsEmpty(ps.q2))
	{
		return false;
	}
	else if (!IsEmpty(ps.q1))
	{
		int n = Get_Size(ps.q1);
		for (int i = 0; i < n - 1; ++i)
		{
			Push_Queue(ps.q2, Get_Front(ps.q1));
			Pop_Queue(ps.q1);
		}
		cout << Get_Front(ps.q1)<<endl;
		Pop_Queue(ps.q1);
	}
	else
	{
		int n = Get_Size(ps.q2);
		for (int i = 0; i < n - 1; ++i)
		{
			Push_Queue(ps.q1, Get_Front(ps.q2));
			Pop_Queue(ps.q2);
		}
		cout << Get_Front(ps.q2)<<endl;
		Pop_Queue(ps.q2);
	}
	return true;
}

bool IsFull_My_Stack(My_Stack& ps)
{
	return (IsFull(ps.q1) || IsFull(ps.q2));
}

bool IsEmpty_My_Stack(My_Stack& ps)
{
	return (IsEmpty(ps.q1) && IsEmpty(ps.q2));
}

ELEM_TYPE Get_My_Length(My_Stack& ps)
{
	if (!IsEmpty(ps.q1))
	{
		return Get_Size(ps.q1);
	}
	else
	{
		return Get_Size(ps.q2);
	}
}

ELEM_TYPE My_Get_Top(My_Stack& ps)
{
	if (!IsEmpty(ps.q1))
	{
		return (ps.q1.data[(ps.q1.rear - 1 + SIZE) % SIZE]);
	}
	else
	{
		return (ps.q2.data[(ps.q2.rear - 1 + SIZE) % SIZE]);
	}
}

void Delete_My_Stack(My_Stack& ps)
{
	Delete_Queue(ps.q1);
	Delete_Queue(ps.q2);
}

 感谢阅读！