二叉樹的創建、遍歷、判斷樹是否爲有效的二叉搜索樹、求樹的深度【C++實現】

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

// 樹節點
 struct TreeNode {
      int val;
      TreeNode *left;
      TreeNode *right;
      TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  };
 
 // 樹
 class  MyTree {
 public:
	 // 構造一棵樹，傳入的vector中是按樹結點的層序存放的，{第一層結點，第二層結點……}，空節點用NULL表示。
	 TreeNode* construct_tree(vector<int> &v) {
		 int v_siz = v.size();
		 TreeNode* root = new TreeNode(v[0]);
		 queue< TreeNode*> que;
		 que.push(root);
		 int i = 1;
		 while (!que.empty()) {
			 int siz = que.size();
			 while (siz--) {
				 auto cur = que.front();
				 que.pop();
				 if (i < v_siz && v[i] != NULL) {
					 cur->left = new TreeNode(v[i++]);
					 que.push(cur->left);
				 }
				 else {
					 cur->left = NULL;
					 ++i;
				 }
				 if (i < v_siz && v[i] != NULL) {
					 cur->right = new TreeNode(v[i++]);
					 que.push(cur->right);
				 }
				 else {
					 cur->right = NULL;
					 ++i;
				 }
			 }		
		 }
		 return root;
	 }

	 // 樹的先序遍歷，遍歷結果存放在vector<int> res中
	 void preorder_traversal(TreeNode* root, vector<int> &res) {
		 if (root == nullptr) {
			 return;
		 }
		 res.push_back(root->val);
		 preorder_traversal(root->left, res);
		 preorder_traversal(root->right, res);
		 return;
	 }

	 // 樹的中序遍歷，中序遍歷結果存放在vector<int> res中
	 void in_order_traversal(TreeNode* root, vector<int> &res) {
		 if (root == nullptr) {
			 return;
		 }
		 in_order_traversal(root->left, res);
		 res.push_back(root->val);
		 in_order_traversal(root->right, res);
		 return;
	 }

	 // 樹的後序遍歷，遍歷結果存放在vector<int> res中
	 void post_order_traversal(TreeNode* root, vector<int> &res) {
		 if (root == nullptr) {
			 return;
		 }
		 post_order_traversal(root->left, res);		 
		 post_order_traversal(root->right, res);
		 res.push_back(root->val);
		 return;
	 }

	 // 判斷樹是否是一個有效的二叉搜索樹
	 // 一個二叉搜索樹具有如下特徵：
	 // 節點的左子樹只包含小於當前節點的數。
	 // 節點的右子樹只包含大於當前節點的數。
	 // 所有左子樹和右子樹自身必須也是二叉搜索樹。
	 bool is_valid_BST(TreeNode* root) {
		 vector<int> res;
		 in_order_traversal(root, res);		// 調用中序遍歷函數
		 // 二叉搜索樹的中序遍歷結果應爲一組有序遞增的數
		 for (unsigned int i = 1; i < res.size(); ++i) {
			 if (res[i] < res[i - 1]) {
				 return false;
			 }
		 }
		 return true;
	 }

	 // 樹的深度
	 int max_depth(TreeNode* root) {
		 if (root) {
			 return max(max_depth(root->left), max_depth(root->right)) + 1;
		 }
		 else {
			 return 0;
		 }
	 }

	
 };
 
int main() {
	vector<int> v{ 10,5,15,NULL,NULL,6,20 };
	MyTree tree;
	TreeNode* root = tree.construct_tree(v);		// 構造一棵二叉樹
	vector<int> first_visit;
	tree.preorder_traversal(root, first_visit);		// 先序遍歷
	vector<int> mid_visit;
	tree.in_order_traversal(root, mid_visit);		// 中序遍歷
	vector<int> last_visit;
	tree.post_order_traversal(root, last_visit);	// 後序遍歷
	bool is_valid = tree.is_valid_BST(root);		// 判斷是否是有效二叉搜索樹
	int dep = tree.max_depth(root);					// 獲取樹的深度

	// 輸出結果
	cout << "樹的先序遍歷：";
	for (auto &it : first_visit) {
		cout << it << " ";
	}
	cout <<endl<< "樹的中序遍歷：";
	for (auto &it : mid_visit) {
		cout << it << " ";
	}
	cout << endl << "樹的後序遍歷：";
	for (auto &it : last_visit) {
		cout << it << " ";
	}
	cout << endl << "是否是有效二叉搜索樹：";
	if (is_valid) {
		cout << "是" ;
	}
	else {
		cout << "否" ;
	}
	cout << endl << "樹的深度："<<dep<<endl;
	

}