[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. 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;
}
};