lc[二叉树]---二叉树的遍历(递归/迭代/统一迭代/层序遍历)

一、递归遍历

递归的三要素

144. 二叉树的前序遍历 - 力扣（LeetCode）https://leetcode.cn/problems/binary-tree-preorder-traversal/submissions/        本题，只给了一个接口,自己在写递归函数的时候,要自己想，如何设置参数（方便递归），故会写出子函数用于递归。

class Solution 
{
public:
    void preOrder(TreeNode* root,vector<int>& res)
    {
        if(root==nullptr)return ;
        res.push_back(root->val);
        preOrder(root->left,res);
        preOrder(root->right,res);
    }
    vector<int> preorderTraversal(TreeNode* root) 
    {
        vector<int>res;
        preOrder(root,res);
        return res;
    }
};

中序与后序遍历类似

二、迭代遍历 

1.前序和后序遍历

        前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。

        为什么要先加入 右孩子，再加入左孩子呢？ 因为这样出栈的时候才是中左右的顺序。

        动画如下：

 （注意代码中空节点不入栈）

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == NULL) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();                       // 中
            st.pop();
            result.push_back(node->val);
            if (node->right) st.push(node->right);           // 右（空节点不入栈）
            if (node->left) st.push(node->left);             // 左（空节点不入栈）
        }
        return result;
    }
};

        后序遍历：

        再来看后序遍历，先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了，如下图：

 （reverse参数利用result的迭代器就行。）

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == NULL) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            result.push_back(node->val);
            if (node->left) st.push(node->left); // 相对于前序遍历，这更改一下入栈顺序 （空节点不入栈）
            if (node->right) st.push(node->right); // 空节点不入栈
        }
        reverse(result.begin(), result.end()); // 将结果反转之后就是左右中的顺序了
        return result;
    }
};

        前序和中序是完全两种代码风格，并不像递归写法那样代码稍做调整，就可以实现前后中序。这是因为前序遍历中访问节点（遍历节点）和处理节点（将元素放进result数组中）可以同步处理，但是中序就无法做到同步！(遍历到一个就放入res中一个元素)

2.中序遍历

刚刚在迭代的过程中，其实我们有两个操作：

1. 处理：将元素放进result数组中
2. 访问：遍历节点

分析一下为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢，因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点。

那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。

         那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) { // 指针来访问节点，访问到最底层
                st.push(cur); // 将访问的节点放进栈
                cur = cur->left;                // 左
            } else {
                cur = st.top(); // 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
                st.pop();
                result.push_back(cur->val);     // 中
                cur = cur->right;               // 右
            }
        }
        return result;
    }
};

三、统一迭代法

指导思想：

        那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

        如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。

1.中序遍历

        动画中，result数组就是最终结果集。

        可以看出我们将访问的节点直接加入到栈中，但如果是处理的节点则后面放入一个空节点， 这样只有空节点弹出的时候，才将下一个节点放进结果集。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node->right) st.push(node->right);  // 添加右节点（空节点不入栈）

                st.push(node);                          // 添加中节点
                st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。

                if (node->left) st.push(node->left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.top();    // 重新取出栈中元素
                st.pop();
                result.push_back(node->val); // 加入到结果集
            }
        }
        return result;
    }
};

2.前序遍历

         (相比中序遍历,仅仅改变了两行代码顺序)

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左
                st.push(node);                          // 中
                st.push(NULL);
            } else {
                st.pop();                //先把NULL结点拿出来
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

3. 后序遍历

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                st.push(node);                          // 中
                st.push(NULL);                    //(中先放进去st,实际上是最后处理的)

                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左

            } else {
                st.pop();                         //把NULL结点拿出来
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

四、层序遍历 

（1）leetcode 102.二叉树的层序遍历

        需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。使用队列实现二叉树广度优先遍历，动画如下：

        本题关键;如何定层?

6加入后，队列的size变成1，然后将6弹出。然后加入左右孩子4和7得到size变成2，根据这个size保存为cnt，进行下一次孩子的读取并完成本层遍历，一次下去（4和7的左右孩子都加入，发现有4个孩子，size变成4）

class Solution 
{
public:
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        vector<vector<int>> res;
        if(root==nullptr)return res;
        deque<TreeNode*> que;
        TreeNode*p;

        que.push_back(root);
        while(!que.empty())
        {
            vector<int> tmp;
        // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            int cnt=que.size();//保存下来
            for(int i=0;i<cnt;i++)//这里的for就是为了定层
            {
                p=que.front();
                tmp.push_back(p->val);
                que.pop_front();

                if(p->left)que.push_back(p->left);
                if(p->right)que.push_back(p->right);
            }
            res.push_back(tmp);
        }
        return res;
    }
};

（2）leetcode 107.二叉树的层序遍历②

 在上一题代码的基础上，直接将res反转一下即可。

reverse(res.begin(),res.end());

（3） leetcode 199.二叉树的右视图

         一开始犯傻了，多开辟了空间，来存每层的所有节点，实际上，遍历到每层的最后一个节点直接加入res即可。

class Solution 
{
public:
    vector<int> rightSideView(TreeNode* root) 
    {
        vector<int> res;
        if(root==nullptr)return res;    //root为空节点的时候,直接返回
        deque<TreeNode*> que;
        TreeNode* tmp;
        que.push_back(root);

        while(!que.empty())
        {
            int cnt=que.size();             //定层
            for(int i=0;i<cnt;i++)
            {
                tmp=que.front();que.pop_front();
                if(i==cnt-1)
                    res.push_back(tmp->val);
                if(tmp->left)que.push_back(tmp->left);
                if(tmp->right)que.push_back(tmp->right);
            }
        }
        return res;
    }
};

（4）637. 二叉树的层平均值

层序遍历每层就行，记录求平均加入res。

（5）429.N叉树的层序遍历

 把判断有无左右孩子，变成去遍历所有孩子即可。

（6）515.在每个树行中找最大值

INT_MIN  利用此宏得到int 的最小值

（7）116.填充每个节点的下一个右侧指针

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。

注意：在写if判断的时候，注意一个边界,就是i==cnt-1之后若仍为else if则下面的pre->next=cur是不会执行的，所以分成两个if

class Solution {
public:
    Node* connect(Node* root) 
    {
        deque<Node*> que;
        Node*cur=NULL;Node* pre=NULL;
        if(root!=NULL)que.push_back(root);
        while(!que.empty())
        {
        // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            int cnt=que.size();//保存下来
            pre=NULL;//重置
            for(int i=0;i<cnt;i++)//这里的for就是为了定层
            {
                cur=que.front();
                que.pop_front();

                if(i==cnt-1)
                   cur->next=NULL;
                if(pre!=NULL)
                    pre->next=cur;

                if(cur->left)que.push_back(cur->left);
                if(cur->right)que.push_back(cur->right);
                pre=cur;        //保存走过的路径
            }
        }
        return root;   
    }
};

 （8）117.填充每个节点填充每个节点的下一个右侧指针②

层序遍历上述的代码一样能过。

（9）104.二叉树的最大深度

层序遍历，每遍历完一层,depth++;即可。

（10）111.二叉树的最小深度

加上一个flg,当遍历到某一个结点同时无左右孩子时，就break；返回当前的depth即为最小深度