BinaryTree.h

#ifndef BINARYTREE_H
#define BINARYTREE_H

#include<iostream>
#include<stack>
#include<queue>
//binary tree node
struct binary_tree_node{
	char data;
	binary_tree_node* lchild;
	binary_tree_node* rchild;
	binary_tree_node() :lchild(NULL), rchild(NULL){}
	binary_tree_node(char ch) :data(ch), lchild(NULL), rchild(NULL){}
};
//BinaryTree
class BinaryTree{
public:
	typedef binary_tree_node node_value;
	typedef binary_tree_node* node_pointer;
	BinaryTree();
	~BinaryTree();
	node_pointer get_root();
	void create_preorder(node_pointer& p);

	void preorder_recursive(node_pointer p);
	void inorder_recursive(node_pointer p);
	void postorder_recursive(node_pointer p);

	void preorder_no_recursive(node_pointer p);
	void preorder_no_recursive2(node_pointer p);
	void inorder_no_recursive(node_pointer p);
	void postorder_no_recursive(node_pointer p);

	void levelorder(node_pointer p);
	void tree_depth(node_pointer p, int& depth, int level);
	int leaf_count(node_pointer p);
	int node_count(node_pointer p);
private:
	void destroy(node_pointer p);
private:
	node_pointer root;
};

BinaryTree::BinaryTree() :root(NULL){}
BinaryTree::~BinaryTree(){
	destroy(root);
	root = NULL;
}
void BinaryTree::destroy(node_pointer p){
	if (p == NULL)
		return;
	destroy(p->lchild);
	destroy(p->rchild);
	delete p;
}
BinaryTree::node_pointer BinaryTree::get_root(){
	return root;
}
void BinaryTree::create_preorder(node_pointer& p){
	char ch;
	std::cin >> ch;
	if (ch == '#')
		p = NULL;
	else{
		p = new node_value(ch);
		create_preorder(p->lchild);
		create_preorder(p->rchild);
	}
}
void BinaryTree::preorder_recursive(node_pointer p){
	if (p == NULL)
		return;
	std::cout << p->data << ' ';
	preorder_recursive(p->lchild);
	preorder_recursive(p->rchild);
}
void BinaryTree::inorder_recursive(node_pointer p){
	if (p == NULL)
		return;
	inorder_recursive(p->lchild);
	std::cout << p->data << ' ';
	inorder_recursive(p->rchild);
}
void BinaryTree::postorder_recursive(node_pointer p){
	if (p == NULL)
		return;
	postorder_recursive(p->lchild);
	postorder_recursive(p->rchild);
	std::cout << p->data << ' ';
}
/*
先讓根進棧，只要棧不為空，就可以做彈出操作，
每次彈出一個結點，就把它的右孩子和左孩子依次入棧，這樣可以保證右子樹在棧中總處於左子樹的下面。
*/
void BinaryTree::preorder_no_recursive(node_pointer p){
	if (p == NULL)
		return;
	std::stack<node_pointer> stk;
	stk.push(p);
	while (!stk.empty()){
		node_pointer cur = stk.top();
		std::cout << cur->data << ' ';
		stk.pop();
		if (cur->rchild)
			stk.push(cur->rchild);
		if (cur->lchild)
			stk.push(cur->lchild);
	}
}
/*
對於任一結點P：
1)訪問結點P，並將結點P入棧;
2)判斷結點P的左孩子是否為空，若為空，則取棧頂結點並進行出棧操作，並將棧頂結點的右孩子置為當前的結點P，迴圈至1);
若不為空，則將P的左孩子置為當前的結點P;
3)直到P為NULL並且棧為空，則遍歷結束。
*/
void BinaryTree::preorder_no_recursive2(node_pointer p){
	if (p == NULL)
		return;
	std::stack<node_pointer> stk;
	node_pointer cur = p;
	while (cur != NULL || !stk.empty()){
		while (cur != NULL){
			std::cout << cur->data << ' ';
			stk.push(cur);
			cur = cur->lchild;
		}
		if (!stk.empty()){
			cur = stk.top();
			stk.pop();
			cur = cur->rchild;
		}
	}
}
/*
對於任一結點P，
1)若其左孩子不為空，則將P入棧並將P的左孩子置為當前的P，然後對當前結點P再進行相同的處理；
2)若其左孩子為空，則取棧頂元素並進行出棧操作，訪問該棧頂結點，然後將當前的P置為棧頂結點的右孩子；
3)直到P為NULL並且棧為空則遍歷結束
*/
void BinaryTree::inorder_no_recursive(node_pointer p){
	if (p == NULL)
		return;
	std::stack<node_pointer> stk;
	node_pointer cur = p;
	while (cur != NULL || !stk.empty()){
		while (cur != NULL){
			stk.push(cur);
			cur = cur->lchild;
		}
		if (!stk.empty()){
			cur = stk.top();
			std::cout << cur->data << ' ';
			stk.pop();
			cur = cur->rchild;
		}
	}
}
/*
對於任一結點P，先將其入棧。如果P不存在左孩子和右孩子,則可以直接訪問它;
或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被訪問過了，也可以直接訪問它。
若非上述兩種情況，則將P的右孩子和左孩子依次入棧，這樣就保證了
左孩子在右孩子前面被訪問，左孩子和右孩子都在根結點前面被訪問。
*/
void BinaryTree::postorder_no_recursive(node_pointer p){
	if (p == NULL)
		return;
	std::stack<node_pointer> stk;
	stk.push(p);
	node_pointer cur;
	node_pointer pre = NULL;
	while (!stk.empty()){
		cur = stk.top();
		if ((cur->lchild == NULL&&cur->rchild == NULL) || pre != NULL && (cur->lchild == pre || cur->rchild == pre)){
			std::cout << cur->data << ' ';
			stk.pop();
			pre = cur;
		}
		else{
			if (cur->rchild)
				stk.push(cur->rchild);
			if (cur->lchild)
				stk.push(cur->lchild);
		}
	}
}
/*
先讓根進佇列，只要佇列不為空，就可以做pop操作，
每次pop一個結點，就把它的左孩子和右孩子依次入佇列，這樣可以保證層次遍歷。
*/
void BinaryTree::levelorder(node_pointer p){
	if (p == NULL)
		return;
	std::queue<node_pointer> que;
	que.push(p);
	while (!que.empty()){
		node_pointer temp = que.front();
		std::cout << temp->data << ' ';
		if (temp->lchild)
			que.push(temp->lchild);
		if (temp->rchild)
			que.push(temp->rchild);
		que.pop();
	}
}
void BinaryTree::tree_depth(node_pointer p, int& depth, int level){
	if (p == NULL)
		return;
	if (level>depth)
		depth = level;
	tree_depth(p->lchild, depth, level + 1);
	tree_depth(p->rchild, depth, level + 1);
}
int BinaryTree::leaf_count(node_pointer p){
	if (p == NULL)
		return 0;
	else if (p->lchild == NULL&&p->rchild == NULL)
		return 1;
	else
		return (leaf_count(p->lchild) + leaf_count(p->rchild));
}
int  BinaryTree::node_count(node_pointer p){
	if (p == NULL)
		return 0;
	else
		return (1 + node_count(p->lchild) + node_count(p->rchild));
}

#endif
 

#include"BinaryTree.h"
using namespace std;

void menu(){
	cout << "========================================================================" << endl;
	cout << "1.輸入字元序列，以先序序列建立二叉樹!" << endl;
	cout << "2.先序、中序、後序遍歷二叉樹(遞迴演算法)!" << endl;
	cout << "3.先序、中序、後序遍歷二叉樹(非遞迴演算法)!" << endl;
	cout << "4.層次遍歷二叉樹!" << endl;
	cout << "5.求二叉樹的高度!" << endl;
	cout << "6.求二叉樹的葉子個數!" << endl;
	cout << "7.求二叉樹的節點個數!" << endl;
	cout << "0.退出程式!" << endl;
	cout << "========================================================================" << endl;
}

int main(){
	int choose;
	int depth;
	int level;
	bool flag = true;
	BinaryTree binary_tree;
	binary_tree_node* root = binary_tree.get_root();
	while (flag){
		menu();
		cout << "請輸入要選擇的功能：";
		cin >> choose;
		switch (choose){
		case 1:
			cout << "請輸入二叉樹中的元素,空的左右孩子以#替代:" << endl;
			binary_tree.create_preorder(root);
			break;
		case 2:
			cout << "先序遍歷:" << endl;
			binary_tree.preorder_recursive(root);
			cout << endl << "中序遍歷:" << endl;
			binary_tree.inorder_recursive(root);
			cout << endl << "後序遍歷:" << endl;
			binary_tree.postorder_recursive(root);
			cout << endl;
			break;
		case 3:
			cout << "先序遍歷:" << endl;
			cout << "方法一：";
			binary_tree.preorder_no_recursive(root);
			cout << endl << "方法二：";
			binary_tree.preorder_no_recursive2(root);
			cout << endl << "中序遍歷:" << endl;
			binary_tree.inorder_no_recursive(root);
			cout << endl << "後序遍歷:" << endl;
			binary_tree.postorder_no_recursive(root);
			cout << endl;
			break;
		case 4:
			cout << "層次遍歷:" << endl;
			binary_tree.levelorder(root);
			cout << endl;
			break;
		case 5:
			depth = 1;
			level = 1;
			binary_tree.tree_depth(root, depth, level);
			cout << "二叉樹的高度為:" << depth << endl;
			break;
		case 6:
			cout << "二叉樹的葉子個數為：" << binary_tree.leaf_count(root) << endl;
			break;
		case 7:
			cout << "二叉樹的節點個數為：" << binary_tree.node_count(root) << endl;
			break;
		case 0:
			flag = false;
			break;
		default:
			cout << "輸入錯誤，請重新輸入" << endl;
		}
	}

	return 0;
}
 

參考：