树的Marris序

不管是递归还是迭代遍历树的过程都是时间复杂度O(N),空间复杂度O(M) （M代表树的高度）

Morris是树相关遍历的最优解，它的时间复杂度是O(N),空间复杂度O(1)

  Maorris过程（纯手工）

我们看到依次遍历到的是 a b d b e a c f c g 

代码部分：

package dataStructure.morris;

import dataStructure.TreeNode;

public class MorrisLoopTree {
    public static void morris(TreeNode head) {
        //如果头节点都是空的，不处理
        if(head == null) return;
        //定义两个变量cur表示当前遍历到的节点
        TreeNode cur = head;
        //mostRight代表当前位置的左子树的最右节点
        TreeNode mostRight = null;
        //按照我们定义的规则，cur == null的时候所有的节点都已经遍历完了
        while (cur != null) {
            int val = cur.value;
            System.out.print(val == 1? "a" : val == 2? "b" : val == 3? "c" : val == 4? "d" : val == 5? "e" : val==6? "f" : "g");
            System.out.print(" ");
            mostRight = cur.left;
            if(mostRight != null) {//条件2：如果cur的左子树不为空,分我两种情况
                //找左子树的最右节点
                while(mostRight.right != null && mostRight.right != cur) {
                    mostRight = mostRight.right;
                }
                //条件2.a,如果mostRight.right==null代表这个节点是第一次到达
                if(mostRight.right == null) {
                    mostRight.right = cur;
                    cur = cur.left;
                    continue;
                } else {//条件2.b：如果mostRight.right != null也就是mostRight.right = cur表示这是第二次到达了，直接改为空，避免下一次处理
                    mostRight.right = null;
                }
            }
            //条件1，如果没有左子树，直接跳到右子树
            //取巧，这里本来要加一个else，但是它和条件2的cur的改变都是cur = cur.right，所以合并了
            cur = cur.right;
        }
    }

    public static void main(String[] args) {
        TreeNode a = new TreeNode(1);
        TreeNode b = new TreeNode(2);
        TreeNode c = new TreeNode(3);
        TreeNode d = new TreeNode(4);
        TreeNode e = new TreeNode(5);
        TreeNode f = new TreeNode(6);
        TreeNode g = new TreeNode(7);
        a.left = b;
        a.right = c;
        b.left = d;
        b.right = e;
        c.left = f;
        c.right = g;
        morris(a);
    }
}

代码运行结果：

a b d b e a c f c g 
Process finished with exit code 0

跟我们预期结果一致

但是我们平时遇到的题目都是先序、中序、后序遍历，而不是Morris遍历，我们想办法把Morris遍历改为先序中序和后序遍历

Morris遍历的规律：有左子树的节点会到达两次，没有的到达一次

改造成先序：先序是先根节点、然后左子树，然后右子树，我们对于cur节点，有左子树的节点，第一次到达的时候打印即可，没有左子树直接打印

根据原来的树我们先序的顺序应该是：a b d e c f g

现在我们改造原来的morris算法为先序：

public static void morrisPre(TreeNode head) {
        //如果头节点都是空的，不处理
        if(head == null) return;
        //定义两个变量cur表示当前遍历到的节点
        TreeNode cur = head;
        //mostRight代表当前位置的左子树的最右节点
        TreeNode mostRight = null;
        //按照我们定义的规则，cur == null的时候所有的节点都已经遍历完了
        while (cur != null) {
            System.out.print(" ");
            mostRight = cur.left;
            if(mostRight != null) {//条件2：如果cur的左子树不为空,分我两种情况
                //找左子树的最右节点
                while(mostRight.right != null && mostRight.right != cur) {
                    mostRight = mostRight.right;
                }
                //条件2.a,如果mostRight.right==null代表这个节点是第一次到达
                if(mostRight.right == null) {
                    //如果mostRight.right == null代表第一次遍历到cur节点，如果是第二次的话mostRight.right应该是cur
                    int val = cur.value;
                    System.out.print(val == 1? "a" : val == 2? "b" : val == 3? "c" : val == 4? "d" : val == 5? "e" : val==6? "f" : "g");
                    mostRight.right = cur;
                    cur = cur.left;
                    continue;
                } else {//条件2.b：如果mostRight.right != null也就是mostRight.right = cur表示这是第二次到达了，直接改为空，避免下一次处理
                    mostRight.right = null;
                }
            } else {
                //如果没有左孩子，则直接打印
                int val = cur.value;
                System.out.print(val == 1? "a" : val == 2? "b" : val == 3? "c" : val == 4? "d" : val == 5? "e" : val==6? "f" : "g");
            }
            //条件1，如果没有左子树，直接跳到右子树
            //取巧，这里本来要加一个else，但是它和条件2的cur的改变都是cur = cur.right，所以合并了
            cur = cur.right;
        }
    }

运行结果： a b d  e  c f  g

中序遍历：先左后跟然后是右，根据Morris遍历的过程，有左子树的节点，只需要当节点到达第二次的时候打印即可，没有左子树直接打印，原来的树的中序遍历应该是：

Morris改造成中序的代码：

public static void morrisIn(TreeNode head) {
        //如果头节点都是空的，不处理
        if(head == null) return;
        //定义两个变量cur表示当前遍历到的节点
        TreeNode cur = head;
        //mostRight代表当前位置的左子树的最右节点
        TreeNode mostRight = null;
        //按照我们定义的规则，cur == null的时候所有的节点都已经遍历完了
        while (cur != null) {
            System.out.print(" ");
            mostRight = cur.left;
            if(mostRight != null) {//条件2：如果cur的左子树不为空,分我两种情况
                //找左子树的最右节点
                while(mostRight.right != null && mostRight.right != cur) {
                    mostRight = mostRight.right;
                }
                //条件2.a,如果mostRight.right==null代表这个节点是第一次到达
                if(mostRight.right == null) {

                    mostRight.right = cur;
                    cur = cur.left;
                    continue;
                } else {//条件2.b：如果mostRight.right != null也就是mostRight.right = cur表示这是第二次到达了，直接改为空，避免下一次处理
                    //如果是第二次的话mostRight.right应该是cur，如果mostRight.right == null代表第一次遍历到cur节点，
                    int val = cur.value;
                    System.out.print(val == 1? "a" : val == 2? "b" : val == 3? "c" : val == 4? "d" : val == 5? "e" : val==6? "f" : "g");
                    mostRight.right = null;
                }
            } else {
                //如果没有左孩子，则直接打印
                int val = cur.value;
                System.out.print(val == 1? "a" : val == 2? "b" : val == 3? "c" : val == 4? "d" : val == 5? "e" : val==6? "f" : "g");
            }
            //条件1，如果没有左子树，直接跳到右子树
            //取巧，这里本来要加一个else，但是它和条件2的cur的改变都是cur = cur.right，所以合并了
            cur = cur.right;
        }
    }
运行结果：d b e a  f c g

对于原来那棵树后序遍历的结果应该是：d e b f g c a

通过Morris改后序遍历是比较麻烦的，总体思路是：遍历到每个节点第二次的时候逆序打印左子树的右边界，然后打印整棵树的右边界，对于这棵树来说是这样的：

a（第一次来到a，不管） b（第一次来到b，不管） d （第一次来到d，不管）b（第二次来到b打印b左子树的右边界d） e（第一次来到e不管） a（第二次来到a打印左子树的右边界e b） c（第一次来到c不管） f（第一次来到f不管） c（第二次来到c，打印c左子树的右边界f） g（第一次来到g不管）

最右打印整棵树的右边界g c a

我们可以看到这个过程确实是后序遍历的过程d e b f g c a

代码中的难点是是打印右边界（某个节点的左子树的右边界和整棵树的右边界）

整体算法代码我稍后更新