c++中基于两个栈实现队列的操作

思路：

由于队列的先进先出的特性，使用栈的先进后出的特性。可以使用两个栈，其中一个栈实现入队，另一个栈实现出队的操作。

定义一个数据节点的类：

class data_node{
public:
	data_node() :data(0), next(NULL){}//default constructer function
	data_node(int value) :data(value), next(NULL){}//include arg constructer function
	int data;
	data_node *next;//pointer that point to next node
};

 定义一个栈类：

class my_stack{
public:
	my_stack() :top(NULL){}
	void push(data_node new_data);
	void pop(data_node *pop_node);
	bool empty();
	data_node *top;
};

 定义一个队列的类：

私有成员为两个栈，一个是入队，一个出队。 

class my_queue{
public:
	void enqueue(data_node new_data);
	void dequeue(data_node *del_data);
	bool empty(void);
private:
	my_stack s1;//input queue
	my_stack s2;//output queue
};

 关于栈中的方法的实现，请参考:https://blog.csdn.net/u010299133/article/details/103931670

队列中的方法的实现：

入队操作：

void my_queue::enqueue(data_node new_data)
{
	s1.push(new_data);
}

出队操作：

 先判断出队栈是否为空，如果为空，就将入队的栈中的数据出栈，并压入出队栈。最后再从出队栈中pop出数据节点。

void my_queue::dequeue(data_node *del_data)
{
	data_node local_node;

	if (s2.empty()){
		while (!s1.empty())
		{
			s1.pop(&local_node);
			s2.push(local_node);
		}
	}

	if (!s2.empty()){
		s2.pop(del_data);
	}

}

队列的判空操作：

队列中的两个栈都为空，队列也就为空。

bool my_queue::empty(void)
{
	return (s1.empty() && s2.empty());
}

 

完整代码：

#include "stdafx.h"
#include <iostream>
#pragma warning(disable:4996)
#include <string>

using namespace std;

class data_node{
public:
	data_node() :data(0), next(NULL){}//default constructer function
	data_node(int value) :data(value), next(NULL){}//include arg constructer function
	int data;
	data_node *next;//pointer that point to next node
};

class my_stack{
public:
	my_stack() :top(NULL){}
	void push(data_node new_data);
	void pop(data_node *pop_node);
	bool empty();
	data_node *top;
};

void my_stack::push(data_node new_data)
{
	data_node *pnode = NULL;
	pnode = new data_node(new_data.data);
	pnode->next = top;
	top = pnode;
}

void my_stack::pop(data_node *pop_node)
{
	if (empty())
	{
		printf("this stack is empty\n");
		return;
	}
	pop_node->data = top->data;
	data_node *pnode = top;
	top = top->next;
	delete pnode;
}

bool my_stack::empty()
{
	return (top == NULL);
}

class my_queue{
public:
	void enqueue(data_node new_data);
	void dequeue(data_node *del_data);
	bool empty(void);
private:
	my_stack s1;//input queue
	my_stack s2;//output queue
};

void my_queue::enqueue(data_node new_data)
{
	s1.push(new_data);
}

void my_queue::dequeue(data_node *del_data)
{
	data_node local_node;

	if (s2.empty()){
		while (!s1.empty())
		{
			s1.pop(&local_node);
			s2.push(local_node);
		}
	}

	if (!s2.empty()){
		s2.pop(del_data);
	}

}

bool my_queue::empty(void)
{
	return (s1.empty() && s2.empty());
}
int main()
{
	data_node stack_data_node(0);
	my_queue queue;
	queue.enqueue(data_node(3));
	queue.enqueue(data_node(2));
	queue.enqueue(data_node(4));

	cout << "this queue empty:" << queue.empty() << endl;

	queue.dequeue(&stack_data_node);
	cout << stack_data_node.data << " " << endl;
	queue.dequeue(&stack_data_node);
	cout << stack_data_node.data << " " << endl;
	queue.dequeue(&stack_data_node);
	cout << stack_data_node.data << " " << endl;

	cout << "this queue empty:" << queue.empty() << endl;
	return 0;
}

结果：