二叉树的遍历有四种:
(1) 前序遍历(根左右)
(2)中序遍历(左根右)
(3) 后序遍历(左右根)
(4) 层序遍历(一层一层来)
记住了,好那就来题吧
1~~给你二叉树的根节点 root ,返回它节点值的 前序 遍历
示例 1:输入:root = [1,null,2,3]
输出:[1,2,3]
示例 2:输入:root = []
输出:[]
示例 3:输入:root = [1]
输出:[1]
法一:递归
解决二叉树的遍历问题应该想到的方法是递归,准备工作如下
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
主函数
vector<int> preorderTraversal(TreeNode* root) {
vector<int>res;
prevector(root,res);
return res;
}
代码实现,过程是插入根节点,先递归左边,再递归右边
void prevector(TreeNode* root,vector<int>& res)
{
if(root==nullptr)
{
return ;
}
//root要不为空
//把值插入数组
res.push_back(root->val);
//递归左边子节点
prevector(root->left,res);
//递归右边子节点
prevector(root->right,res);
}
法二:迭代,用栈的思想
准备工作如上,开始的代码还是设立结束条件
vector<int> preorderTraversal(TreeNode* root) {
vector<int>res;
if(root==nullptr)
{
return res;
}
用堆栈实现,要明确指针是要保存在堆栈里的,所以我们要建立一个保存指针的堆栈。做法是先把根节点指针入栈,放入数组,再访问左节点,一直访问到指针为空,即最左端,前面进入的都是根节点,此时,先记住,然后出栈,再访问右节点,循环做完就🆗
//构建一个保存TreeNode* 类型的栈
stack<TreeNode*>S;
//创建一个临时指针变量
TreeNode* node=root;
while(!S.empty() || node!=nullptr)
{
//左子树遍历
while(node!=nullptr)
{
res.emplace_back(node->val);
S.emplace(node);
node=node->left;
}
//最后到最左端子节点,此时S里顶端是该子节点的根
node=S.top();
S.pop();
node=node->right;
}
2~~给定一个二叉树的根节点 root
,返回它的 中序 遍历
示例 1:输入:root = [1,null,2,3] 输出:[1,3,2]
示例 2:输入:root = [] 输出:[]
示例 3:输入:root = [1] 输出:[1]
法一:还是递归
先递归左子树,再插入,再递归右子树
class Solution {
public:
vector<int> midFind(vector<int>& res,TreeNode* root)
{
if(root==nullptr)
{
return res;
}
//访问到最左端的左节点
midFind(res,root->left);
//插入数组
res.emplace_back(root->val);
midFind(res,root->right);
return res;
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int>res;
midFind(res,root);
return res;
}
};
法二:迭代,是栈的思想
和前面差不多,先找到最左节点,插入数组,再往右边找
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int>res;
stack<TreeNode*> sk;
while(!sk.empty()||root!=nullptr)
{
while(root!=nullptr)
{
sk.emplace(root);
root=root->left;
}
root=sk.top();
sk.pop();
res.emplace_back(root->val);
root=root->right;
}
return res;
}
};
这里再给一个栈的程序,不过时间复杂度升高,思想还是一样
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int>res;
stack<TreeNode*> sk;
while(!sk.empty()||root!=nullptr)
{
if(root!=nullptr)
{
sk.emplace(root);
root=root->left;
}
else
{
root=sk.top();
sk.pop();
res.emplace_back(root->val);
root=root->right;
}
}
return res;
}
};
返回
这里给出了两个模板,都适用于二叉树的三种遍历用迭代来解决
3~~给你一棵二叉树的根节点 root
,返回其节点值的 后序遍历
示例 1:输入:root = [1,null,2,3] 输出:[3,2,1]
示例 2:输入:root = [] 输出:[]
示例 3:输入:root = [1] 输出:[1]
法一:递归,先递归左节点,再递归右节点,再赋值
class Solution {
public:
vector<int>res;
vector<int> postorderTraversal(TreeNode* root) {
if(root==nullptr)
{
return res;
}
postorderTraversal(root->left);
postorderTraversal(root->right);
res.push_back(root->val);
return res;
}
};
法二:迭代
有了之前的基础,应该先找到最左节点,然后再找最右节点,如果右节点为空,则将该值插入数组,否则就遍历右子树,找到最右节点
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int>res;
stack<TreeNode*>sk;
TreeNode *ptr=nullptr;
while(!sk.empty() || root!=nullptr)
{
while(root!=nullptr)
{
sk.emplace(root);
root=root->left;
}
root=sk.top();
sk.pop();
//右子树为空,根节点入栈
if(root->right==nullptr || root->right==ptr)
{
res.emplace_back(root->val);
ptr=root;
root=nullptr;
}
else
{
sk.emplace(root);
root=root->right;
}
}
return res;
}
};
4~~给你二叉树的根节点 root
,返回其节点值的 层序遍历
示例 1:输入:root = [3,9,20,null,null,15,7] 输出:[[3],[9,20],[15,7]]
示例 2:输入:root = [1] 输出:[[1]]
示例 3:输入:root = [] 输出:[]
方法:队列
队列保存TreeNode*类型的指针,根节点入队,再从上到下遍历二叉树,先记住根节点,再根节点出队,插入数组,找左节点,找右节点,入队,遍历完了,再插入存放数组的数组里
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
//队列实现
queue<TreeNode*>que;
if(root!=nullptr)
{
que.push(root);
}
vector<vector<int>>result;
while(!que.empty())
{
//从上到下遍历
int size=que.size();
vector<int>temp;
for(int i=0;i<size;i++)
{
TreeNode* Node=que.front();
que.pop();
temp.emplace_back(Node->val);
if(Node->left) que.push(Node->left);
if(Node->right) que.push(Node->right);
}
result.push_back(temp);
}
return result;
}
};
总结:二叉树的遍历,前中后要记住,其实也很简单前中后就是根的位置,并且一定是先左后右遍历 主要还是掌握递归算法,顺带熟悉迭代和队列,加强数据结构的使用