144. Binary Tree Preorder Traversal

Problem Statement

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?

solution one:

This question is for preorder, the order of preorder is root, left, and right. 

Traverse:

This version is pretty simple to understand, we defined a vector, which store the preorder of tree nodes.

Stop/Return condition: if current node is NULL, we return.

Otherwise: we put current node into the vector, and recursively do the same operation for its left tree and right tree.

And then, return.

/**
 * 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:
    void preorderTraverse(TreeNode *node, vector<int>& preorder){
        if(node == NULL){
            return;
        }
        
        preorder.push_back(node->val);
        preorderTraverse(node->left, preorder);
        preorderTraverse(node->right, preorder);
        return;
    }
    
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> preorder;
        preorderTraverse(root, preorder);
        return preorder;       
    }
};

Divide and conquer:

Normally, divide and conquer will split the problem into subsets, and deal the subsets individually.

In this question, for each node, we test if it is NULL first, return if it is.

Otherwise (node is not NULL), we get its left and right subsets.

And process left and right according to what we want.

/**
 * 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:
    // this version is divide && conquer
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> preorder;
        if(root == NULL){
            return preorder;
        }
        // divide
        vector<int> left = preorderTraversal(root->left);
        vector<int> right = preorderTraversal(root->right);
        // conquer
        preorder.push_back(root->val);
        preorder.insert(preorder.end(), left.begin(), left.end());
        preorder.insert(preorder.end(), right.begin(), right.end());
        return preorder;
    }
};

Non-traverse version:

For tree traverse, there are three different ordrs: 

preorder: root, left, right

Inorder: left, root, right

postorder: left, right, root

For non-traverse version, we use stack to store the tree node we already traversed.

Pop the top element from stack if current node is NULL, and push the right son of the node into stack again.

Until, the stack is empty.

/**
 * 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) {
        // this is the non traverse version
        vector<int> preorder;
        if(root == NULL){
            return preorder;
        }
        stack<TreeNode*> node_stack;
        TreeNode* cur_node = root;
        node_stack.push(cur_node);
        while(!node_stack.empty()){
            if(cur_node){
                node_stack.push(cur_node);
                preorder.push_back(cur_node->val);
                cur_node = cur_node->left;    
            } else {
                cur_node = node_stack.top();
                node_stack.pop();
                cur_node = cur_node->right;
            }
        }
        return preorder;
    }
};