LeetCode之“树”：Binary Tree Preorder && Inorder && Postorder Traversal

Binary Tree Preorder Traversal

　　题目链接

　　题目要求：

　　Given a binary tree, return the preorder traversal of its nodes' values.

　　For example:
　　Given binary tree {1,#,2,3},

   1
    
     2
    /
   3

　　return [1,2,3].

　　Note: Recursive solution is trivial, could you do it iteratively?

递归解法

　　对这道题，用递归是最简单的了，具体程序如下：

/**
 * 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> preorderTraversal(TreeNode* root) {
        vector<int> rVec;
        preorderTraversal(root, rVec);
        return rVec;
    }
    
    void preorderTraversal(TreeNode *tree, vector<int>& rVec)
    {
        if(!tree)
            return;
            
        rVec.push_back(tree->val);
        preorderTraversal(tree->left, rVec);
        preorderTraversal(tree->right, rVec);
    }
};

非递归解法

　　非递归解法相对就要难很多了，理解起来比较抽象。在这里我们需要借助栈。当左子树遍历完后，需要回溯并遍历右子树。具体程序如下：

vector<int> preorderTraversal(TreeNode* root) {
    vector<int> rVec;
    stack<TreeNode *> st;
    TreeNode *tree = root;
    while(tree || !st.empty())
    {
        if(tree)
        {
            st.push(tree);
            rVec.push_back(tree->val);
            tree = tree->left;
        }
        else
        {
            tree = st.top();
            st.pop();
            tree = tree->right;
        }
    }

    return rVec;
}

更为简洁非递归解法

　　具体程序如下：

vector<int> preorderTraversal(TreeNode* root) {
    vector<int> rVec;
    if(!root)
        return rVec;
    
    stack<TreeNode *> st;
    st.push(root);
    while(!st.empty())
    {
        TreeNode *tree = st.top();
        rVec.push_back(tree->val);
        st.pop();
        if(tree->right)
            st.push(tree->right);
        if(tree->left)
            st.push(tree->left);
    }
    
    return rVec;
}

Binary Tree Inorder Traversal

　　题目链接

　　题目要求：

　　Given a binary tree, return the inorder traversal of its nodes' values.

　　For example:
　　Given binary tree {1,#,2,3},

   1
    
     2
    /
   3

　　return [1,3,2].

　　Note: Recursive solution is trivial, could you do it iteratively?

　　这道题的非递归解法跟上题的非递归解法基本一致，只是访问的节点时机不一样。详细分析可参考LeetCode上的一篇博文。具体程序如下：

vector<int> inorderTraversal(TreeNode* root) {
    vector<int> rVec;
    stack<TreeNode *> st;
    TreeNode *tree = root;
    while(tree || !st.empty())
    {
        if(tree)
        {
            st.push(tree);
            tree = tree->left;
        }
        else
        {
            tree = st.top();
            rVec.push_back(tree->val);
            st.pop();
            tree = tree->right;
        }
    }
    
    return rVec;
}

Binary Tree Postorder Traversal

　　题目链接

　　题目要求：

　　Given a binary tree, return the postorder traversal of its nodes' values.

　　For example:
　　Given binary tree {1,#,2,3},

   1
    
     2
    /
   3

　　return [3,2,1].

　　Note: Recursive solution is trivial, could you do it iteratively?

　　除了递归法，这道题利用两个栈来解决问题的话会比较方便，详细可参考LeetCode上的一篇文章。具体程序如下：

vector<int> postorderTraversal(TreeNode* root) {
    vector<int> rVec;
    if(!root)
        return rVec;
    
    stack<TreeNode *> st;
    stack<TreeNode *> output;
    st.push(root);
    while(!st.empty())
    {
        TreeNode *tree = st.top();
        output.push(tree);
        st.pop();
        if(tree->left)
            st.push(tree->left);
        if(tree->right)
            st.push(tree->right);
    }
    
    while(!output.empty())
    {
        rVec.push_back(output.top()->val);
        output.pop();
    }
    
    return rVec;
}