二叉樹的三種遍歷-中序-前序-後序

二叉樹的三種遍歷：中序，前序，後序

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

中序遍歷

• left->root->right

中序遞歸版

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

中序非遞歸

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        vector<int> ret;
        std::stack<TreeNode*> sk;
        TreeNode* read = root;
        while(read != NULL || !sk.empty()) {
            if (read != NULL) {
                sk.push(read);
                read = read->left;
            }
            else {
                read = sk.top();
                sk.pop();
                ret.push_back(read->val);
                read = read->right;
            }
        }
        return ret;
    }
};

前序遍歷

• root->left->right

前序-遞歸版

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

前序-非遞歸版

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        vector<int> ret;
        std::stack<TreeNode*> sk;
        TreeNode* read = root;
        sk.push(read);
        while (!sk.empty()) {
            read = sk.top();
            ret.push_back(read->val);
            sk.pop();
            if (read != NULL && read->right != NULL) {
                sk.push(read->right);
            }
            if (read != NULL && read->left != NULL) {
                sk.push(read->left);
            }
        }
        return ret;
    }
};

注：前序非遞歸的終止條件不能和中序一樣。

while (!sk.empty())

因爲所有節點被彈出後，read 值不爲NULL，這樣會導致對空的 stack 執行pop操作。C++是不允許這樣的。

後序遍歷

• left->right->root

後序-遞歸

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

後序-非遞歸

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if (root == NULL) return {};
        vector<int> ret;
        TreeNode* read = root;
        TreeNode* top;
        TreeNode* tmp = NULL; // 記錄上次訪問過的節點
        std::stack<TreeNode*> sk;
        while(read != NULL || !sk.empty()) {
            if (read != NULL) {
                sk.push(read);
                read = read->left;
            }
            else {
                top = sk.top();
                if (top->right == NULL || top->right == tmp) {
                    tmp = sk.top();
                    sk.pop();
                    ret.push_back(tmp->val);
                }
                else {
                    read = top->right;
                }
            }
        }
        return ret;
    }
};