[数据结构]代码：二叉树的基本操作

首先定义节点：

template <class T>
struct TreeNode
{
	T val;
	TreeNode<T>* parent;
	TreeNode<T>* left;
	TreeNode<T>* right;
	TreeNode() : val(0), parent(nullptr), left(nullptr), right(nullptr) {}
	TreeNode(T val) : val(val), parent(nullptr), left(nullptr), right(nullptr) {}
	TreeNode(T val, TreeNode<T>* p) : val(val), parent(p), left(nullptr), right(nullptr) {}
	TreeNode(T val, TreeNode<T>* p, TreeNode<T>* l, TreeNode<T>* r) : val(val), parent(p), left(l), right(r) {}
};

说明：这里并没有用到指向父节点的指针parent，可能以后会需要

定义二叉树类：

template <class T>
class BinaryTree {
private:	
	TreeNode<T>* root;
	
public:
	BinaryTree() : root(nullptr) {}
	BinaryTree(TreeNode<T>* r) : root(r) {}
	
	TreeNode<T>* getRoot() {
		return root;
	}
    
    //层级建树
	void levelOrderBuildTree(vector<T> arr) {
		queue<pair<int, TreeNode<T>*>> que;
		root = new TreeNode<T>(arr[0]);
		que.push(make_pair(0, root));
		
		while (!que.empty()) {
			pair<int, TreeNode<T>*> m = que.front();
			int pos = m.first+1;
			TreeNode<T>* p = m.second;
			que.pop();
			if (pos * 2 - 1 < arr.size() && arr[pos * 2 - 1] != NULL) {
				p->left = new TreeNode<T>(arr[pos * 2 - 1]);
				que.push(make_pair(pos * 2 - 1, p->left));
			}
			if (pos * 2 < arr.size() && arr[pos * 2] != NULL) {
				p->right = new TreeNode<T>(arr[pos * 2]);
				que.push(make_pair(pos * 2, p->right));
			}
		}
		return;
	}

    //前序遍历
	vector<T> preOrder() {
		stack<TreeNode<T>*> st;
		vector<T> ans;
		st.push(root);
		while (!st.empty()) {
			TreeNode<T>* p = st.top();
			st.pop();
			ans.push_back(p->val);
			if (p->right) st.push(p->right);
			if (p->left) st.push(p->left);
		}
		return ans;
	}

    //中序遍历
	vector<T> inOrder() {
		stack<TreeNode<T>*> st;
		vector<T> ans;
		
		if (!root) return ans;

		TreeNode<T>* h = root;
		while (!st.empty() || h!=nullptr) {
			while (h) {
				st.push(h);
				h = h->left;
			}
			h = st.top();
			st.pop();
			ans.push_back(h->val);
			h = h->right;
		}
		return ans;
	}

    //后序遍历
	vector<T> postOrder() {
		vector<T> ans;
		if (!root) return ans;

		stack<TreeNode<T>*> st;
		TreeNode<T>* h = root;
		TreeNode<T>* pre = nullptr;
		while (h != nullptr || !st.empty()) {
			while (h) {
				st.push(h);
				h = h->left;
			}
			h = st.top();
			st.pop();
			if (h->right == nullptr || h->right == pre) {
				ans.push_back(h->val);
				pre = h;
				h = nullptr;
			}
			else {
				st.push(h);
				h = h->right;
			}
		}
		return ans;
	}

    //层级遍历
	vector<vector<T>> levelOrder() {
		vector<vector<T>> ans;

		if (!root) return ans;

		queue<TreeNode<T>*> que;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			vector<T> row;
			for (int i = 0; i < size; i++) {
				TreeNode<T>* p = que.front();
				que.pop();
				if (p->left) que.push(p->left);
				if (p->right) que.push(p->right);
				row.push_back(p->val);
			}
			ans.push_back(row);
		}

		return ans;
	}

    //通过前序和中序建树
	void pre_in_BuildTree(vector<T> pre, vector<T> in) {
		unordered_map<T, int> mp;
		for (int i = 0; i < in.size(); i++) {
			mp[in[i]] = i;
		}
		root = preHelper(pre, in, 0, pre.size() - 1, 0, in.size() - 1, mp);
	}
	TreeNode<T>* preHelper(const vector<T>& pre, const vector<T>& in, int pre_begin, int pre_end, int in_begin, int in_end, unordered_map<T,int>& mp) {
		if (in_begin > in_end) return nullptr;

		T rootVal = pre[pre_begin];
		TreeNode<T>* node = new TreeNode<T>(rootVal);
		int rootIndex = mp[rootVal];
		int leftSize = rootIndex - in_begin;
		node->left = preHelper(pre, in, pre_begin + 1, pre_begin + leftSize, in_begin, rootIndex - 1, mp);
		node->right = preHelper(pre, in, pre_begin + leftSize + 1, pre_end, rootIndex + 1, in_end, mp);
		return node;
	}


    //通过后序和中序建树
	void post_in_BuildTree(vector<T> post, vector<T> in) {
		unordered_map<T, int> mp;
		for (int i = 0; i < in.size(); i++) {
			mp[in[i]] = i;
		}
		root = postHelper(post, in, 0, post.size() - 1, 0, in.size() - 1, mp);
	}
	TreeNode<T>* postHelper(const vector<T>& post, const vector<T>& in, int post_begin, int post_end, int in_begin, int in_end, unordered_map<T, int>& mp) {
		if (in_begin > in_end) return nullptr;

		T rootVal = post[post_end];
		TreeNode<T>* node = new TreeNode<T>(rootVal);
		int rootIndex = mp[rootVal];
		int leftSize = rootIndex - in_begin;
		node->left = postHelper(post, in, post_begin, post_begin + leftSize - 1, in_begin, rootIndex - 1, mp);
		node->right = postHelper(post, in, post_begin + leftSize, post_end - 1, rootIndex + 1, in_end, mp);
		return node;
	}

};