【算法训练营day14】理论基础 LeetCode144. 二叉树的前序遍历 LeetCode145. 二叉树的后序遍历 LeetCode94. 二叉树的中序遍历

理论基础

满二叉树：如果一棵二叉树只有度为0的节点和度为2的节点，且度为0的节点在同一层上，则这颗二叉树为满二叉树。

完全二叉树：在完全二叉树中，除了最底层节点可能没有填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。

二叉搜索树：二叉搜索树是一个有数值的有序树。

• 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
• 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
• 它的左、右子树也分别为二叉排序树

平衡二叉搜索树（AVL树）：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉搜索树。

---

LeetCode144. 二叉树的前序遍历

题目链接：144. 二叉树的前序遍历

初次尝试

抱着赶时间和学习的态度，直接看题解。

看完代码随想录后的想法

递归法实现。

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

迭代法实现（注意空节点不入栈）。

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> ans;
        if (root == NULL) return ans;
        st.push(root);

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

        return ans;
    }
};

统一迭代法（用NULL作为标记）。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> ans;
        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();
                ans.push_back(node -> val);
                st.pop();
            }
        }

        return ans;
    }
};

---

LeetCode145. 二叉树的后序遍历

题目链接：145. 二叉树的后序遍历

初次尝试

抱着赶时间和学习的态度，直接看题解。

看完代码随想录后的想法

递归法实现。

class Solution {
public:
    void Traversal(TreeNode* root, vector<int>& ans) {
        if (root == NULL) return;
        Traversal(root -> left, ans);
        Traversal(root -> right, ans);
        ans.push_back(root -> val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        Traversal(root, ans);
        return ans;
    }
};

迭代法实现（中左右 -> 中右左 -> 左右中）。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> ans;
        if (root == NULL) return ans;
        st.push(root);

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

        return ans;
    }
};

统一迭代法（用NULL作为标记）。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> ans;
        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();
                ans.push_back(node -> val);
                st.pop();
            }
        }

        return ans;
    }
};

---

LeetCode94. 二叉树的中序遍历

题目链接：94. 二叉树的中序遍历

初次尝试

抱着赶时间和学习的态度，直接看题解。

看完代码随想录后的想法

递归法实现。

class Solution {
public:
    void Traversal(TreeNode* root, vector<int>& ans) {
        if (root == NULL) return;
        Traversal(root -> left, ans);
        ans.push_back(root -> val);
        Traversal(root -> right, ans);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        Traversal(root, ans);
        return ans;
    }
};

迭代法实现（借助指针）。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> ans;
        TreeNode* cur = root;

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

        return ans;
    }
};

统一迭代法（用NULL作为标记）。

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> ans;
        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();
                ans.push_back(node -> val);
                st.pop();
            }
        }

        return ans;
    }
};