c++实现二叉搜索树的前中后序遍历和层序遍历

前中后序遍历都挺简单的，用循环来实现的话要注意三条语句的次序。另外，层序遍历的话，需要我们引入一个队列，他要求我们每次将根节点先入队，然后将根节点弹出，然后依次再将这个根节点的左右孩子的结点分别入队，然后弹出左孩子，将左孩子的左右孩子入队，然后弹出队列中的队首元素（也就是之前的右孩子），将右孩子的左右孩子入队。。。 以此类推，直到弹出的队首元素没有左右孩子。

void PreOrder(Node* node)
	{
		if(node != NULL)
		{
			cout << node->key << " ";
			PreOrder(node->left);
			PreOrder(node->right);
		}
	}

	void MidOrder(Node* node)
	{
		if(node != NULL)
		{
			MidOrder(node->left);
			cout << node->key << " ";
			MidOrder(node->right);
		}
	}

	void PostOrder(Node* node)
	{
		if(node != NULL)
		{
			PostOrder(node->left);
			PostOrder(node->right);
			cout << node->key << " ";
		}
	}

void LevelOrder()
	{
		queue q;
		q.push(root);
		while(!q.empty())
		{
			Node* node = q.front(); //先保存，再弹出	
			q.pop();

			cout << node->key << " ";

			if(node->left)
				q.push(node->left);
			if(node->right)
				q.push(node->right);

		}
		
	}

程序所有代码如下：

#include
#include

using namespace std; //不要忘记

template
class BST
{
private:
	struct Node
	{
		Key key;
		Value value;
		Node* left;
		Node* right;

		Node(Key key,Value value) //在结点里面直接初始化
		{
			this->key = key;
			this->value = value;
			this->left = NULL;
			this->right = NULL;
		}
	};

	Node* root;
	int count; //树中节点的个数

public:
	
	BST()
	{
		root = NULL;
		count = 0;
	}

	~BST() //析构函数没有参数
	{
		//TODO
	}

	bool isEmpty()
	{
		return count == 0 ? true : false;
	}

	int size()  //为什么写这个方法，是因为count是私有类型，我们用户从外界无法直接获取
	{
		return count;
	}

	void Insert(Key key, Value value) //肯定是插入两部分啊!!! 
	{
		root = Insert(root,key,value); //返回的这个根就是添加新的结点后的树的根
	}

	bool contain(Key key) //看看要查找的键值是否存在
	{
		return contain(root,key);
	}

	Value* search(Key key)
	{
		return search(root,key); //这里直接返回就行

	}

	void PreOrder()
	{
		PreOrder(root);
	}

	void MidOrder()
	{
		MidOrder(root);
	}

	void PostOrder()
	{
		PostOrder(root);
	}

	//层序遍历 直接写 学习一下队列的使用方法
	void LevelOrder()
	{
		queue q;
		q.push(root);
		while(!q.empty())
		{
			Node* node = q.front(); //先保存，再弹出	
			q.pop();

			cout << node->key << " ";

			if(node->left)
				q.push(node->left);
			if(node->right)
				q.push(node->right);

		}
		
	}

private:
	Node* Insert(Node* node ,Key key,Value value)
	{
		if(node == NULL)
		{
			count ++;
			//这里位置为空了，当然要新建立一个节点啊
			return new Node(key,value);
		}
		
		if(node->key == key)
			node->value = value;
		else if(node->key < key)
		{
			node->right = Insert(node->right,key,value); 
			//向node的右子树，相应的插入key和value。插入后，返回结果的这个根，就应该返回给node->right
		}
		else
		{
			node->left = Insert(node->left,key,value);
		}

		return node; //最后返回的仍然是这个节点本身 即是原来的根啦

	}

	bool contain(Node* node, Key key)
	{
		if(node == NULL)
			return false;
		if(node->key == key)
			return true;
		else if(node->key > key)
			return contain(node->right,key);
		else
			return contain(node->left,key);
	}

	Value* search(Node* node,Key key) //这里由于外部函数是直接返回这个值，所以就返回值为Value
	{
		if(node == NULL)
			return NULL;
		if(node->key == key) //key == node->key 这样写会更好一点
			return &(node->value);

		else if(node->key > key)
			return search(node->right,key);
		else
			return search(node->left,key);

	}

	void PreOrder(Node* node)
	{
		if(node != NULL)
		{
			cout << node->key << " ";
			PreOrder(node->left);
			PreOrder(node->right);
		}
	}

	void MidOrder(Node* node)
	{
		if(node != NULL)
		{
			MidOrder(node->left);
			cout << node->key << " ";
			MidOrder(node->right);
		}
	}

	void PostOrder(Node* node)
	{
		if(node != NULL)
		{
			PostOrder(node->left);
			PostOrder(node->right);
			cout << node->key << " ";
		}
	}


};

int main(int argc, char const *argv[])
{
	srand(time(NULL)); //设置种子
	BST bst = BST (); //这里不用new的

	int N = 10;
	int M = 100;

	for(int i = 0; i < N; i++)
	{
		int key = rand()%M; //生成100以内的数字
		int value = key;
		cout << key << " ";
		bst.Insert(key,value);
	}


	cout << endl;

	cout << "PreOrder: " << " ";
	bst.PreOrder();
	cout << endl; 
	
	cout << "MidOrder: " << " ";
	bst.MidOrder(); 
	cout << endl; 


	cout << "PostOrder: " << " ";
	bst.PostOrder(); 
	cout << endl; 

	cout << "LevelOrder: " << " ";
	bst.LevelOrder(); 
	cout << endl; 


	return 0;
}