devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

学会二叉树不知道干啥?二叉树的深度优先搜索和广度优先搜索,我要打十个乃至二十个(打开你的LeetCode撸起来)学练并举_二叉树深度搜索

作者：2023面试高手 | 2024-04-09 15:09:53

赞

踩

二叉树深度搜索

目录

一. 图解二叉树的深度优先搜索

二. 二叉树的广度优先搜索  (层序遍历)

三. 打开LeetCode 撸起来

至此, 咱多少被刚刚的后序非递归搞得可能有点小晕晕的, 没事,层序简单呀....  (层序就是纯模板, 打10个小意思)

然后如下的就是一些经典性的题目. 二叉树的最近公共祖先  +  建立二叉树   （又特别是建立二叉树，其实算是蛮不好处理的题目）

四, 总结(外加建议)

一. 图解二叉树的深度优先搜索

  • 然后提到深度优先搜索必然是离不开三种二叉树的深搜遍历方式的:
  • 前序遍历:  根部 左子树 右子树
  • 中序遍历：左子树  根部 右子树
  • 后序遍历:  左子树 右子树 根部

到了此处 大家都很气愤了, 在学校里的时候三种遍历方式就没完全搞透澈过, 每次都是跟着感觉走, 写代码的话就也只是会写递归, 不过不怕了, 图形结合 递归代码, 咱走一走:

  • 好了艰难的地方过去了, 其实上述告知的不是一个具体的万能公式啥的, 也不是要你记住就OK了, 如果是大佬就不用看了, 因为大佬堪称人肉递归机器.   但是咱初学者要是真想好好理解递归函数一定要自己这样按照短小的代码展开去感受一下, 真正的身临其境的走一遭, 真的会有一番不同的感受的  (真心的一点小建议)
  • 好了还是把刚刚的问题解决了, 三种遍历方式咋看都没说:   (要是上述的这些过程都看懂了这个也就是一个小意思了)    
  • 有一个技巧是三个三个节点的来看, 但是 要清楚的留空,   此处的技巧就在留下空格
  • 前序举个例子:  根部   左子树   右子树

  •  至此, 大家都是完全知道咋办了, 我觉着另外两种以聪明的大家肯定可以自行脑补了

二. 二叉树的广度优先搜索  (层序遍历)

  • 二叉树的广度优先搜索也称层序遍历就非常的简单了....  人如其名(当然不是人)  遍历方式如同意思(就是一层一层的遍历二叉树, 一层一层的扫)
  • 思考一下？？？？  我想实现的是一层一层的扫描? 如何可以办到?

 

  • 总结道理:  利用队列这个数据结构, 出上一层元素, 出的时候用上一层带入下一层的元数就OK了     代码模型如下
  1. //版本1
  2. void LevelOrder(Node* root) {
  3. 	queue<Node*> q;
  4. 	q.push(root);
  5. 	while (!q.empty()) {
  6. 		Node* pCur = q.front();//拿出上一层的节点
  7. 		cout << pCur->val << " ";//打印
  8. 		q.pop();//弹出本层节点
  9. 		if (pCur->left) q.push(pCur->left);
  10. 		if (pCur->right) q.push(pCur->right);
  11. 		//入下一层的节点
  12. 	}
  13. }
  14. //版本2：
  15. void LevelOrder2(Node* root) {
  16. 	queue<Node*> q;
  17. 	q.push(root);
  18. 	while (!q.empty()) {
  19.         int n = q.size();//计算本层节点数目
  20.         for (int i = 0; i < n; ++i) {//除去本层,入下一层
  21.             Node* pCur = q.front();
  22. 		    cout << pCur->val << " ";
  23. 		    q.pop();
  24. 		    if (pCur->left) q.push(pCur->left);
  25. 		    if (pCur->right) q.push(pCur->right);
  26.         }
  27. 	}
  28. }

三. 打开LeetCode 撸起来

144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

这个题目使用递归的话及其的简单, 就是cout << "根部"; 递归遍历Func(左子树), 递归Func(右子树)....    只不过此处的cout需要改成 push_back 存储在vector中作为结果

写递归三要素:    边界条件     递归统一的操作是什么   返回值  (写递归的时候一定向着这三点上面思考)

  1. class Solution {
  2.     void PreOrder(TreeNode* root, vector<int>& ans) {
  3.         //if (!root) return ; !root 等效rooot == nullptr
  4.         if (root == nullptr) return ;//终点(边界)
  5.         //中间操作
  6.         ans.push_back(root->val);
  7.         PreOrder(root->left, ans);
  8.         PreOrder(root->right, ans);
  9.         return ;//返回值
  10.     }
  11. public:
  12.     vector<int> preorderTraversal(TreeNode* root) {
  13.         vector<int > ans;//存储遍历结果
  14.         ans.clear();//清空容器
  15.         PreOrder(root, ans);
  16.         return ans;
  17.     }
  18. };

小爽一把:  咱自己按照上述的方式去写如下两道题目：咱都知道写起来很简单, 但是养成写递归的习惯, 习惯性的思考三要素.  对于递归的培养还是蛮有好处的）

94. 二叉树的中序遍历

145. 二叉树的后序遍历

使用递归写上述题目确实非常的简单, 仅仅算得上是简单题目, 这个是因为具体的深入不了的回溯过程   +   系统栈  都是递归函数帮助我们隐形的处理了, 所以上述过程变得及其简单好写, 弊端, 不便于对于整个遍历过程的思考,

好了咱自己模拟系统栈的回溯， 用栈辅助实现递归一般的深入和回溯. 还是哪个整体的思路, 先一条路往深了走， 走不动咱就回溯一步. 往其他路走....

  1. class Solution {
  2. public:
  3.     vector<int> preorderTraversal(TreeNode* root) {
  4.         vector<int > ans;//存储遍历结果
  5.         ans.clear();//清空容器
  6.         stack<TreeNode*> st;
  7.         TreeNode* p = root;
  8.         while (p || !st.empty()) {
  9.             //循环结束条件 p空 + st空
  10.             while (p) {
  11.                 ans.push_back(p->val);//遍历根部
  12.                 st.push(p);//入栈根部,为了回溯
  13.                 p = p->left;//左深入
  14.             }
  15.             //自此处, p深入到NULL,需要回溯一步走另一边
  16.             //栈顶存储的是前面的节点,回溯就是往回走,取栈顶
  17.             TreeNode* oldP = st.top();//回溯节点
  18.             st.pop();//弹出
  19.             p = oldP->right;//搜索另一边
  20.         }
  21.         return ans;
  22.     }
  23. };

跟着上述思路走, 完全小小的修改便可以写出中序遍历了,

但是后序遍历没那么简单，写非递归?          后序  左子树 右子树 根部.  （why？） 存在两次回溯, 如何判断是第一次回溯还是第二次回溯, 这个算是一个思考题了, 说实话不好想, 大佬除外, 突破点：标记, 代码我附在下面大家可以简单的思考一下如果感兴趣的...（大佬路过就行） 

思考这样一个问题. 每一次从右边回溯上去到之前的根部节点, 你都会思考我刚刚是从左边上来的还是右边上来的? 如果是左边继续走右, 如果是右边, 遍历根部

  1. class Solution {
  2. public:
  3.     vector<int> postorderTraversal(TreeNode* root) {
  4.         vector<int > ans;//存储结果
  5.         ans.clear();
  6.         stack<TreeNode*> st;
  7.         TreeNode* p = root;
  8.         TreeNode* usedP = nullptr;//标记刚刚走过
  9.         while (p || !st.empty()) {
  10.             //先深入左边
  11.             while (p) {
  12.                 st.push(p);//存储根部为了后序回溯
  13.                 p = p->left;//深入左
  14.                 //对比前序不能入根部?
  15.                 //左子树 右子树 根部(你懂)
  16.             }
  17.             //至此说明p走到空
  18.             TreeNode* oldP = st.top();//回溯
  19.             //思考, 我是有没有走过右边, 是从右边还是左边上来的?
  20.             if (oldP->right && oldP->right != usedP) {
  21.                 p = oldP->right;//深入右
  22.             } else {
  23.                 //左子树走了, 右子树是空或者走了, 入根部
  24.                 ans.push_back(oldP->val);
  25.                 usedP = oldP;//走过, 标记走过
  26.                 st.pop();
  27.             }
  28.         }
  29.         return ans;
  30.     }
  31. };

去掉冗余注释版本:  会的人看的

  1. class Solution {
  2. public:
  3.     vector<int> postorderTraversal(TreeNode* root) {
  4.         vector<int > ans;//存储结果
  5.         ans.clear();
  6.         stack<TreeNode*> st;
  7.         TreeNode* p = root;
  8.         TreeNode* usedP = nullptr;//标记刚刚走过
  9.         while (p || !st.empty()) {
  10.             //先深入左边
  11.             while (p) {
  12.                 st.push(p);//存储根部为了后序回溯
  13.                 p = p->left;//深入左
  14.             }
  15.             TreeNode* oldP = st.top();//回溯
  16.             if (oldP->right && oldP->right != usedP) {
  17.                 p = oldP->right;
  18.             } else {
  19.                 ans.push_back(oldP->val);
  20.                 usedP = oldP;
  21.                 st.pop();
  22.             }
  23.         }
  24.         return ans;
  25.     }
  26. };

  • 至此, 咱多少被刚刚的后序非递归搞得可能有点小晕晕的, 没事,层序简单呀....  (层序就是纯模板, 打10个小意思)

  • 层序需要大家多练， 一定开始多练, 后面自然用的出神入化(做个面试二叉树不小case)

102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

  1. class Solution {
  2. public:
  3.     vector<vector<int>> levelOrder(TreeNode* root) {
  4.         vector<vector<int > > ans;
  5.         if (root == nullptr) return ans;//防空
  6.         vector<int> path;//记录每一层结果
  7.         queue<TreeNode*> q;
  8.         q.push(root);
  9.         TreeNode* pCur;
  10.         //要求? 一层一层的访问节点, 使用写法2吧.
  11.         while (!q.empty()) {
  12.             int n = q.size();//本层节点数目
  13.             for (int i = 0; i < n; ++i) {
  14.                 pCur = q.front();
  15.                 q.pop();
  16.                 path.push_back(pCur->val);
  17.                 if (pCur->left) q.push(pCur->left);
  18.                 if (pCur->right) q.push(pCur->right);
  19.             }
  20.             ans.push_back(path);//入上一层
  21.             path.clear();//清空继续存下一层
  22.         }
  23.         return ans;
  24.     }
  25. };

??? 你说层序就层序, 我的面子哪里放, 可以递归吗请问？可以深搜解决吗.让递归函数去帮我们干这个苦活重活

  • 思路:  想一想? 使用层序的好处是一层一层的做的处理, 我们只要按照它的要求存储序列就是它            首先只要能遍历完树然后按照层序序列存储不也还是层序序列吗....
  • 深搜不一样可以遍历整颗树吗? 只不过常规的深搜少了一个条件, 不清楚当前遍历的节点是那一层的,  所以给深搜 + deep层数参数便可解决这个问题了。
  1. class Solution {
  2.     void dfs(vector<vector<int > >& ans, TreeNode* root, int deep) {
  3.         if (root == nullptr) return ; //边界条件
  4.         if (ans.size() == deep) ans.push_back(vector<int >());//塞入空一位数组
  5.         ans[deep].push_back(root->val);
  6.         dfs(ans, root->left, deep + 1);
  7.         dfs(ans, root->right, deep + 1);
  8.         return ;//返回值
  9.     }
  10. public:
  11.     vector<vector<int>> levelOrder(TreeNode* root) {
  12.         vector<vector<int > > ans;
  13.         ans.clear();
  14.         dfs(ans, root, 0);//0起始层数
  15.         return ans;
  16.     }
  17. };
  • 然后授人以鱼不如授人以渔。。。  后序还有很多题目, 希望大家能按照上述两种方式都尝试练习, 几乎都是上述的模板...  题目链接附在如下:

107. 二叉树的层序遍历 II

103. 二叉树的锯齿形层序遍历

面试题32 - I. 从上到下打印二叉树

589. N 叉树的前序遍历

  • 然后如下的就是一些经典性的题目. 二叉树的最近公共祖先  +  建立二叉树   （又特别是建立二叉树，其实算是蛮不好处理的题目）

236. 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。  说俗点, 就是p  和  q  向上看找第一个合在一起的地方

  • 咋做?   典型的递归, 然后嘞. 层序根本不好使, 这个肯定是利用好回溯过程中进行判断返回节点.   
  • 首先的第一步找到  p  节点  和   q 节点不断地向上回溯
  • 然后一直向上回溯判断, 首先思考第一个问题, 走到了 公共节点地时候  p  和   q 肯定都是已经找到了地, 一定确定地是q  和  p  都找到了,   这个题目, 我们需要使用后序遍历..... 为啥?
  • 因为你得先确定你的左子树和右子树中分别 有 p  和  q  然后这个根部才是公共祖先...  所以你必须先获取左右子树地情况. 然后判断根部是不是所需地最近公共祖先,  至此思路明了了
  • return val : 找到地p q 或者是 root 最近公共祖先
  1. class Solution {
  2. public:
  3.     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
  4.         if (root == NULL) return NULL;
  5.         TreeNode* l = lowestCommonAncestor(root->left, p, q);
  6.         TreeNode* r = lowestCommonAncestor(root->right, p, q);
  7.         //获知了左右子树地信息了
  8.         //开始判断
  9.         if (root == p || root == q) return root;
  10.         if (l && r) return root;//左右子树中有p 和 q return 祖先 
  11.         if (l) return l;//返回找到地结果
  12.         if (r) return r;//返回找到地结果
  13.         return NULL;
  14.     }
  15. };

105. 从前序与中序遍历序列构造二叉树

题目意思就超级简单了, 就是给你两个序列 一个 前序遍历结果序列  另外一个是中序遍历序列, 然后让你构造出来这个二叉树....

  • 前序: 根部  左子树  右子树  :  所以前序过来是每一个根部
  • 中序  左子树  根部  右子树  :  可以根据前序地根部分开左右子树区间
  • 请问咋做, 上述说的超级清楚了  根据前序地根部不停地分割中序地左右区间,  左右区间分别就是左子树和右子树, 然后递归式建立二叉树就OK了
  1. class Solution {
  2.     unordered_map<int, int> ind;//采取一个技巧, 映射下标位置
  3.     //[l, mid) mid, (mid, r)
  4.     TreeNode* BuildTree(vector<int>& preorder, vector<int>& inorder, int& rooti, int l, int r) {
  5.         if (l >= r) {
  6.             rooti -= 1;//回溯
  7.             return nullptr;//l 和 r 之间没有元素
  8.         }
  9.         TreeNode* root = new TreeNode(preorder[rooti]);
  10.         int mid = ind[preorder[rooti]];
  11.         //[l, r)
  12.         root->left = BuildTree(preorder, inorder, ++rooti, l, mid);
  13.         root->right = BuildTree(preorder, inorder, ++rooti, mid + 1, r);
  14.         return root;
  15.     }
  16. public:
  17.     TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
  18.         for (int i = 0; i < inorder.size(); ++i) {
  19.             ind[inorder[i]] = i; 
  20.         }
  21.         int i = 0;
  22.         //至此获取到中序地值index地映射键值对map
  23.         //[0, inorder.size())  [l, r)
  24.         return BuildTree(preorder, inorder, i, 0, inorder.size());
  25.     }
  26. };

1008. 前序遍历构造二叉搜索树

思路:  因为是二叉搜索树 所以是满足  左子树  <  根部  <  右子树地

前序  根部   左子树  右子树  所以  根部  比所有的左子树节点都大, 于是可以根据这个特性找到左右子树地分界位置, 分割出来左右子树, 然后建立二叉树搜索树...

转换为中序遍历建立二叉搜索树地形式, 将前序序列转换为中序序列建立二叉搜索树即可....

因为你可以区分出根  左子树区间 右子树区间...

  1. class Solution {
  2.     TreeNode* BuildTree(vector<int>& preorder, int l, int r) {
  3.         if (l >= r) return nullptr;
  4.         TreeNode* root = new TreeNode(preorder[l]);
  5.         int mid = l + 1;
  6.         while (mid < r && root->val > preorder[mid]) ++mid;
  7.         root->left = BuildTree(preorder, l + 1, mid);
  8.         root->right = BuildTree(preorder, mid, r);
  9.         return root;
  10.     }
  11. public:
  12.     TreeNode* bstFromPreorder(vector<int>& preorder) {
  13.         return BuildTree(preorder, 0, preorder.size());
  14.     }
  15. };

现在差不多大体上大家应该对于建树也有点感觉了, 主要是使用递归处理  +   找到左右子树地分割线, 至此再附上链接几条大家可以去做做

106. 从中序与后序遍历序列构造二叉树

654. 最大二叉树

四, 总结(外加建议)

  • 本文主要介绍了二叉树地深度优先搜索和广度优先搜索, 以图解理论结合实践地形式拖出. 之后我会不停地跟新自己对于算法和数据结构地浅显见解， 希望大家多多支持谢谢
  • 还有一个小小地建议就是学数据结构和算法必须得学练并举...  （小杰的小小经验）不练习很多时候对于结构和算法的理解会下降和遗忘...  做过的题目需要反复做, 仅仅对于面试经典题目而言, 最好每一次得出不同的感受
  • 深度优先搜索本质:  先往深处搜索,走不动了回溯上去搜索另外没有搜索的方向
  • 广度优先搜索层序遍历(一层一层的)地毯式搜索. 之后可以介绍更多, 它比较适合找最短路径
  • 然后是建树关键   分割区间递归建树
  • 最终感谢大家对小杰的支持，感谢CSDN让身处各地的大家通过一片片博文相知相识, 谢谢群里各位志同道合朋友的大力支持, 小杰真心的感谢大家.. 希望大家一起加油，共同进步

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/393562
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号