树相关
1.重建二叉树
1 class Solution { 2 public: 3 TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) { 4 if(pre.size() == 0 || vin.size() == 0) 5 return nullptr; 6 return constructCore(pre, vin, 0, pre.size()-1, 0, vin.size()-1); 7 } 8 9 TreeNode* constructCore(vector<int> pre,vector<int> vin, int sp, int ep, int si, int ei) 10 { 11 //sp, ep 确定先序中树的范围，si，ei确定中序的子树范围 12 //先序头就是根 13 int rootValue = pre[sp]; 14 TreeNode* root = new TreeNode(rootValue); 15 if(sp == ep) 16 { 17 if(si == ei && pre[sp] == vin[si]) 18 return root; 19 } 20 //中序找到根，分为左右子树 21 int index = si; 22 while(index <= ei && vin[index] != rootValue) 23 ++index; 24 int leftLen = index-si;//左子树长度 25 if(leftLen > 0) 26 { 27 root->left = constructCore(pre, vin, sp+1, sp+leftLen, si, index-1); 28 } 29 if(leftLen < ep-sp) 30 { 31 root->right = constructCore(pre, vin, sp+leftLen+1, ep, index+1, ei); 32 } 33 return root; 34 } 35 };
2.树的子结构
1 class Solution { 2 public: 3 bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) 4 { 5 //tree2空或者tree1空都不符合,问清楚空树是不是子树 6 if(pRoot2 == nullptr || pRoot1 == nullptr) 7 return false; 8 bool res = false; 9 if(pRoot1 != nullptr && pRoot2 != nullptr) 10 { 11 if(pRoot1->val == pRoot2->val)//找到匹配的根 12 res = isSubTree(pRoot1, pRoot2); 13 if(!res)//未找到，递归左节点 14 res = HasSubtree(pRoot1->left, pRoot2); 15 if(!res)//未找到，递归节点 16 res = HasSubtree(pRoot1->right, pRoot2); 17 } 18 return res; 19 } 20 //判断是否是子树 21 bool isSubTree(TreeNode* pRoot1, TreeNode* pRoot2) 22 { 23 //tree2先遍历结束，重合 24 if(pRoot2 == nullptr) 25 return true; 26 //主树先结束，不重合 27 if(pRoot1 == nullptr) 28 return false; 29 //对于节点值不等，不重合 30 if(pRoot1->val != pRoot2->val) 31 return false; 32 33 //节点值相等，递归判断左右子树 34 return isSubTree(pRoot1->left, pRoot2->left) 35 && isSubTree(pRoot1->right, pRoot2->right); 36 } 37 };
3.二叉树镜像
1 class Solution { 2 public: 3 void Mirror(TreeNode *pRoot) { 4 //前序遍历（根左右）树每个节点，如果节点有子节点，就交换子节点，直到叶子节点 5 //处理空树 6 if(pRoot == nullptr) 7 return; 8 //到达叶子节点 9 if(pRoot->left == nullptr && pRoot->right == nullptr) 10 return; 11 //交换子节点 12 TreeNode* tmp = pRoot->left; 13 pRoot->left = pRoot->right; 14 pRoot->right = tmp; 15 //递归左子树 16 if(pRoot->left) 17 Mirror(pRoot->left);//不要return，因为void不返回 18 19 //递归右子树 20 if(pRoot->right) 21 Mirror(pRoot->right); 22 } 23 };
4.对称二叉树
1 class Solution { 2 public: 3 bool isSymmetrical(TreeNode* pRoot) 4 { 5 return isSymmetrical(pRoot, pRoot); 6 } 7 8 bool isSymmetrical(TreeNode* pRoot1, TreeNode* pRoot2) 9 { 10 if(pRoot1 == nullptr && pRoot2 == nullptr)//都空，对称 11 return true; 12 if(pRoot1 == nullptr || pRoot2 == nullptr)//一空一不空。不对称 13 return false; 14 if(pRoot1->val != pRoot2->val)//都不空，值不等，不对称，写了return true就无法再往下遍历了 15 return false; 16 //都不空，且值相等，在比较下一个节点 17 return isSymmetrical(pRoot1->left, pRoot2->right) 18 && isSymmetrical(pRoot1->right, pRoot2->left); 19 } 20 };
5.二叉树前中后续遍历，递归和循环版
递归就是递归，循环实现用栈（前序中序比较简单，后续的话需要简单修改一下前序遍历，反转即可）
前序遍历非递归版
1 class Solution { 2 public: 3 vector<int> res; 4 vector<int> preorderTraversal(TreeNode *root) { 5 if(!root) 6 return {}; 7 stack<TreeNode*> s; 8 s.push(root); 9 while(!s.empty()) 10 { 11 auto p = s.top(); 12 s.pop(); 13 res.push_back(p->val); 14 if(p->right) 15 s.push(p->right); 16 if(p->left) 17 s.push(p->left); 18 } 19 return res; 20 } 21 };
6.后序遍历非递归版
1 class Solution { 2 public: 3 //一个巧妙地算法，先序遍历:根->左->右，根据出栈顺序根->右->左reverse,变成 左->右->根 4 vector<int> res; 5 vector<int> postorderTraversal(TreeNode *root) { 6 if(root == nullptr) 7 return {}; 8 stack<TreeNode*> s; 9 s.push(root); 10 while(!s.empty()) 11 { 12 auto p = s.top(); 13 s.pop(); 14 res.push_back(p->val); 15 if(p->left) 16 s.push(p->left); 17 if(p->right) 18 s.push(p->right); 19 } 20 reverse(res.begin(), res.end()); 21 return res; 22 } 23 };
7.二叉树中和为某值的路径
1 class Solution { 2 public: 3 vector<vector<int> > res; 4 //递归解决，防止段错误 5 vector<vector<int> > FindPath(TreeNode* root,int expectNumber) { 6 if(root == nullptr) 7 return res; 8 vector<int> cur; 9 find(root, expectNumber, cur); 10 return res; 11 } 12 13 void find(TreeNode* root, int target, vector<int> cur) 14 { 15 if(root == nullptr) 16 return ; 17 cur.push_back(root->val); 18 if((target-root->val) == 0 && root->left == nullptr && root->right == nullptr) 19 res.push_back(cur); 20 else 21 { 22 if(root->left) 23 find(root->left, target-root->val, cur); 24 if(root->right) 25 find(root->right, target-root->val, cur); 26 } 27 } 28 };
8.二叉树的深度
（递归）
1 class Solution { 2 public: 3 int res = 0; 4 int TreeDepth(TreeNode* pRoot) 5 { 6 int depth = 0; 7 getDepth(pRoot, depth); 8 return res; 9 } 10 11 //递归函数，每遇到null节点说明到底了，更新res 12 void getDepth(TreeNode* root, int depth) 13 { 14 if(root == nullptr) 15 { 16 res = (depth > res) ? depth : res; 17 return ; 18 } 19 else 20 { 21 getDepth(root->left, depth+1); 22 getDepth(root->right, depth+1); 23 } 24 } 25 };
非递归（使用队列BFS层序遍历 数层数）
class Solution { public: //非递归，使用BFS栈来解决问题,其中的打印内容可以辅助查看具体过程 int TreeDepth(TreeNode *pRoot) { if (pRoot == nullptr) return 0; queue<TreeNode *> s; s.push(pRoot); int depth = 0; while (!s.empty()) { depth++; int len = s.size(); cout << "第" << depth << "层，共有节点：" << len << "个" << endl; for (int i = 0; i < len; i++) { auto p = s.front(); s.pop(); cout << p->val << "出栈" << endl; if (p->left) { s.push(p->left); cout << p->left->val << "入栈" << endl; } if (p->right) { s.push(p->right); cout << p->right->val << "入栈" << endl; } } } return depth; } };
9.二叉树的最小深度（使用队列来实现,将上面一个算法简单改改即可：在第一次左右子节点都不存在时，跳出即可）
1 class Solution { 2 public: 3 //那我也用层序遍历(BFS)试试吧 4 int run1(TreeNode *root) { 5 if(root == nullptr) 6 return 0; 7 8 queue<TreeNode*> q; 9 q.push(root); 10 int depth = 0; 11 while(!q.empty()) 12 { 13 depth++; 14 int len = q.size(); 15 for(int i=0; i<len; i++) 16 { 17 auto p = q.front(); 18 q.pop(); 19 if(p->left == nullptr && p->right == nullptr) 20 return depth; 21 if(p->left) 22 q.push(p->left); 23 if(p->right) 24 q.push(p->right); 25 } 26 } 27 return depth; 28 } 29 //从上述方法我们可以想到，求算二叉树深度，也可以采用此法，跟我们原来的做法略有不同 30 31 //神奇的递归做法 32 int run(TreeNode *root) { 33 if(root == nullptr) 34 return 0; 35 int l = run(root->left); 36 int r = run(root->right); 37 if(l == 0 || r == 0) 38 return 1+l+r; 39 else 40 return 1+min(l, r); 41 } 42 };
序列化和反序列化二叉树