#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <map>
template <class T>
typedef struct node {
node* left;
node* right;
T val;
std::string ext;
node(T val) : left(nullptr), right(nullptr), val(val), ext(""){}
};
typedef node<int> Node;
Node* creat_normal_tree() {
Node* pRoot = new Node(5);
pRoot->left = new Node(3);
pRoot->left->left = new Node(1);
pRoot->left->right = new Node(4);
pRoot->right = new Node(8);
pRoot->right->left = new Node(7);
pRoot->right->right = new Node(9);
return pRoot;
}
Node* creat_normal_tree2() {
Node* pRoot = new Node(5);
pRoot->left = new Node(8);
pRoot->left->left = new Node(9);
pRoot->left->right = new Node(7);
pRoot->right = new Node(3);
pRoot->right->left = new Node(4);
pRoot->right->right = new Node(1);
return pRoot;
}
#define CHECK_NULL_RET(pRoot, ret) {
if (nullptr == pRoot) {
return ret;
}
}
#define CHECK_NULL_VOID(pRoot) {
if (nullptr == pRoot) {
return;
}
}
/*************************二叉树遍历*****************************/
// 前序
void pre_order_r(Node* pRoot) {
if (nullptr == pRoot) {
return;
}
std::cout << pRoot->val << ",";
pre_order_r(pRoot->left);
pre_order_r(pRoot->right);
}
void pre_order_stack(Node* pRoot) {
if (nullptr == pRoot) {
return;
}
Node* pCur = pRoot;
std::stack<Node*> helper;
helper.push(pCur);
while (!helper.empty()) {
Node* pTmp = helper.top();
helper.pop();
std::cout << pTmp->val << ",";
if (pTmp->right) {
helper.push(pTmp->right);
}
if (pTmp->left) {
helper.push(pTmp->left);
}
}
}
// 中序
void in_order_r(Node* pRoot) {
if (nullptr == pRoot) {
return;
}
in_order_r(pRoot->left);
std::cout << pRoot->val << ",";
in_order_r(pRoot->right);
}
void in_order_stack(Node* pRoot) {
if (nullptr == pRoot) {
return ;
}
std::stack<Node*> helper;
Node* pCur = pRoot;
while (pCur || !helper.empty()) {
if (pCur) {
helper.push(pCur);
pCur = pCur->left;
} else {
Node* pTop = helper.top();
helper.pop();
std::cout << pTop->val << ",";
pCur = pTop->right;
}
}
}
// 后序
void post_order_r(Node* pRoot) {
if (nullptr == pRoot) {
return;
}
post_order_r(pRoot->left);
post_order_r(pRoot->right);
std::cout << pRoot->val << ",";
}
void post_order_stack(Node* pRoot) {
if (nullptr == pRoot) {
return;
}
std::stack<Node*> helper;
Node* pCur = pRoot;
while (pCur || !helper.empty()) {
if (pCur) {
helper.push(pCur);
pCur = pCur->left;
} else {
Node* pTop = helper.top();
if (std::strcmp(pTop->ext.c_str(), "visited") == 0) {
std::cout << pTop->val << ",";
helper.pop();
} else {
pTop->ext = "visited";
pCur = pTop->right;
}
}
}
}
// 层序遍历, 同时按照层数保存数据
void leve_order_queue(Node* pRoot, std::map<int, std::vector<int>> &s_out) {
if (nullptr == pRoot) {
return;
}
std::queue<Node*> helper;
helper.push(pRoot);
std::vector<int> vec;
Node* pHelper = new Node(-1);
pHelper->ext = "helper";
helper.push(pHelper);
int level = 1;
while (!helper.empty()) {
Node* pFront = helper.front();
helper.pop();
if (strcmp(pFront->ext.c_str(), "helper") == 0) {
if (helper.empty()) {
break;
} else {
++level;
helper.push(pHelper);
}
} else {
std::cout << pFront->val << ",";
s_out[level].push_back(pFront->val);
if (pFront->left) {
helper.push(pFront->left);
}
if (pFront->right) {
helper.push(pFront->right);
}
}
}
}
/*************************Search end*****************************/
/*************************合并两个二叉搜索树*****************************/
// step 1 get in order arrs
void get_order_arr(Node* pRoot, std::vector<int> &out) {
if (nullptr == pRoot) {
return;
}
get_order_arr(pRoot->left, out);
out.push_back(pRoot->val);
get_order_arr(pRoot->right, out);
}
// step 2 insert node into bst
Node* insert_node_into_bst(Node* pRoot, int val) {
if (nullptr == pRoot) {
pRoot = new Node(val);
return pRoot;
}
// val != pRoot->val in bst
if (pRoot->val < val) {
pRoot->right = insert_node_into_bst(pRoot->right, val);
}
if (pRoot->val > val) {
pRoot->left = insert_node_into_bst(pRoot->left, val);
}
return pRoot;
}
// step 3 Merge
Node* merge_bsts(Node* pRoot1, Node* pRoot2) {
// special cases
if (nullptr == pRoot1 && nullptr == pRoot2) {
return nullptr;
}
if (nullptr == pRoot1) {
return pRoot2;
}
if (nullptr == pRoot2) {
return pRoot1;
}
// in order arr
std::vector<int> helper;
get_order_arr(pRoot1, helper);
// insert into tree2
for (auto itr:helper) {
insert_node_into_bst(pRoot2, itr);
}
return pRoot2;
}
/*************************合并两个二叉搜索树*****************************/
/*************************二叉树最大深int度*****************************/
int get_max_depth(Node* pRoot) {
CHECK_NULL_RET(pRoot, 0);
int left = get_max_depth(pRoot->left) + 1;
int right = get_max_depth(pRoot->right) + 1;
return std::max(left, right);
}
/*************************二叉树最大深度*****************************/
/*************************二叉树最小深度*****************************/
int get_min_depth(Node* pRoot) {
CHECK_NULL_RET(pRoot, 0);
int left = get_min_depth(pRoot->left);
int right = get_min_depth(pRoot->right);
if (left * right == 0) {
return (left + right + 1);
} else {
return std::min(left + 1, right + 1);
}
}
/*************************二叉树最小深度*****************************/
/*************************重建二叉树*****************************/
Node* rebuild_tree_by_pre_in_arrs(std::vector<int> &pre_order, std::vector<int> &in_order) {
// 递归终止
if (pre_order.size() == 1) {
return new Node(pre_order[0]);
}
if (in_order.size() == 1) {
return new Node(in_order[0]);
}
// 创建根节点
Node* pRoot = new Node(pre_order[0]);
// 左子树中序
std::vector<int> left_in;
// 左树节点数量
int left_cnt = 0;
for (int i=0; i < in_order.size(); ++i) {
if (pre_order[0] == in_order[i]) {
break;
} else {
++left_cnt;
left_in.push_back(in_order[i]);
}
}
// 左树先序
std::vector<int> left_pre(pre_order.begin() + 1, pre_order.begin() + left_cnt + 1);
// 右树先序
std::vector<int> right_pre(pre_order.begin() + left_cnt + 1, pre_order.end());
// 右树中序
std::vector<int> right_in(in_order.begin() + left_cnt + 1, in_order.end());
pRoot->left = rebuild_tree_by_pre_in_arrs(left_pre, left_in);
pRoot->right = rebuild_tree_by_pre_in_arrs(right_pre, right_in);
return pRoot;
}
/*************************重建二叉树*****************************/
/*************************二叉树叶子节点个数*****************************/
int get_nodes_cnt(Node* pRoot) {
if (nullptr == pRoot) {
return 0;
}
if (nullptr == pRoot->left && nullptr == pRoot->right) {
return 1;
}
return get_nodes_cnt(pRoot->left) + get_nodes_cnt(pRoot->right) + 1;
}
/*************************二叉树节点个数*****************************/
/*************************判断二叉树是否是平衡二叉树*****************************/
// 判断以pRoot为根节点的树是否是平衡的
int is_node_balanced(Node* pRoot) {
if (nullptr == pRoot) {
return 0;
}
int left = is_node_balanced(pRoot->left);
int right = is_node_balanced(pRoot->right);
// 如果当前节点子节点不平衡, 或者当前节点本身不平衡, 返回-1
if (left == -1 || right == -1 || std::abs(left - right) > 1) {
return -1;
}
// 如果当前节点是平衡的, 返回当前节点的最大深度
return std::max(left, right) + 1;
}
bool is_avl(Node* pRoot) {
return is_node_balanced(pRoot) == -1 ? false : true;
}
/*************************判断二叉树是否是平衡二叉树*****************************/
/*************************两个二叉树是否完全相同*****************************/
bool is_same_tree(Node* pRoot1, Node* pRoot2) {
if (nullptr == pRoot1 && nullptr == pRoot2) {
return true;
}
if (nullptr == pRoot1 || nullptr == pRoot2) {
return false;
}
if (pRoot1->val != pRoot2->val) {
return false;
}
return is_same_tree(pRoot1->left, pRoot2->left) && is_same_tree(pRoot1->right, pRoot2->right);
}
/*************************两个二叉树是否完全相同*****************************/
/*************************两个二叉树是否互为镜像*****************************/
bool is_mirror_trees(Node* pRoot1, Node* pRoot2) {
if (nullptr == pRoot1 && nullptr == pRoot2) {
return true;
}
if (nullptr == pRoot1 || nullptr == pRoot2) {
return false;
}
if (pRoot1->val != pRoot2->val) {
return false;
}
return is_mirror_trees(pRoot1->left, pRoot2->right) && is_mirror_trees(pRoot1->right, pRoot2->left);
}
/*************************两个二叉树是否互为镜像*****************************/
/*************************求二叉树的镜像*****************************/
Node* get_mirror_tree(Node* pRoot) {
if (nullptr == pRoot) {
return nullptr;
}
pRoot->left = get_mirror_tree(pRoot->right);
pRoot->right = get_mirror_tree(pRoot->left);
return pRoot;
}
/*************************求二叉树的镜像*****************************/
/*************************求两个二叉树的最低公共祖先节点*****************************/
bool find_node(Node* pNode, Node* pRoot) {
if (nullptr == pRoot || nullptr == pNode) {
return false;
}
if (pNode->val == pRoot->val) {
return false;
}
return find_node(pNode, pRoot->left) || find_node(pNode, pRoot);
}
Node* find_latest_common_ancestor(Node* pNode1, Node* pNode2, Node* pRoot) {
if (find_node(pNode1, pRoot->left)) {
if (find_node(pNode2, pRoot->right)) {
return pRoot;
} else {
return find_latest_common_ancestor(pNode1, pNode2, pRoot->left);
}
} else {
if (find_node(pNode2, pRoot->left)) {
return pRoot;
} else {
find_latest_common_ancestor(pNode1, pNode2, pRoot->right);
}
};
}
/*************************求两个二叉树的最低公共祖先节点*****************************/
/*************************输入一个二叉树和一个整数，打印出二叉树中节点值的和等于输入整数所有的路径*****************************/
void get_root_path(Node* pRoot, int target, std::vector<std::vector<Node*>> &out, std::vector<Node*> helper) {
if (nullptr == pRoot) {
return;
}
helper.push_back(pRoot);
if (nullptr == pRoot->left && nullptr == pRoot->right && target - pRoot->val == 0) {
out.push_back(helper);
helper.clear();
}
if (pRoot->left) {
get_root_path(pRoot->left, target-pRoot->val, out, helper);
}
if (pRoot->right) {
get_root_path(pRoot->right, target-pRoot->val, out, helper);
}
helper.pop_back();
}
/*************************输入一个二叉树和一个整数，打印出二叉树中节点值的和等于输入整数所有的路径*****************************/
/*************************二叉树内两个节点的最长距离*****************************/
/*************************二叉树内两个节点的最长距离*****************************/
/*************************1-N个数可以构成多少个不同的二叉搜索树*****************************/
int get_bst_cnt(int N) {
std::vector <int> helper(N+1, 0);
helper[0] = 1;
helper[1] = 1;
for (int i = 2; i <= N; ++i) {
// 当 N=i 时
for (int root = 0; root < i; ++root) {
// 左子树个数*右子树个数
int cur = helper[root] * helper[i-root -1];
helper[i] += cur;
}
}
return helper[N];
}
// https://blog.csdn.net/sinat_35261315/article/details/78678961
/*************************1-N个数可以构成多少个不同的二叉搜索树*****************************/
/*************************判断二叉树是否是完全二叉树*****************************/
bool is_completed_tree(Node* pRoot) {
}
/*************************判断二叉树是否是完全二叉树*****************************/
int main() {
std::cout << "Hello, World!" << std::endl;
Node* pRoot = creat_normal_tree();
in_order_r(pRoot);
std::cout << std::endl;
std::vector<std::vector<Node*>> out;
std::vector<Node*> helper;
get_root_path(pRoot, 12, out, helper);
int a = 1;
return 0;
}