【Leetcode】Binary Tree Traversal

把三个二叉树遍历的题放在一起了。

递归写法太简单，就不再实现了，每题实现了两种非递归算法。

一种是利用栈，时间和空间复杂度都是O(n)。

另一种是借助线索二叉树，也叫Morris遍历，充分利用树中节点的空指针域。

先序：

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].

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

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

---

中序：

Binary Tree Inorder Traversal

Given a binary tree, return the inorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

   1
    \
     2
    /
   3

return [1,3,2].

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

 class Solution {
 public:
     vector<int> inorderTraversal(TreeNode *root) {
         vector<int> result;
         TreeNode *p = root;
         while (p) {
             if (p->left) {
                 TreeNode *q = p->left;
                 while (q->right && q->right != p) {
                     q = q->right;
                 }
                 if (q->right == p) {
                     result.push_back(p->val);
                     q->right = nullptr;
                     p = p->right;
                 } else {
                     q->right = p;
                     p = p->left;
                 }
             } else {
                 result.push_back(p->val);
                 p = p->right;
             }
         }
         return result;
     }
 };

---

后序：

Binary Tree Postorder Traversal

Given a binary tree, return the postorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

   1
    \
     2
    /
   3

return [3,2,1].

 class Solution {
 public:
     vector<int> postorderTraversal(TreeNode *root) {
         vector<int> result;
         stack<TreeNode *> s;
         TreeNode *p = root;
         TreeNode *q = nullptr, *last = nullptr;
         while (!s.empty() || p) {
             if (p) {
                 s.push(p);
                 p = p->left;
             } else {
                 q = s.top();
                 if (q->right && last != q->right) {
                     p = q->right;
                 } else {
                     result.push_back(q->val);
                     s.pop();
                     last = q;
                 }
             }
         }
         return result;
     }
 };

 class Solution {
 public:
     vector<int> postorderTraversal(TreeNode *root) {
         vector<int> result;
         TreeNode dummy();
         TreeNode *p = &dummy, *pre = nullptr;
         p->left = root;
         while (p) {
             if (p->left == nullptr) {
                 p = p->right;
             } else {
                 pre = p->left;
                 while (pre->right != nullptr && pre->right != p) {
                     pre = pre->right;
                 }
                 if (pre->right == nullptr) {
                     pre->right = p;
                     p = p->left;
                 } else {
                     printReverse(result, p->left, pre);
                     pre->right = nullptr;
                     p = p->right;
                 }
             }
         }
         return result;
     }

 private:
     void printReverse(vector<int>& v, TreeNode* from, TreeNode *to) {
         reverse(from, to);
         TreeNode *p = to;
         while (true) {
             v.push_back(p->val);
             if (p == from) {
                 break;
             }
             p = p->right;
         }
         reverse(to, from);
     }

     void reverse(TreeNode *from, TreeNode *to) {
         if (from == to) {
             return;
         }
         TreeNode *x = from, *y = x->right, *z;
         while (true) {
             z = y->right;
             y->right = x;
             x = y;
             y = z;
             if (x == to) {
                 break;
             }
         }
     }
 };