<LeetCode OJ>Binary Tree Preorder Traversal【144】

144. Binary Tree Preorder Traversal

My Submissions

Question

Total Accepted: 100308 Total
Submissions: 262975 Difficulty: Medium

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?

Subscribe to see which companies asked this question

Hide Tags
Tree Stack

Hide Similar Problems
(M) Binary Tree Inorder Traversal (M)
Verify Preorder Sequence in Binary Search Tree

第一种简单做法：前序递归遍历

/**
 * 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) {
        if(root){
            result.push_back(root->val);
            preorderTraversal(root->left);
            preorderTraversal(root->right);
        }
        return result;
    }
private:
    vector<int> result;
};

或者这样：前序式深度优先搜索（其实和上面是一样的）：

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

第二种方法：迭代法之广度优先搜索（下面这个算法有误，只通过了50个测试案例，有17个未通过）

错得好：广度搜索的遍历方式和前序遍历方式不一样，就算要用搜索算法，也应该是深度优先搜索。

前序式遍历方式才是深度遍历的一种方式

/**
 * 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) {
        TreeNode* curNode=root;

        queue<TreeNode*> que;
        if(root!=NULL)
            que.push(curNode);//进队（队列的尾端）
        else
            return result;
        while (!que.empty())  
        {  
            curNode=que.front();//出队首元素  
            que.pop();//删除队首元素
            result.push_back(curNode->val);
            if(curNode->left!=NULL)
                que.push(curNode->left);
            if(curNode->right!=NULL)
                que.push(curNode->right);    
        }
        return result;
    }
private:
    vector<int> result;
};

纠正上面这个算法：

/**
 * 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) {
        if (root==NULL) 
            return result;  
        stack<TreeNode*> stk;  
        TreeNode* pCurNode=root;  
        stk.push(pCurNode);  
        while (!stk.empty())
        {  
            pCurNode = stk.top();  
            stk.pop();  
            result.push_back(pCurNode->val);  
  
            if (pCurNode->right)  
                stk.push(pCurNode->right); //先压进来的后访问 
            if (pCurNode->left)  
                stk.push(pCurNode->left);  
        }  
        return result;  
    }
private:
  vector<int> result;  
};