代码随想录 10.05 || 二叉树 LeetCode 144.二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历

        二叉树理论基础，手写二叉树的数据结构，掌握前中后序二叉树的递归遍历和迭代遍历，了解二叉树前中后序的统一迭代遍历法。

二叉树的数据结构

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

144. 二叉树的前序遍历

class Solution { // 递归法
public:

    void traversal (TreeNode* cur, vector<int>& vec) {
        if (cur == nullptr) return ;
        vec.push_back(cur->val);
        traversal(cur->left, vec);
        traversal(cur->right, vec);
    }


    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

class Solution { // 迭代法
public:

    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        if (root == nullptr) return result;

        stack<TreeNode*> st;
        st.push(root);

        while (!st.empty()) {
            TreeNode* node = st.top();
            result.push_back(node->val);
            st.pop();
            if (node->right) st.push(node->right);
            if (node->left) st.push(node->left);
        }
        return result;
    }
};

        前序遍历的递归法很简单，根据“根左右”的顺序，先将每一层的根节点添加进 result 中，然后探索左孩子节点，直至左孩子节点为空，然后探索右孩子节点，直至右孩子节点为空。

        前序遍历的迭代法稍复杂，在系统内部利用栈实现递归法，所以在迭代法中，我们也利用栈。首先，将根节点压栈，维护一个当栈不为空的 while，将栈顶弹出并添加进 result 中；根据“根左右”的顺序，将右孩子节点入栈，再将左孩子节点入栈，因为栈是“后进先出”，所以左孩子节点后进栈可以先出；在下次循环中，栈顶的左孩子节点出栈进 result，然后将其右孩子节点和左孩子节点分别入栈；如此往复，直至最后一层的左孩子节点。在每次的循环中，栈顶访问的元素，就是我们要添加进 result 中的元素。

145. 二叉树的后序遍历

        二叉树的后序遍历的递归法和迭代法和前序遍历类似。

class Solution { // 递归法
public:

    void traversal (TreeNode* cur, vector<int>& vec) {
        if (cur == nullptr) return ;
        traversal(cur->left, vec);
        traversal(cur->right, vec);
        vec.push_back(cur->val);
    }


    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

class Solution { // 迭代法
public:

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        if (root == nullptr) return result;

        stack<TreeNode*> st;
        st.push(root);

        while (!st.empty()) {
            TreeNode* node = st.top();
            result.push_back(node->val);
            st.pop();
            if (node->left) st.push(node->left);
            if (node->right) st.push(node->right);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

95. 二叉树的中序遍历

        二叉树的中序遍历的递归法和前序和后续类似，但是递归法则完全不同，这是因为我们只能够直接访问根节点，而根据中序遍历“左根右”的顺序，需要操作的结点是根节点的左孩子节点，所以访问节点和操作节点不同，这时我们需要借助一个指针：

class Solution { // 递归法
public:

    void traversal (TreeNode* cur, vector<int>& vec) {
        if (cur == nullptr) return ;
        traversal(cur->left, vec);
        vec.push_back(cur->val);
        traversal(cur->right, vec);
    }


    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

class Solution { // 迭代法
public:

    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;

        while (cur || !st.empty()) {
            if (cur) {
                st.push(cur);
                cur = cur->left;
            } else {
                cur = st.top();
                st.pop();
                result.push_back(cur->val);
                cur = cur->right;
            }
        }
        return result;
    }
};

        在中序遍历迭代法的实践中，我们利用一个 cur 指针，将需要先处理的所有左孩子节点入栈，直至 cur 指空，说明没有左孩子节点。此时，栈中的元素都是该二叉树最左边的元素节点，然后我们依次为这些最左的元素节点，处理其根节点和右节点。

二叉树的统一迭代遍历

        从上面的代码可以看出，二叉树的递归遍历法逻辑相同，仅改变几行代码的顺序就能得到前序、中序和后序遍历。但是，迭代法的中序和前序、后续则具有较大差别。这里拓展一个二叉树的统一迭代遍历法，来自卡哥的代码随想录：

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