系列综述：
💞目的：本系列是个人整理为了
秋招面试的，整理期间苛求每个知识点，平衡理解简易度与深入程度。🥰来源：材料主要源于【CodeTopHot200】进行的，每个知识点的修正和深入主要参考各平台大佬的文章，其中也可能含有少量的个人实验自证，所有代码均优先参考最佳性能。
🤭结语：如果有帮到你的地方，就点个赞和关注一下呗，谢谢🎈🎄🌷！！！
文章目录
-
- 基础知识
-
- 二叉树DFS基本算法
- 相关题目
-
- [236. 二叉树的最近公共祖先](#236. 二叉树的最近公共祖先)
- [110. 判断平衡二叉树（后序遍历的示例）](#110. 判断平衡二叉树（后序遍历的示例）)
- [222. 求树中结点的数量](#222. 求树中结点的数量)
- [226. 翻转二叉树](#226. 翻转二叉树)
- [101. 对称二叉树](#101. 对称二叉树)
- 左叶子之和
- 二叉树的所有路径（带缓存的前序遍历）
- 符合总和的路径
- 参考博客
基础知识
二叉树DFS基本算法
递归算法
-
注意
- 左右子树不需要
if (root->left/rihgt)，因为递归出口已经判断了 - 后序遍历有个好处：可以先收集和处理孩子，然后根节点再进行处理
cpp// 前序遍历 void Traversal(TreeNode *root) { if (root == nullptr) return ; Doing(root->val); // 中 Traversal(root->left); // 左 Traversal(root->right); // 右 } // 中序遍历 void Traversal(TreeNode *root) { if (root == nullptr) return ; Traversal(root->left); // 左 Doing(root->val); // 中 Traversal(root->right); // 右 } // 后序遍历 void Traversal(TreeNode *root, vector<int> vec) { if (root == nullptr) return ; Traversal(root->left); // 左 Traversal(root->right); // 右 vec.emplace_back(root->val);// 中 } - 左右子树不需要
非递归算法
-
注意点
cppvector<int> preorderTraversal(TreeNode* root) { vector<int> res; // 结果容器 stack<TreeNode*> st; // 深度栈 if(root != nullptr) st.push(root); // 根非空则入栈 // 遍历源容器 while (!st.empty()) { // key:注意使用的全部结点都是node // 先记录 TreeNode *node = st.top(); st.pop(); // 后操作 if (node != nullptr) { // 压入允许为逆序，注意根节点要后压入nullptr if (node->right) st.push(node->right); if (node->left) st.push(node->left); st.push(node); st.push(nullptr); } else { // 先记录 node = st.top(); st.pop(); // 后操作 res.emplace_back(node->val); } } return res; }
相关题目
236. 二叉树的最近公共祖先
- 题目
- 给定一个二叉树, 找到该树中两个指定节点p和q的最近公共祖先。
- 复杂度分析：
- 时间复杂度 O(N)： 其中 N为二叉树节点数；最差情况下，需要递归遍历树的所有节点。
- 空间复杂度 O(N)： 最差情况下，递归深度达到 N
- 思路
- 递归出口：如果不是nullptr表示找到了
- 后序遍历：优先遍历左右子树并进行记录
- 结点处理
- 如果左右子树都非空，一定表示该结点为公共祖先结点
- 如果有一个为空，则向上传递非空的那个结点
cpp
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
// 递归出口：返回标志，不为空说明是祖先结点
if (root == p || root == q || root == nullptr)
return root;
// 后序遍历
TreeNode *left = lowestCommonAncestor(root->left, p, q);
TreeNode *right = lowestCommonAncestor(root->right, p, q);
// 中间结点的处理
// 左右都非空表示，该节点为公共祖先结点
if (left != nullptr && right != nullptr)
return root;
// 有一个为空表示，
if (left == nullptr) return right;
if (right == nullptr) return left;
return root;
}110. 判断平衡二叉树（后序遍历的示例）
-
递归法
- 给定一个二叉树，判断它是否是高度平衡的二叉树。
- 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
cpp// 初始化ans为true，最后看ans是否为false即可 int depth(TreeNode* root, bool &ans) { if(!root) return 0; // 后序遍历 int left=1+depth(root->left, ans); int right=1+depth(root->right, ans); if(abs(left-right) > 1) ans = false;// 对根结点的处理 // 递归出口 return max(left,right); // 返回树的高度 } // 尾递归优化：效率高 bool isBalanced(TreeNode* root) { if (root == nulllptr) return true; return abs(depth(root->left) - depth(root->right)) <= 1 && isBalanced(root->left) && isBalanced(root->right); }
222. 求树中结点的数量
-
题目
- 给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。
-
算法
cppint getNodesNum(TreeNode* cur) { if (cur == NULL) return 0; int leftNum = getNodesNum(cur->left); // 左 int rightNum = getNodesNum(cur->right); // 右 int treeNum = leftNum + rightNum + 1; // 中 return treeNum; }
226. 翻转二叉树
- 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
cpp
TreeNode* invertTree(TreeNode* root) {
auto self = [&](auto &&self, TreeNode *root){
if (root == nullptr) return ;
self(self, root->left);
self(self, root->right);
swap(root->left, root->right);
return ;
};
self(self, root);
return root;
}101. 对称二叉树
- 题目
- 求一颗二叉树是否镜像对称
- 求一颗二叉树是否镜像对称
- 思路
- 根节点必定对称，关键是左右两子树的对称
- 左右两个孩子存在的情况下，递归比较左右两颗子树的情况
cpp
bool isSymmetric(TreeNode* root) {
auto self = [&](auto && self, TreeNode *left, TreeNode *right)->bool{
// 递归出口
if (left == nullptr && right == nullptr) return true;
else if (left != nullptr && right == nullptr) return false;
else if (left == nullptr && right != nullptr) return false;
else if (left->val != right->val) return false;
// 后序遍历：递归比较并汇总结果
bool outside = self(self, left->left, right->right);
bool inside = self(self,left->right, right->left);
bool is_same = outside && inside;
// 返回结果
return is_same;
};
return self(self, root->left, root->right);
}左叶子之和
-
- 遍历所有节点，对所求的特殊节点进行约束求值
cppif (node->left != nullptr && node->left->left == nullptr && node->left->right == nullptr) res += node->left->val;
二叉树的所有路径（带缓存的前序遍历）
-
递归
- 数字转化成字符串
to_string(number) - 字符串后追加子串
str.append(subStr) - 字符串删除某个位置之后的字符
str.erase(position)
cpp// 数字型 void dfs(TreeNode*root,vector<int>path, vector<vector<int>> &res) { if(!root) return; //根节点为空直接返回 // 中 path.push_back(root->val); //作出选择 if(!root->left && !root->right) //如果到叶节点 { res.push_back(path); return; } // 左 dfs(root->left,path,res); //继续递归 // 右 dfs(root->right,path,res); } // 字符型 void binaryTree(TreeNode* root,string path,vector<string>&res) { if(root==NULL) return ; path.append(to_string(root->val)); path.append("->"); if(root->left==NULL&&root->right==NULL{ path.erase(path.length()-2); res.push_back(path); } binaryTree(root->left,path,res); binaryTree(root->right,path,res); } vector<string> binaryTreePaths(TreeNode* root) { string path; vector<string>res; binaryTree(root,path,res); return res; } - 数字转化成字符串
符合总和的路径
-
题目
- 判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true；否则，返回 false
cpp// 递归方式：前序遍历，并记录每条路径的和 bool hasPathSum(TreeNode* root, int targetSum) { bool flag = false; auto self = [&](auto &&self, TreeNode *root, int sum){// sum不可全局 if (root == nullptr) return ; // 根结点的处理 sum += root->val; cout << sum << ' '; if (root->left == nullptr && root->right == nullptr && targetSum == sum) flag = true; self(self, root->left, sum); self(self, root->right, sum); }; self(self, root, 0); return flag; } // 非递归 bool hasPathSum(TreeNode* root, int targetSum) { // 初始化 stack<TreeNode*> st; if(root != nullptr) st.push(root); int sum = 0; // 迭代 while(!st.empty()){ TreeNode *cur = st.top(); if(cur != nullptr){ st.pop(); st.push(cur); st.push(nullptr); sum += cur->val; if(cur->right) st.push(cur->right); if(cur->left) st.push(cur->left); }else{ st.pop(); cur = st.top(); st.pop(); // 节点判断 if(sum == targetSum&& cur->left == nullptr && cur->right == nullptr){ return true; }else{// 回溯 sum -= cur->val; } } } return false; }
少年，我观你骨骼清奇，颖悟绝伦，必成人中龙凤。 不如点赞·收藏·关注一波