链队定义及其应用

队列的定义

队列结点类型

template<class T>
struct QueneNode
{
	T data;
	QueneNode<T>* link;
	QueneNode()
	{
		link = NULL;
	}
	QueneNode(T x)
	{
		data = x;
		link = NULL;
	}
};

链队类函数

template<class T>
class Quene
{
public:
	Quene();  //构造函数
	~Quene();  //析函数
	bool EnQuene(T x);  //入队
	bool DeQuene(T& x);  //出队
	bool Get_Front(T& x);  //取队头
	void MakeEmpty();  //清空队列
private:
	QueneNode<T>* front;  //队头指针
	QueneNode<T>* rear;  //队尾指针
};

构造函数

template<class T>
Quene<T>::Quene()
{
	front = new QueneNode<T>;
	rear = front;
}

析构函数

template<class T>
Quene<T>::~Quene()
{
	MakeEmpty();
}

入队

template<class T>
bool Quene<T>::EnQuene(T x)
{
	QueneNode<T>* newnode;
	newnode = new QueneNode<T>(x);
	if (newnode == NULL)
		return false;
	rear->link = newnode;
	rear = newnode;
	return true;
}

出队

template<class T>
bool Quene<T>::DeQuene(T& x)
{
	QueneNode<T>* p = front->link;
	if (front == rear)
		return false;
	if (p == rear)
		rear = front;
	front->link = p->link;
    x = p->data;
	delete p;
	p = NULL;
	return true;
}

取队头元素

template<class T>
bool Quene<T>::Get_Front(T& x)
{
	if (front == rear)
		return false;
	x = front->link->data;
	return true;
}

清空队列

template<class T>
void Quene<T>::MakeEmpty()
{
	T x;
	while (DeQuene(x));
}

队列的应用

周末舞会

void Week_Dance()  //周末舞会
{
	Quene<int> Man, Woman;
	cout << "请输入参加舞会男士的人数和女士的人数" << endl;
	int m = 0, n = 0;
	cin >> m >> n;
	int count = 1;
	while (m--)
	{
		Man.EnQuene(count++);
	}
	count = 1;
	while (n--)
	{
		Woman.EnQuene(count++);
	}
	cout << "请输入舞曲的数目" << endl;
	int k = 0;
	cin >> k;
	cout << "舞伴安排顺序如下:" << endl;
	while (k--)
	{
		int a = 0, b = 0;
		Man.DeQuene(a);
		Woman.DeQuene(b);
		cout << a << ' ' << b << endl;
		Man.EnQuene(a);
		Woman.EnQuene(b);
	}
	cout << "舞伴安排完毕" << endl;
}

二叉树的层次遍历

//需要二叉树
//结点类型改变了
template<class T>
struct QueneNode
{
	BinTreeNode<T>* data;
	QueneNode<T>* link;
	QueneNode()
	{
		data = NULL;
		link = NULL;
	}
	QueneNode(BinTreeNode<T>* x)
	{
		data = x;
		link = NULL;
	}
};
//层次遍历 思想是这样
void Level_Tra(BinTreeNode<char>* root)
{
	BinTreeNode<char>* p = root;
	if (root == NULL)
	{
		return;
	}
	Quene<char> t;
	t.EnQuene(p);
	while (!t.Is_Empty())
	{
		t.DeQuene(p);
		cout << p->data << ' ';
		if (p->leftchild != NULL)
			t.EnQuene(p->leftchild);
		if (p->rightchild != NULL)
			t.EnQuene(p->rightchild);
	}
}

关于层次遍历的完整代码

#include<iostream>

using namespace std;

template<class T>
struct BinTreeNode
{
	T data;
	BinTreeNode<T>* leftchild;
	BinTreeNode<T>* rightchild;
	BinTreeNode()
	{
		leftchild = NULL;
		rightchild = NULL;
	}
	BinTreeNode(T x)
	{
		data = x;
		leftchild = NULL;
		rightchild = NULL;
	}
};

template<class T>
struct QueneNode
{
	BinTreeNode<T>* data;
	QueneNode<T>* link;
	QueneNode()
	{
		data = NULL;
		link = NULL;
	}
	QueneNode(BinTreeNode<T>* x)
	{
		data = x;
		link = NULL;
	}
};


template<class T>
class BinTree
{
public:
	BinTree();
	~BinTree();
	BinTreeNode<T>* Get_root()
	{
		return root;
	}  //返回根结点
	void CreateTree(BinTreeNode<T>*& root);  //创建二叉树
	void DeleTree(BinTreeNode<T>* root);  //销毁二叉树
protected:
	BinTreeNode<T>* root;
};

template<class T>
class Quene
{
public:
	Quene();  //构造函数
	bool EnQuene(BinTreeNode<T>* x);  //入队
	bool DeQuene(BinTreeNode<T>*& x);  //出队
	bool Is_Empty();  //判断队列是否为空
private:
	QueneNode<T>* front;  //队头指针
	QueneNode<T>* rear;  //队尾指针
};

template<class T>
BinTree<T>::BinTree()
{
	root = NULL;
}

template<class T>
BinTree<T>::~BinTree()
{
	DeleTree(root);
}

template<class T>
void BinTree<T>::CreateTree(BinTreeNode<T>*& root)
{
	T x;
	cin >> x;
	if (x == '#')
	{
		root = NULL;
		return;
	}
	root = new BinTreeNode<T>(x);
	if (root == NULL)
		return;
	CreateTree(root->leftchild);
	CreateTree(root->rightchild);
}

template<class T>
void BinTree<T>::DeleTree(BinTreeNode<T>* root)
{
	if (root == NULL)
		return;
	DeleTree(root->leftchild);
	DeleTree(root->rightchild);
	delete root;
}

template<class T>
Quene<T>::Quene()
{
	front = new QueneNode<T>;
	rear = front;
}


template<class T>
bool Quene<T>::EnQuene(BinTreeNode<T>* x)
{
	QueneNode<T>* newnode;
	newnode = new QueneNode<T>(x);
	if (newnode == NULL)
		return false;
	rear->link = newnode;
	rear = newnode;
	return true;
}

template<class T>
bool Quene<T>::DeQuene(BinTreeNode<T>*& x)
{
	QueneNode<T>* p = front->link;
	if (front == rear)
		return false;
	if (p == rear)
		rear = front;
	front->link = p->link;
	x = p->data;
	delete p;
	p = NULL;
	return true;
}

template<class T>
bool Quene<T>::Is_Empty()
{
	if (front == rear)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void Level_Tra(BinTreeNode<char>* root)//层次遍历
{
	BinTreeNode<char>* p = root;
	if (root == NULL)
	{
		return;
	}
	Quene<char> t;
	t.EnQuene(p);
	while (!t.Is_Empty())
	{
		t.DeQuene(p);
		cout << p->data << ' ';
		if (p->leftchild != NULL)
			t.EnQuene(p->leftchild);
		if (p->rightchild != NULL)
			t.EnQuene(p->rightchild);
	}
}

int main()
{
	BinTree<char> tree;
	BinTreeNode<char>* head = tree.Get_root();
	tree.CreateTree(head);
	Level_Tra(head);
	return 0;
}