144. 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?

题意：

给定一个二叉树，返回其节点值的前序遍历序列。

Note：

递归实现是微不足道的，你能否用迭代实现。

思路一：

最简单的递归实现，只需要按照前序遍历流程递归调用递归函数即可。

代码：C++版：3ms

/**
 * 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 {
private:
    vector<int> ans;
public:
    vector<int> preorderTraversal(TreeNode* root) {
        repreTra(root);
        return ans;
    }
    void repreTra(TreeNode *root) {
        if (root != NULL) {
            ans.push_back(root->val); //前序遍历root->left->right
            repreTra(root->left);
            repreTra(root->right);
        }
    }
};

思路二：

利用栈辅助实现二叉树的先序遍历。先将根节点入栈，在循环体中，取出栈顶节点，将该节点值保存进返回结果集中，之后依次将右节点，左节点入栈，利用栈的先入后出的特点实现先序遍历的顺序。之后执行循环体即可。

代码：C++版：0ms

/**
 * 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 {
private:
    vector<int> ans;
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res; //返回结果集
        const TreeNode *p; //取出每次出栈的节点
        stack<const TreeNode*> stk;  //辅助栈
        
        p = root;
        if (p != nullptr) stk.push(p); //将根节点入栈
        
        while (!stk.empty()) {
            p = stk.top();
            stk.pop();
            res.push_back(p->val); //将出栈节点值存储到返回集中
            
            if (p->right != nullptr) stk.push(p->right); //右节点先入栈，因为栈先进后出的特点
            if (p->left != nullptr) stk.push(p->left);  //左节点入栈
        }
        return res;
    }
};

思路三：

使用Morris遍历实现。其时间复杂度仍然是O(n)，但是空间复杂度却只有O(1)。

其优点概括来说有两个：1. O(1)空间复杂度，即只能使用常数空间；2. 二叉树的形状不会被破坏（中间过程允许改变其形状）。

要使用O(1)空间进行遍历，最大的难点在于，遍历到子节点的时候怎样重新返回到父节点（假设节点中没有指向父节点的p指针），由于不能用栈作为辅助空间。为了解决这个问题，Morris方法用到了线索二叉树（threaded binary tree）的概念。在Morris方法中不需要为每个节点额外分配指针指向其前驱（predecessor）和后继节点（successor），只需要利用叶子节点中的左右空指针指向某种顺序遍历下的前驱节点或后继节点就可以了。

它使用二叉树中的叶节点的right指针来保存后面将要访问的节点的信息，当这个right指针使用完成之后，再将它置为NULL，但是在访问过程中有些节点会访问两次，所以与递归的空间换时间的思路不同，Morris则是使用时间换空间的思想。

参考图示流程更容易看懂：



代码：C++版：0ms

/**
 * 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 {
private:
    vector<int> ans;
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        TreeNode *cur;
        
        cur = root;
        while (cur != nullptr) {
            if (cur->left == nullptr) {
                res.push_back(cur->val);
                cur = cur->right;
            } else {
                //查找前驱
                TreeNode *node = cur->left;
                while (node->right != nullptr && node->right != cur) //找到右子树的叶子节点
                    node = node->right;
                
                if (node->right == nullptr) { //还没线索化，则建立线索
                    res.push_back(cur->val); //仅这一行的位置与中序遍历不同
                    node->right = cur; 
                    cur = cur->left;
                } else {  //已经线索化，则删除线索
                    node->right = nullptr;
                    cur = cur->right;
                }
            }
        }
        return res;
    }
}

详细算法流程参考博客：Morris二叉树遍历算法