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;
}

結果：