526互联

算法学习Day14花式遍历二叉树

发布时间 2023-12-27 00:14:25作者: HQWQF

Day14花式遍历二叉树

By HQWQF 2023/12/26

笔记

二叉树的递归遍历

对于一个递归算法，我们应该考虑它的三个要素：

  1. 确定递归函数的参数和返回值
  2. 确定终止条件
  3. 确定单层递归的逻辑

二叉树节点的定义

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    //构造函数
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

三种遍历顺序

二叉树的递归遍历的核心：为了遍历一个二叉树，我们需要遍历其根节点和其左右子树，为了遍历左右子树，对于其左右子树的根节点也执行相同的逻辑即可。

对于三种二叉树的三种形式：前序遍历、中序遍历、后序遍历。

他们在递归遍历的中的差别是对于当前节点的三个操作：输出当前节点值（中）、遍历左子树（左）、遍历右子树（右）的执行顺序。

所谓的X序遍历就是输出当前节点值在顺序中的位置

  • 前序遍历：中左右
  • 中序遍历：左中右
  • 后序遍历：左右中

递归遍历的代码

//前序遍历
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) 
    {
        vector<int> res;
        Traversal(root,res);
        return res;
    }
    void Traversal(TreeNode* cur,vector<int> &res)
    {
        if(cur == nullptr)
        {
            return;
        }
        res.push_back(cur->val);
        Traversal(cur->left,res);
        Traversal(cur->right,res);        
    }
};

//中序遍历
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) 
    {
        vector<int> res;
        Traversal(root,res);
        return res;
    }
    void Traversal(TreeNode* cur,vector<int> &res)
    {
        if(cur == nullptr)
        {
            return;
        }
        Traversal(cur->left,res);
        res.push_back(cur->val);   
        Traversal(cur->right,res);
             
    }
};

//后序遍历
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) 
    {
        vector<int> res;
        Traversal(root,res);
        return res;
    }
    void Traversal(TreeNode* cur,vector<int> &res)
    {
        if(cur == nullptr)
        {
            return;
        }
        Traversal(cur->left,res);
        Traversal(cur->right,res);
        res.push_back(cur->val);        
    }
};

二叉树的迭代遍历

由于函数本身就使用了栈作为递归时存储数据的结构，我们也可以使用栈来迭代遍历一个二叉树。

前序遍历（迭代法）

对于前序遍历，我们可以建立一个栈，在将根节点push入栈后，我们先输出栈顶节点的节点值再pop出去，然后尝试将该节点的左右节点push入栈，对当前的栈顶节点继续重复这一过程，直到栈空。

注意我们处理的是栈顶元素，为了达成前序遍历"中左右"的顺序，因此push入节点的左右节点需要先压右节点再压左节点，这样优先被处理的是左节点。

前序遍历（迭代法）代码

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

后序遍历（迭代法）

后序遍历的顺序是"左右中"，这其实是"中右左"顺序的倒序。

我们只需要在前序遍历的代码的基础上修改，将其变为"中右左"的顺序，然后把结果倒序即可。

后序遍历（迭代法）代码

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

中序遍历（迭代法）

相比于前序遍历和后序遍历，中序遍历的迭代法则有所不同。

在前序遍历中，我们在单个循环中做了这两件事：

  1. 处理输出，将当前节点输出到结果中
  2. 深入遍历，以当前节点的左右孩子为起点继续遍历

我们可以发现，要访问的元素和要处理的元素顺序是一致的，都是中间节点。

然而在以"左中右"顺序的遍历，我们是将当前节点的左子树遍历完才处理当前节点的。

为了中序遍历，我们可以使用一个指针，这个指针在开始时将沿左分支深入到最底层，并把元素压入栈，到底后将弹出栈并输出同时尝试向右分支移动栈，移动失败则继续弹出和输出。

中序遍历（迭代法）代码

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

二叉树的统一迭代法

迭代法实现的先中后序，其实风格也不是那么统一，除了先序和后序，有关联，中序完全就是另一个风格了，一会用栈遍历，一会又用指针来遍历。

其实针对三种遍历方式，使用迭代法是可以写出统一风格的代码。

整体来说，这种方法是将节点压入栈中，在循环中读取栈顶元素，并将栈顶元素但是随后以一定顺序压入该元素及其非空左右孩子（这个顺序与X序相关），但是此时在重新压入该元素打一个标记，表明该元素是当前处理的元素，在后面循环读取到这个标记后就弹出该元素并输出到结果集。

这个标记我们可以在元素后多压入一个空节点来表示。

由于栈的处理顺序和压入顺序相反，在代码中表示压入对应节点的代码的顺序需要反转。

前序遍历统一迭代法

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();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return 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;
    }
};

后序遍历统一迭代法

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);

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

            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};