关于常见的各种二叉树算法题C++代码实现（希望可以持续更新…）

1、定义一颗二叉树

struct TreeNode {
	int val;
	struct TreeNode* left;
	struct TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

2、二叉树的前序、中序、后序遍历

NC45 实现二叉树先序，中序和后序遍历

核心：遍历时第一次遇到则记录（前），第二次遇到则记录（中），第三次遇到则记录（后）

特性：前序（根+左子树+右子树）、中序（左子树+根+右子树）、后序（左子树+右子树+根）

vector<int> firstOrders(TreeNode* root, vector<int>& vec) {
	if (root == nullptr) {
		return vec;
	}
	vec.push_back(root->val);
	firstOrders(root->left, vec);
	firstOrders(root->right, vec);
	return vec;
}

vector<int> secondOrders(TreeNode* root, vector<int>& vec) {
	if (root == nullptr) {
		return vec;
	}
	secondOrders(root->left, vec);
	vec.push_back(root->val);
	secondOrders(root->right, vec);
	return vec;
}

vector<int> thirdOrders(TreeNode* root, vector<int>& vec) {
	if (root == nullptr) {
		return vec;
	}
	thirdOrders(root->left, vec);
	thirdOrders(root->right, vec);
	vec.push_back(root->val);
	return vec;
}


vector<vector<int> > threeOrders(TreeNode* root) {
	vector<vector<int> > ret_v;
	if (root == nullptr) {
		ret_v = { {}, {}, {} };
		return ret_v;
	}
	vector<int> cur_v1;
	cur_v1 = firstOrders(root, cur_v1);
	ret_v.push_back(cur_v1);

	vector<int> cur_v2;
	cur_v2 = secondOrders(root, cur_v2);
	ret_v.push_back(cur_v2);

	vector<int> cur_v3;
	cur_v3 = thirdOrders(root, cur_v3);
	ret_v.push_back(cur_v3);

	return ret_v;
}

3、已知二叉树的前序和中序遍历还原二叉树

NC12 重建二叉树

TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin) {
	if (pre.empty() || vin.empty() || pre.size() != vin.size()) {
		return  nullptr;
	}
	int index = 0;
	TreeNode* pRoot = new TreeNode(pre[0]);
	vector<int> left_pre;
	vector<int> left_vin;
	vector<int> right_pre;
	vector<int> right_vin;
	for (size_t i = 0; i < vin.size(); ++i) {
		if (vin[i] == pre[0]) {
			index = i;
			break;
		}
	}
	for (int i = 0; i < index; ++i) {
		left_pre.push_back(pre[i + 1]);
		left_vin.push_back(vin[i]);
	}
	for (int i = index + 1; i < (int)vin.size(); ++i) {
		right_pre.push_back(pre[i]);
		right_vin.push_back(vin[i]);
	}
	pRoot->left = reConstructBinaryTree(left_pre, left_vin);
	pRoot->right = reConstructBinaryTree(right_pre, right_vin);
	return pRoot;
}

4、二叉树的层序遍历

NC15 求二叉树的层序遍历

vector<vector<int> > levelOrder1(TreeNode* root) {
	vector<vector<int>> v;
	if (root == nullptr) {
		return v;
	}
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty()) {
		vector<int> cur_v;
		size_t size = q.size();
		while (size > 0) {
			TreeNode* node = q.front();
			q.pop();
			cur_v.push_back(node->val);
			if(node->left != nullptr){
				q.push(node->left);
			}
			if (node->right != nullptr) {
				q.push(node->right);
			}
			size--;
		}
		if (cur_v.size() > 0) {
			v.push_back(cur_v);
		}
	}
	return v;
}

5、判断是否为平衡二叉树

NC62 判断是不是平衡二叉树

所谓平衡二叉树就是左右子树的高度相差不大于一即可~~

int height(TreeNode* root) {
	if (root != nullptr) {
		return max(height(root->left), height(root->right)) + 1;
	}
	return 0;
}

bool IsBalanced_Solution(TreeNode* pRoot) {
	if (pRoot == nullptr) {
		return true;
	}
	int left_h = height(pRoot->left);
	int right_h = height(pRoot->right);
	int num = left_h - right_h;
	if (num > 1 || num < -1) {
		return false;
	}
	return IsBalanced_Solution(pRoot->left) && IsBalanced_Solution(pRoot->right);
}

6、按之字形顺序打印二叉树

NC14 按之字形顺序打印二叉树

先按照层序打印二叉树的原则得到一个数组，然后奇数层不动，偶数层反转。

vector<int> ReverseVec(vector<int>& v) {
	if (!v.empty()) {
		reverse(v.begin(), v.end());
	}
	return v;
}

vector<vector<int> > Print(TreeNode* pRoot) {
	vector<vector<int>> v;
	if (pRoot == nullptr) {
		return v;
	}
	queue<TreeNode*> q;
	q.push(pRoot);
	while(!q.empty()){
		vector<int> vc;
		size_t size = q.size();
		while (size) {
			TreeNode* node = q.front();
			q.pop();
			vc.push_back(node->val);
			if (node->left != nullptr) {
				q.push(node->left);
			}
			if (node->right != nullptr) {
				q.push(node->right);
			}
			size--;
		}
		v.push_back(vc);
	}
	int num = 1;
	for (size_t i = 0; i < v.size(); ++i) {
		if (num % 2 != 0) {
			v[i] = ReverseVec(v[i]);
		}
		++num;
	}
	return v;
}

7、输出二叉树的右视图

NC136 输出二叉树的右视图

先还原二叉树，然后获取二叉树的层序遍历，最后取每个子数组的最后一个值即可。

TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin) {
	if (pre.empty() || vin.empty() || pre.size() != vin.size()) {
		return  nullptr;
	}
	int index = 0;
	TreeNode* pRoot = new TreeNode(pre[0]);
	vector<int> left_pre;
	vector<int> left_vin;
	vector<int> right_pre;
	vector<int> right_vin;
	for (size_t i = 0; i < vin.size(); ++i) {
		if (vin[i] == pre[0]) {
			index = i;
			break;
		}
	}
	for (int i = 0; i < index; ++i) {
		left_pre.push_back(pre[i + 1]);
		left_vin.push_back(vin[i]);
	}
	for (int i = index + 1; i < (int)vin.size(); ++i) {
		right_pre.push_back(pre[i]);
		right_vin.push_back(vin[i]);
	}
	pRoot->left = reConstructBinaryTree(left_pre, left_vin);
	pRoot->right = reConstructBinaryTree(right_pre, right_vin);
	return pRoot;
}
vector<int> solve(vector<int>& xianxu, vector<int>& zhongxu) {
	vector<int> v;
	if (xianxu.empty() || zhongxu.empty()) {
		return v;
	}
	//还原二叉树
	TreeNode* pRoot = reConstructBinaryTree(xianxu, zhongxu);

	//获取层序遍历
	vector<vector<int>> vc_ret;
	queue<TreeNode*> q;
	q.push(pRoot);
	while (!q.empty()) {
		vector<int> vc;
		size_t size = q.size();
		while (size) {
			TreeNode* node = q.front();
			q.pop();
			vc.push_back(node->val);
			if (node->left != nullptr) {
				q.push(node->left);
			}
			if (node->right != nullptr) {
				q.push(node->right);
			}
			size--;
		}
		vc_ret.push_back(vc);
	}
	//取层序遍历的每个子数组的最后一个值
	for (size_t i = 0; i < vc_ret.size(); ++i) {
		v.push_back(vc_ret[i][vc_ret[i].size() - 1]);
	}
	return v;
}

8、二叉树的最大深度

NC13 二叉树的最大深度

int maxDepth(TreeNode* root) {
	if (root != nullptr) {
		return max(maxDepth(root->left), maxDepth(root->right)) + 1;
	}
	return 0;
}

9、将升序数组转化为平衡二叉搜索树

NC11 将升序数组转化为平衡二叉搜索树

TreeNode* createBST(vector<int>& v, int left, int right) {
	if (left > right) {
		return nullptr;
	}
	int mid = (left + right + 1) / 2;
	TreeNode* root = new TreeNode(v[mid]);
	root->left = createBST(v, left, mid - 1);
	root->right = createBST(v, mid + 1, right);
	return root;
}

TreeNode* sortedArrayToBST(vector<int>& num) {
	if (num.empty()) {
		return nullptr;
	}
	return createBST(num, 0, num.size() - 1);
}

10、在二叉树中找到两个节点的最近公共祖先

NC102 在二叉树中找到两个节点的最近公共祖先

TreeNode* bfsTree(TreeNode* root, int o1, int o2) {
	if (root == nullptr || root->val == o1 || root->val == o2) {
		return root;
	}
	TreeNode* left = bfsTree(root->left, o1, o2);
	TreeNode* right = bfsTree(root->right, o1, o2);
	if (left == nullptr) {
		return right;
	}
	if (right == nullptr) {
		return left;
	}
	return root;
}

int lowestCommonAncestor(TreeNode* root, int o1, int o2) {
	TreeNode* node = bfsTree(root, o1, o2);
	return node->val;
}