[leetcode] 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].
题意：
对一棵二叉树进行先序遍历，即先访问根节点，再访问左子树和右子树。
思路：
递归的思路比较简单，就是访问根节点，然后递归访问左右子树。本文研究采用非递归的方法。我们会使用栈去保存节点。

1. 栈的特点是后进先出，当访问到某个节点的时候，接下来需要先遍历了左子树，再遍历右子树。所以可以使用栈将右孩子先压入，再将左孩子压入。这样出栈的时候就是先访问左子树再去访问右子树。思路比较清晰，代码如下：

/**
 1. Definition for binary tree
 2. struct TreeNode {
 3.     int val;
 4.     TreeNode *left;
 5.     TreeNode *right;
 6.     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 7. };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode *root) {
        vector<int> result;
        if (root == NULL)return result;
        vector<TreeNode *>list_nodes;
        list_nodes.push_back(root);
        while (!list_nodes.empty()){
            TreeNode *temp = list_nodes.back();
            list_nodes.pop_back();
            result.push_back(temp->val);
            if (temp->right != NULL)list_nodes.push_back(temp->right);
            if (temp->left != NULL)list_nodes.push_back(temp->left);
        }
        return 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) {
        vector<int> result;
        stack<TreeNode*> s;
        TreeNode* p = root;
        while(!s.empty() || p != NULL) {
            while(p != NULL) {
                result.push_back(p->val);
                s.push(p);
                p = p->left;
            }
            if(!s.empty()) {
                p = s.top();
                s.pop();
                p = p->right;
            }
        }
        return result;
    }
};

3.2. 采用另一种非递归的方法，Morris 算法，通过线索二叉树的概念，保存中序遍历下某个元素的前驱。因为前序遍历的访问顺序是根节点，左子树，右子树。所以在使用非递归的方式遍历的时候，当把左子树访问完之后需要访问右子树，而由于已经访问到左子树的最右边节点，所以这个时候要有办法指向根的右孩子节点，或者指向根节点，然后就可以访问根节点的右节点了。所以就是需要将节点在中序遍历下的前驱节点找到，让前驱节点的下一个指向当前节点。由于当前节点的前驱是其左子树的最后一个访问到的节点，其实就是取左孩子，然后一直往右孩子遍历，直到没有右孩子为止。这就找到了当前节点的前驱，因为这个前驱的右孩子等于NULL，所以让其右孩子指向当前节点，就可以在访问到左子树的最后一个节点后，可以跳到当前节点了。
所以Morris算法就是利用了线索二叉树的一些性质。
具体做法是当扫描到节点curr时，
a.如果curr没有左孩子，那么curr就没有在 中序遍历下的前驱，所以直接将curr的val存入遍历的数组中。接着访问curr的右孩子。

b.如果curr有左孩子，那么显然curr存在中序遍历下的前驱，我们查找其前驱，前驱节点就是取curr->left的右孩子，另prev = curr->left, 找prev的右孩子，一直找右孩子，往左子树的右下角找，直接找到最右下角即prev->right == NULL，这个prev就是curr的前驱，所以让prev->right = curr，这样子，后面访问到prev节点的时候，就可以通过网right上走，回到curr节点。当然，由于是先序遍历，所以我们要在此刻就把curr的值存入到数组中。并且继续往curr的左孩子挺进，继续找出左孩子的前驱，访问curr的左孩子，去往下逐层寻找左孩子的前驱。

c.对于b的情况，比如我们之前设置过了某个叫做prev的节点的右孩子等于curr，由于a,b在不断往下扫描，当再次扫描到b中之前设置过的那个prev节点的时候，由于此时prev的右孩子是curr，那么会在访问完prev之后访问prev->right即curr，那么curr的前驱之前已经设置过了即prev，所以这个时候我们需要将树的结构还原，将prev的right设置为NULL。

其实上面步骤的2，3两步代码是一样的，只是查看下curr的前驱是否已经设置好了，如果没有哪个节点的right==curr说明还没设置，否则代表没设置。

以上。
代码如下：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        TreeNode* curr = root;
        TreeNode* prev = NULL;
        while(curr != NULL) {
            if(curr->left == NULL) {
                result.push_back(curr->val);
                curr = curr->right;
            }
            else {
                prev = curr->left;
                while(prev->right != NULL && prev->right != curr)
                    prev = prev->right;
                if(prev->right == NULL) {
                    result.push_back(curr->val);
                    prev->right = curr;
                    curr = curr->left;
                }
                else {
                    prev->right = NULL;
                    curr = curr->right;
                }
            }
        }
        return result;
    }
};