144. Binary Tree Preorder Traversal

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

Example:

Input: [1,null,2,3]
   1
    \
     2
    /
   3

Output: [1,2,3]

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

题意：给出一棵二叉树，求其先序遍历序列。

思路一：先层次建树，再先序递归遍历。

class Solution {
public:
    vector<int>vec;
    void preorder(TreeNode *t){
        if(t!=NULL){
             vec.push_back(t->val); 
            if(t->left!=NULL)
                preorder(t->left);
            if(t->right!=NULL)
                preorder(t->right);
        }
    }
    vector<int> preorderTraversal(TreeNode* root) {
        preorder(root);
        return vec;
    }
};

思路二：先序非递归遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root){
        TreeNode *p=root,*q;
        vector<int>st;
        stack<TreeNode*>nodes;
        //这里要注意root可能为空树 
        if(root==NULL) 
            return st;
        nodes.push(p);
        while(!nodes.empty()){
            q=nodes.top();
            nodes.pop();
            st.push_back(q->val);
            if(q->right!=NULL){     
               nodes.push(q->right);
            }
            if(q->left!=NULL){            
                nodes.push(q->left);
            }
        }
        return st;
    }
};

完整代码如下：

#include<stdio.h>
#include<iostream>
#include<stack>
#include<queue>
#include<vector>
#include<map>
using namespace std;
const int INF=-9999999;
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){
        TreeNode *p=root,*q;
        vector<int>st;
        stack<TreeNode*>nodes;
        if(root==NULL) return st;
        nodes.push(p);
        while(!nodes.empty()){
            q=nodes.top();
            nodes.pop();
            st.push_back(q->val);
            if(q->right!=NULL){     
               nodes.push(q->right);
            }
            if(q->left!=NULL){            
                nodes.push(q->left);
            }
        }
        return st;
    }
};
//层次遍历建树 
void Build(TreeNode *&Tree,vector<int>vec)
{
    int pos=0;
    Tree=new TreeNode(vec[pos]);
    queue<TreeNode*>que;
    que.push(Tree);
    while(!que.empty()){
        TreeNode *tmp=que.front();
        que.pop();
        if(pos<vec.size()&&vec[++pos]==INF){
            tmp->left=NULL;
        }else if(pos<vec.size()){
            tmp->left=new TreeNode(vec[pos]);
            que.push(tmp->left);
        }
        if(pos<vec.size()&&vec[++pos]==INF){
            tmp->right=NULL;
        }else if(pos<vec.size()){
            tmp->right=new TreeNode(vec[pos]);
            que.push(tmp->right);
        }
    }    
}
int main()
{   
    vector<int>vec;
    vec.push_back(1);
    vec.push_back(INF);
    vec.push_back(2);
    vec.push_back(3);
    TreeNode *Tree= new TreeNode(vec[0]);
    Build(Tree,vec); 
    Solution CC;
    vec=CC.preorderTraversal(Tree);
    for(int i=0;i<vec.size();i++)
       printf("%d  ",vec[i]);
}