【LeetCode】Morris算法实现二叉树的前序，中序，后序遍历

1. 前序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        
        TreeNode *p = root;
        while(p) {
            if(p->left) { // 左子树不为空，要建立线索，使得p的左子树的最右节点指向p
                TreeNode *temp = p->left;
                // 如果还没达到p的左子树的最右结点，并且还没建立起线索，继续循环找；直到找到p的左子树的最右节点，或者已经建立起指向p的线索，就退出循环
                while(temp->right != nullptr && temp->right != p) {
                    temp = temp->right;
                }
                
                // 找到p的左子树的最右节点，p结点入栈，同时建立线索，p结点指向左子树的根节点，以建立其他结点的线索
                if(temp->right == nullptr) {
                    res.push_back(p->val);
                    temp->right = p;
                    p = p->left;
                } else { // 已经建立起线索，将右指针复原，同时去遍历p的右子树（此时p的左子树已经完成遍历）
                    temp->right = nullptr;
                    p = p->right;
                }
                
            } else {
                res.push_back(p->val);
                p = p->right;
            }
        }
        
        return res;
    }    
};

2. 中序遍历

// p结点左子树为空，或者线索指针指向p，输出p结点的值
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        
        TreeNode *p = root;
        while(p) {
            if(p->left) {
                TreeNode *temp = p->left;
                while(temp->right != nullptr && temp->right != p) {
                    temp = temp->right;
                }
                
                if(temp->right == nullptr) {
                    temp->right = p;
                    p = p->left;
                } else {
                    res.push_back(p->val);
                    p = p->right;
                    temp->right = nullptr;
                }
            } else {
                res.push_back(p->val);
                p = p->right;
            }
        }   
        return res;
    }    
};

3. 后序遍历

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        
        TreeNode *dummy = new TreeNode();
        dummy->left = root;
        TreeNode *p = dummy;
        
        while(p) {
            if(p->left) {
                TreeNode *temp = p->left;
                while(temp->right != nullptr && temp->right != p) {
                    temp = temp->right;
                }
                
                if(temp->right == nullptr) {
                    temp->right = p;
                    p = p->left;
                } else {
                    visitReverse(p->left, temp, res);
                    p = p->right;
                    temp->right = nullptr;
                } 
            } else {
                p = p->right;
            }
        }    
        return res;
    }
    
    void visitReverse(TreeNode* start, TreeNode* end, vector<int>& res) {        
        reverse(start, end);
        
        TreeNode *p = end;
        while(p != start) {
            res.push_back(p->val);
            p = p->right;
        }
        res.push_back(p->val);
        
        reverse(end, start);
    }

    void reverse(TreeNode* start, TreeNode* end) {
        if(start == end) return;
        
        TreeNode *pre = nullptr;
        TreeNode *cur = start;
        while(cur != end) {
            TreeNode *temp = cur->right;
            cur->right = pre;
            pre  = cur;
            cur = temp;
        }
        cur->right = pre;
    }
};

参考资料：

https://blog.csdn.net/workformywork/article/details/21628351