二叉树的几种遍历方法

二叉树的遍历有四种：

（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;
    }
};

 总结：二叉树的遍历，前中后要记住，其实也很简单前中后就是根的位置，并且一定是先左后右遍历 主要还是掌握递归算法，顺带熟悉迭代和队列，加强数据结构的使用