反正就是各种二叉树树
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、已知二叉树的前序和中序遍历还原二叉树
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、二叉树的层序遍历
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、判断是否为平衡二叉树
所谓平衡二叉树就是左右子树的高度相差不大于一即可~~
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、按之字形顺序打印二叉树
先按照层序打印二叉树的原则得到一个数组,然后奇数层不动,偶数层反转。
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、输出二叉树的右视图
先还原二叉树,然后获取二叉树的层序遍历,最后取每个子数组的最后一个值即可。
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、二叉树的最大深度
int maxDepth(TreeNode* root) {
if (root != nullptr) {
return max(maxDepth(root->left), maxDepth(root->right)) + 1;
}
return 0;
}
9、将升序数组转化为平衡二叉搜索树
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、在二叉树中找到两个节点的最近公共祖先
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;
}