二叉树前中后序遍历，迭代与Morris写法记录

二叉树前中后序遍历，迭代与Morris记录

二叉树前序遍历

迭代

class Solution {
public:
   vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if (!root) return res;
        stack<TreeNode *> stk;
        while (root || !stk.empty()) {
            while (root) {
                res.emplace_back(root->val);
                stk.emplace(root);
                root = root->left;
            }
            root = stk.top();
            stk.pop();
            root = root->right;
        }
        return res;
    }
};

利用栈，如果root不为空且栈不为空，反复循环
先遍历完root左节点并在每次循环首先将root的值推入结果，并将root压入栈用于后续取出来获取右节点

morris

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if (!root) return res;
        TreeNode *predecessor = nullptr;
        while (root) {
            predecessor = root->left;
            if (predecessor) {
                while (predecessor->right && predecessor->right != root) {
                    predecessor = predecessor->right;
                }
                if (!predecessor->right) {
                    res.emplace_back(root->val);
                    predecessor->right = root;
                    root = root->left;
                    continue;
                } else {
                    predecessor->right = nullptr;
                }
            } else {
                res.emplace_back(root->val);
            }
            root = root->right;
        }
        return res;
    }
};

morris 相对复杂点，
这个算法需要用到一个临时节点，总体循环以root不为null进行
如果root不为null，这个节点需要先向左一位（即=root->left)，如果这左一位没有会直接将root的值推入结果，并让root=root->right
如果有，会先将临时节点移动到最右，最右的右边必定会为null，第一次会将最右的右边=root此时的位置，随后让root左移一次，这里因为是前序遍历，所以第一件事先将root值推入结果列表。如果下次遍历下来这边的判断最右的右==root，那么将临时节点右为null，而root会移动到此时的右节点。

二叉树中序遍历

迭代

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

与前序在于第二个循环root遍历左节点不将结果如列表，而先入栈，最后遍历完 FILO top先出栈 说明最左先推入结果，然后将root=root->right

morris

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

morris与前序相比，在最右后不先进行将结果推入结果列表，而是将这一步移到如果临时节点最右的右有root，那么此时将root的值推入列表

二叉树后序遍历

迭代

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if (!root) return res;
        stack<TreeNode *> stk;
        TreeNode *prev = nullptr;
        while (root || !stk.empty()) {
            while (root) {
                stk.emplace(root);
                root = root->left;
            }
            root = stk.top();
            stk.pop();
            if (!root->right || root->right == prev) {
                res.emplace_back(root->val);
                prev = root;
                root = nullptr;
            } else {
                stk.emplace(root);
                root = root->right;
            }
        }
        return res;
    }
};

后序的迭代差别比较大，它需要用到一个前节点来存储上一次推入列表的root，当本次循环的root右节点为空或不为前节点，才推入至结果列表，否则压回栈并将root移动至右节点。

morris

class Solution {
public:
    void addPath(vector<int> &vec, TreeNode *node) {
        int count = 0;
        while (node) {
            ++count;
            vec.emplace_back(node->val);
            node = node->right;
        }
        reverse(vec.end() - count, vec.end());
    }

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if (!root) return res;
        TreeNode *p1 = root, *p2 = nullptr;
        while (p1) {
            p2 = p1->left;
            if (p2) {
                while (p2->right && p2->right != p1) {
                    p2 = p2->right;
                }
                if (!p2->right) {
                    p2->right = p1;
                    p1 = p1->left;
                    continue;
                } else {
                    p2->right = nullptr;
                    addPath(res, p1->left);
                }
            }
            p1 = p1->right;
        }
        addPath(res, root);
        return res;
    }
};

后序的morris算是最复杂的，后序需要最左，左同级的右（右没子的话）。
先按morris的老流程准备个临时节点，这个临时节点先左移一位再右移到最后，并将最后的右节点为主节点，随后主节点左移以为做同样的操作，直到主节点左边就一个节点。这个时候临时节点已经将这个主节点的左节点的右节点连接到了主节点
这时临时节点会去掉这个右节点的连接，虽然推入这个主节点到列表，最左下的操作还算比较好理解就一个，主要是之后的左节点同级的右节点。
这时这个最左节点推入后，主节点会来到同级的右节点，很显然，这个变为主节点的左子节点为空，所以主节点还会继续向右，而这次移动的位置是之前临时节点设置的主节点，这时同样的操作进行后，临时节点移除这个与主节点的连接并将这个之前作为主节点的点作为现在的主节点的左子节点推入列表并将其所有的右子节点推入，但按后序遍历顺序不对，所以还要将刚才所有推入的节点翻转顺序，便是上述代码addPath的操作
这样的写法不会推入root节点，所以最后返回前还需要把root节点推入