二叉树的常用操作

1. 二叉树的构建：
   递归构建
   层次构建
2. 二叉树的遍历
   先序遍历
   后序遍历
   中序遍历
3. 深度
   最大深度 (递归、层次遍历)
   最小深度 (广度优先搜索)
4. 节点统计
   总节点数
   叶子节点数

/*
10 6 14 0 0 12 16 8 0 0 0 0 0
3 9 20 0 0 15 7 0 0 0 0
1 2 3 4 5 6 7 0 0 0 0 0 0 0 0 0 0
*/

#include <iostream>
#include <queue>

using namespace std;
typedef struct BTreeNode {
	int data;
	BTreeNode* left;
	BTreeNode* right;
	BTreeNode(int x) : data(x), left(nullptr), right(nullptr) {}
}*BiTree;

//递归构建
void build_tree(BiTree &root) {
	int data;
	cin >> data;
	if (data == 0) {
		root = nullptr;
	}
	else {
		root = new BTreeNode(data);
		//cout << root->data << endl;
		build_tree(root->left);
		build_tree(root->right);
	}
}

int getdata() {
	int data;
	cin >> data;
	return data;
}

//层次构建
void make_tree(BiTree& root) {
	int data = getdata();
	if (data == 0) {
		return;
	}
	root = new BTreeNode(data);
	
	queue<BiTree> Q_tree;
	Q_tree.push(root);
	while (!Q_tree.empty()) {
		BiTree temp = Q_tree.front();
		Q_tree.pop();
		data = getdata();
		if (data != 0) {
			temp->left = new BTreeNode(data);
			Q_tree.push(temp->left);
		}
		data = getdata();
		if (data != 0) {
			temp->right = new BTreeNode(data);
			Q_tree.push(temp->right);
		}
	}
}

//先序遍历
void PreOrderTraverse(BiTree root)
{
	if (root == nullptr)
		return;
	cout << root->data << " ";	//显示节点数据
	PreOrderTraverse(root->left);
	PreOrderTraverse(root->right);
}
//中序遍历
void InOrderTraverse(BiTree root) {
	if (root == nullptr)
		return;
	InOrderTraverse(root->left);
	cout << root->data << " ";
	InOrderTraverse(root->right);
}
//后序遍历
void PostOrderTraverse(BiTree root) {
	if (root == nullptr)
		return;
	InOrderTraverse(root->left);
	InOrderTraverse(root->right);
	cout << root->data << " ";
}

//节点个数
int numberOfNode(BiTree root) {
	if (root == nullptr) {
		return 0;
	}
	return 1 + numberOfNode(root->left) + numberOfNode(root->right);
}

//叶子节点个数
int numberOfLeaf(BiTree root) {
	if (root == nullptr) return 0;
	if (root->left == nullptr && root->right == nullptr) {
		return 1;
	}
	return numberOfLeaf(root->left) + numberOfLeaf(root->right);
}

//最小高度
int min_depth(BiTree root) {
	if (root == nullptr) {
		return 0;
	}
	int depth = 1;
	BiTree end = root;
	queue<BiTree> Q;
	Q.push(root);
	while (!Q.empty()) {
		BiTree temp = Q.front();
		if (temp->left == nullptr && temp->right == nullptr) {
			break;
		}
		if (temp->left != nullptr) {
			Q.push(temp->left);
		}
		if (temp->right != nullptr) {
			Q.push(temp->right);
		}
		if (temp == end) {
			end = temp->right != nullptr ? temp->right : temp->left;
			depth++;
		}
		Q.pop();
	}
	return depth;
}

//最大高度, 递归
int max_depth(BiTree root) {
	if (root == nullptr) return 0;
	return 1 + max(max_depth(root->left), max_depth(root->right));
}

//最大高度, 层次遍历
int max_depth_BFS(BiTree root) {
	if (root == nullptr) {
		return 0;
	}
	int depth = 0;
	queue<BiTree> Q;
	Q.push(root);
	while (!Q.empty()) {
		int cur = 0, width = Q.size();
		while (cur < width) {
			BiTree temp = Q.front();
			if (temp->left != nullptr) Q.push(temp->left);
			if (temp->right != nullptr) Q.push(temp->right);
			Q.pop();
			cur++;
		}
		depth++;
	}
	return depth;
}


int main() {
	BiTree root = nullptr;
	make_tree(root);
	cout << "builded" << endl;

	cout<<"numberOfNode : "<<numberOfNode(root)<<endl;

	cout<<"numberOfLeaf : "<< numberOfLeaf(root)<<endl;

	cout << "PreOrderTraverse : ";
	PreOrderTraverse(root);
	cout << endl;

	cout << "InOrderTraverse : ";
	InOrderTraverse(root);
	cout << endl;

	cout << "PostOrderTraverse : ";
	PostOrderTraverse(root);
	cout << endl;

	cout<< "min depth: " << min_depth(root) << endl;

	cout<< "max depth: " << max_depth_BFS(root) << endl;
	return 0;
}