二叉树四种遍历（附代码篇）

前序遍历
代码：

//二叉树的前序遍历
void preOrder() {
	preOrder(root);
}

//对以node为根的二叉搜索树进行前序遍历
void preOrder(Node* node) {
	if (node != NULL) {
		cout << node->key << endl;
		preOrder(node->left);
		preOrder(node->right);
	}
}

中序遍历结果会从小到大排序，因此对于排序问题可以考虑此类方法。

//二叉树的中序遍历
void inOrder() {
	inOrder(root);
}
		//对以node为根的二叉搜索树进行中序遍历
	void inOrder(Node* node) {
		if (node != NULL) {				
			inOrder(node->left);
			cout << node->key << endl;
			inOrder(node->right);
		}
	}

后序遍历适合释放二叉树的问题。

//二叉树的后序遍历
void postOrder() {
	postOrder(root);
}
	void postOrder(Node* node) {
		if (node != NULL) {
			postOrder(node->left);				
			postOrder(node->right);
			cout << node->key << endl;
		}
	}

层序遍历
也叫广度优先遍历

//二叉树的广度优先遍历
void leverOrder() {
	queue<Node*> q;
	q.push(root);
	while (!q.empty()) {
		Node *node = q.front();
		q.pop();
		cout << node->key << endl;
		if (node->left)
			q.push(node->left);
		if (node->right)
			q.push(node->right);
	}
}

完整代码：

//二分搜索树 key表示相对应得建，value表示数值。
template<typename Key,typename Value>
//建立一个类
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 = this->right = NULL;//左右孩子初始化
		}
	};
	Node *root;//根得位置
	int count;//结点得个数
public:
	BST() {
		root = NULL;
		count = 0;
	}
	~BST()
	{
		destroy(root);
	}
	int size() {
		return count;
	}
	bool isEmpty() {
		return count == 0;
	}
	//建立递归函数，返回值为根节点
	void insert(Key key, Value value) {
	
		root=insert(root, key, valur);
	}
	bool contain(Key key) {
		return contain(root, key);
	}
	Value* search(Key key) {
		return search(root, key);
	}
	//二叉树的前序遍历
	void preOrder() {
		preOrder(root);
	}
	//二叉树的中序遍历
	void inOrder() {
		inOrder(root);
	}
	//二叉树的后序遍历
	void postOrder() {
		postOrder(root);
	}
	
private:
	//向以node为根的二叉搜索树中，插入结点（key,value）
	//返回插入新节点后的二叉搜索树的根；
	Node* insert(Node *node, Key key, Value value) {

		if (node == NULL) {
			count++;
			return new Node(key, value);
		}
		if (key == node->key)
			node->value = value;
		else if (key < node->key)
			node->left = insert(node->left, key, value);
		else {

			node->right = insert(node->right, key, value);
		}
		return node;
	}
	//查看以node为根的二叉搜索树中是否包含键值为key的结点
		bool contain(Node *node, Key key, Value value) {
			if (node == NULL) {			
				return false;
			}
			if (key == node->key)
				return true;
			else if (key < node->key)
				return contain(node->left, key);
			else
				return contain(node->right, key);
		}
		//在以node为根的二叉搜索树中查找key所对应的value
		Value* search(Node* node, Key key, Value value) {
			if (node == NULL) {
				return NULL;
			}
			if (key == node->key)
				return &(node->value);
			else if (key < node->key)
				return search(node->left, key);
			else
				return search(node->right, key);
		}
		//对以node为根的二叉搜索树进行前序遍历
		void preOrder(Node* node) {
			if (node != NULL) {
				cout << node->key << endl;
				preOrder(node->left);
				preOrder(node->right);
			}
		}
		//对以node为根的二叉搜索树进行中序遍历
		void inOrder(Node* node) {
			if (node != NULL) {				
				inOrder(node->left);
				cout << node->key << endl;
				inOrder(node->right);
			}
		}
		//对以node为根的二叉搜索树进行后序遍历
		void postOrder(Node* node) {
			if (node != NULL) {
				postOrder(node->left);				
				postOrder(node->right);
				cout << node->key << endl;
			}
		}
		//析构函数的递归释放
		void destory(Node* node) {
			if (node != NULL) {
				destory(node->left);
				destory(node->right);
				delete node;
				count--;
			}
		}
};