LeetCode--二叉树的先序遍历（c++，最详细的解法！！！）

给定一个二叉树，返回它的 前序 遍历。

示例:

输入: [1,null,2,3]
1

2
/
3

输出: [1,2,3]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

解题思路
1、如果采用递归思想的话，只需满足根、左、右输出即可。代码简单清晰，看看就会明白。
2、如果采用迭代，则有两种思路：
a、一种是利用常规的迭代思想，利用辅助空间栈，按着先序遍历的过程依次将节点输出即可。先看根节点的左子树是否为空，如果不为空，则从根节点开始依次将根节点和其左子树的根节点压入栈中，直到最左边的叶子结点。同时将这些根节点的值输出。然后在依次取出栈中元素，将其右节点作为新的根节点，依次遍历，直到栈为空。

b、采用线索二叉树的思想，利用两个辅助指针实现迭代，空间复杂度为O（1）：
1、如果当前节点的左孩子为空，则输出当前节点并将其右孩子作为当前节点。
2、如果当前节点的左孩子不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点。
a) 如果前驱节点的右孩子为空，将它的右孩子设置为当前节点。输出当前节点（在这里输出，这是与中序遍历唯一一点不同）。当前节点更新为当前节点的左孩子。
b) 如果前驱节点的右孩子为当前节点，将它的右孩子重新设为空。当前节点更新为当前节点的右孩子。
3、重复以上1、2直到当前节点为空。

代码如下：

递归1

/*class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
         vector<int> res;
         preorder(root, res);
         return res;
    }
    void preorder(TreeNode *root, vector<int> &res) {
         if (!root) 
             return;
         res.push_back(root->val);
         if (root->left) 
             preorder(root->left, res);
         if (root->right) 
             preorder(root->right, res);
     }
};*/

递归2

/*class Solution {
public:
     vector<int> preorderTraversal(TreeNode *root) {
         vector<int> res;
         stack<int> res_;
         preorder(root, res_);
         while(!res_.empty()){
             res.push_back(res_.top());
             res_.pop();
         }
         return res;
     }
     void preorder(TreeNode *root, stack<int> &res) {
         if (!root) 
             return;
         if (root->right) 
             preorder(root->right, res);
         if (root->left) 
             preorder(root->left, res);
         res.push(root->val);
     }
 };*/

递归3

/*class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(root){
            res.push_back(root->val);
            preorderTraversal(root->left);
            preorderTraversal(root->right);
        }
        return res;
    }
private:
        vector<int> res;
};*/

迭代1

/*class Solution{
public:
    vector<int> preorderTraversal(TreeNode* root){
        vector<int> res;
        stack<TreeNode*> s;
        TreeNode *p = root;
        while(p){
            s.push(p);
            res.push_back(p->val);
            p = p->left;
        }
        while(!s.empty()){
            p = s.top();
            p = p->right;
            s.pop();
            while(p != NULL){
                s.push(p);
                res.push_back(p->val);
                p = p->left;
            }
        }
    return res;
    }
};*/

迭代2

// 不用递归和辅助空间栈，空间复杂度为O（1）.
class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> res;
        if (!root) 
            return res;
        TreeNode *cur, *pre;
        cur = root;
        while (cur) {
            if (!cur->left) {
                res.push_back(cur->val);
                cur = cur->right;
            } 
            else {
                pre = cur->left;
                while (pre->right && pre->right != cur) //找出cur的前驱节点
                    pre = pre->right;
                if (!pre->right) {
                    pre->right = cur;
                    res.push_back(cur->val);
                    cur = cur->left;
                } 
                else {
                    pre->right = NULL;
                    cur = cur->right;
                }
            }
        }
        return res;
    }
};

迭代3

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> s;
        vector<int> res;
        if(root == NULL){
            return res;
        }
        TreeNode *cur = root;
        while(cur || !s.empty()){
            if(cur != NULL){
                res.push_back(cur->val);
                s.push(cur->right);
                cur = cur->left;
            } 
            else {
                cur = s.top();
                s.pop();
            }
        }
        return res;
    }
};

关于利用线索二叉树实现遍历的，可参考：https://www.cnblogs.com/AnnieKim/archive/2013/06/15/MorrisTraversal.html