二叉树Morris遍历

前言

二叉树的遍历方式按顺序划分可分成前序、中序、后序遍历，其中，遍历的时间复杂度为 $O(n)$，空间复杂度为 $O(logn)$。在部分情况下，例如二叉树退化成链表，空间复杂度为 $O(n)$，这是因为无论是递归或者是非递归的遍历方式，都避免不了栈的开销。非递归只不过是把系统的递归栈自己手动实现罢了。

Morris 遍历可以在增加时间复杂度的常数，但是实际的时间复杂度仍然是 $O(n)$，把空间复杂度优化到 $O(1)$，并实现二叉树的前序、中序、后序遍历。

算法

大致流程

对于一个树节点，我们不妨设它为 cur ，我们考虑其是否有左孩子节点：若没有左孩子，则将 cur 切换到右子树；若有左孩子，则先找到左子树的最右侧节点，判断该节点的右指针是否指向空，若为空则将它指向 cur ，然后 cur 切换到左子树；否则将它指向空，然后 cur 切换到右子树。当且仅当 cur == 空时，算法结束。

分析

实际上这种遍历方式利用到了和线索二叉树类似的思路，利用终端节点的孩子指针，稍微修改后就能完成二叉树遍历的逻辑。

我们可以发现，根据这个算法，每个节点的左子树的右侧链都会访问两次，第一次是把最右侧节点的右指针指向当前子树的根，方便那个节点访问后回到根，第二次则是去把那个后继指针断掉，使得二叉树回归原貌。除了整棵树的最右侧链没遍历三次，剩下的节点都会遍历三次，所以复杂度为 $O(3n)=O(n)$，空间复杂度为 $O(1)$。

Morris先序遍历

访问节点数据的时机是第一次找到左子树的最右节点并修改右指针时，因为此时相当于访问左子树的准备工作完成，要进入左子树之前，把根的数据访问。

Morris中序遍历

访问节点数据的时机是即将切换到右子树之前，因为左子树可能为空也可能不为空，也就是说当前子树根节点无论时第一次或者是第二次访问都没有关系，之前在右子树之前输出即可。

Morris后序遍历

实际上，Morris遍历方式无法在右子树访问完毕后又回到根节点，但是分析中有提到，整个二叉树可以按右侧链被划分成多个部分，从左到右分别逆序输出这个右侧链即可。 输出的时机恰好是第二次回到子树的根节点的时候，此时可以把左子树的最右侧链的指针逆置，输出完毕后再改回来，最后切换到右子树。如图：

代码实现

#include <bits/stdc++.h>

using namespace std;

template<class E>
class TreeNode {
public:
    TreeNode *lson;
    TreeNode *rson;

    E _val;

    TreeNode(const E& val)
        :_val(val)
        ,lson(NULL)
        ,rson(NULL)
    {}

    void print() {
        cout << _val << ' ';
    }

};

//先序构造二叉树
void build(int arr[], int& id, int n, TreeNode<int>* &_root) {
    if (id >= n || arr[id] == -1) return ; 
    _root = new TreeNode<int>(arr[id]);
    build(arr, ++id, n, _root->lson);
    build(arr, ++id, n, _root->rson);
}

//morris基本框架
void Morris(TreeNode<int>* &root) {
    if (root == NULL) return ;
    TreeNode<int>* cur = root;
    TreeNode<int>* right = NULL;
    while (cur != NULL) {
        right = cur->lson;
        if (right != NULL) {
            while (right->rson != NULL && right->rson != cur) right = right->rson; //找左子树的最右侧节点
            if (right->rson == NULL) {
                right->rson = cur;
                cur = cur->lson;
                continue;
            } else {
                right->rson = NULL;
            }
        }
        cur = cur->rson;
    }
}

void MorrisPreOrderTraverse(TreeNode<int>* &root) {
    if (root == NULL) return ;
    TreeNode<int>* cur = root;
    TreeNode<int>* right = NULL;
    while (cur != NULL) {
        right = cur->lson;
        if (right != NULL) {
            while (right->rson != NULL && right->rson != cur) right = right->rson;
            if (right->rson == NULL) {
                right->rson = cur;

                cur->print();
                
                cur = cur->lson;
                continue;
            } else {
                right->rson = NULL;
            }
        } else {
            cur->print(); //左子树为空但右子树不为空时直接打印
        }
        cur = cur->rson;
    }
    cout << endl;
}

void MorrisInOrderTraverse(TreeNode<int>* &root) {
    if (root == NULL) return ;
    TreeNode<int>* cur = root;
    TreeNode<int>* right = NULL;
    while (cur != NULL) {
        right = cur->lson;
        if (right != NULL) {
            while (right->rson != NULL && right->rson != cur) right = right->rson;
            if (right->rson == NULL) {
                right->rson = cur;
                cur = cur->lson;
                continue;
            } else {
                right->rson = NULL;
            }
        }
        cur->print(); //进入右子树前打印
        cur = cur->rson;
    }
    cout << endl;
}

template<class E>
TreeNode<E>* ReverseEdge(TreeNode<E>* head) {
    TreeNode<E>* _next = NULL;
    TreeNode<E>* _pre = head;
    while (head != NULL) {
        head = head->rson;
        _pre->rson = _next;
        _next = _pre;
        _pre = head;
    }
    return _next;
}

void PrintEdge(TreeNode<int>* head) {
    TreeNode<int>* start = ReverseEdge(head);
    TreeNode<int>* cur = start;
    while (cur != NULL) {
        cur->print();
        cur = cur->rson;
    }
    ReverseEdge(start);
}

void MorrisPosOrderTraverse(TreeNode<int>* &root) {
    if (root == NULL) return ;
    TreeNode<int>* cur = root;
    TreeNode<int>* right = NULL;
    while (cur != NULL) {
        right = cur->lson;
        if (right != NULL) {
            while (right->rson != NULL && right->rson != cur) right = right->rson;
            if (right->rson == NULL) {
                right->rson = cur;
                cur = cur->lson;
                continue;
            } else {
                right->rson = NULL;
                PrintEdge(cur->lson); //逆序打印左子树的右侧链
            }
        }
        cur = cur->rson;
    }
    PrintEdge(root); //整棵树的最外侧链
    cout << endl;
}

int main() {
    TreeNode<int>* root = NULL;
    int arr[] = {1,2,4,8,-1,-1,9,-1,-1,5,-1,-1,3,6,10,-1,-1,-1,7,11,-1,-1,12,-1,-1}, n = 25, id = 0;
    
    build(arr, id, n, root);

    MorrisPreOrderTraverse(root);

    MorrisInOrderTraverse(root);

    MorrisPosOrderTraverse(root);

    return 0;
}