面试中很值得聊的二叉树遍历方法——Morris遍历

Morris遍历

通过利用空闲指针的方式，来节省空间。时间复杂度O(N)，额外空间复杂度O(1)。普通的非递归和递归方法的额外空间和树的高度有关，递归的过程涉及到系统压栈，非递归需要自己申请栈空间，都具有O(N)的额外空间复杂度。

Morris遍历的原则:

1. 假设当前节点为cur，

2. 如果cur没有左孩子，cur向右移动，cur = cur.right

3. 如果cur有左孩子，找到左子树上最右的节点mostRight

　　3.1 如果mostRight.right == null，令mostRight.right = cur，cur向左移动，cur = cur.left

　　3.2 如果mostRight.right == cur，令mostRight.right = null，cur向右移动，cur = cur.right

4. 如果cur == null 停止遍历

 Morris：1242513637

    public static void morris(TreeNode head){
        if(head == null) return;
        TreeNode cur = head;
        TreeNode mostRight = null;
        while(cur != null){//cur为空遍历停止【4】
            mostRight = cur.left;//是cur左子树上最右的节点
            if(mostRight != null){//有左子树【3】
                while(mostRight.right != null && mostRight != cur){//mostRight!=cur不加就会绕环循环
                    mostRight = mostRight.right;//找最右节点【3】
                }
                if(mostRight.right == null){//第一次来到cur【3.1】
                    mostRight.right = cur;
                    cur = cur.left;
                    continue;//执行循环
                }else {//mostRight.right = cur第二次来到cur【3.2】
                    mostRight.right = null;
                }
            }
            cur = cur.right;//没有左子树【2】

        }
    }

所有节点遍历左子树右边界的时间总代价O(N)

基于Morris的先中后序遍历

如果cur有左子树一定能遍历2次，没有左子树只能遍历一次。

先序遍历

 Morris：1242513637

 Morris先序：1245367

基于Morris的先序遍历，如果一个节点可以到达两次则打印第一次，如果只能到达一次直接打印。

    public static void morrisPre(TreeNode head){
        if(head == null) return;
        TreeNode cur = head;
        TreeNode mostRight = null;
        while(cur != null){//有左子树
            mostRight = cur.left;
            if(mostRight != null){
                while(mostRight.right != null && mostRight != cur){
                    mostRight = mostRight.right;
                }
                if(mostRight.right == null){//第一次来到左子树
                    System.out.println(cur.val);//打印
                    mostRight.right = cur;
                    cur = cur.left;
                    continue;
                }else {
                    mostRight.right = null;
                }
            }else{
                System.out.println(cur.val);//没有左子树 只会遍历一次
            }
            cur = cur.right;
        }
    }

中序遍历

 Morris：1242513637

 Morris中序：4251637

基于Morris的中序遍历，如果一个节点可以到达两次则打印第二次，如果只能到达一次直接打印。

    public static void morrisIn(TreeNode head) {
        if(head == null) return;
        TreeNode cur = head;
        TreeNode mostRight = null;
        while(cur != null){
            mostRight = cur.left;
            if(mostRight != null){
                while(mostRight.right != null && mostRight != cur){
                    mostRight = mostRight.right;
                }
                if(mostRight.right == null){
                    mostRight.right = cur;
                    cur = cur.left;
                    continue;
                }else {
                    mostRight.right = null;
                }
            }
            //没有左树跳过if直接打印，有左树第二次来到cur退出循环打印
            System.out.println(cur.val);
            cur = cur.right;
        }
    }

后序遍历

 Morris：1242513637

 Morris先序：4526731

基于Morris的后序遍历，如果一个节点可以到达两次则第二次到达时逆序打印左树的右边界，单独逆序打印整棵树的右边界。

（1）逆序右边界（等同于单链表的逆序）

      public static TreeNode reverseEdge(TreeNode from) {
        TreeNode pre = null;
        TreeNode next = null;
        while(from != null){
            next = from.right;
            from.right = pre;
            pre = from;
            from = next;
        }
        return pre;
    }

（2）逆序打印以head为头节点的右边界。

    public static void printRightEdge(TreeNode head) {
        TreeNode tail = reverseEdge(head);//逆转右边界
        TreeNode cur = tail;
        while(cur != null){
            System.out.println(cur.val + " ");
            cur = cur.right;
        }
        reverseEdge(tail);//逆转回去 恢复原树
    }

（3）在Morris遍历中按时机打印。

    public static void morrisPost(TreeNode head){
        if(head == null) return;
        TreeNode cur = head;
        TreeNode mostRight = null;
        while(cur != null){
            mostRight = cur.left;
            if(mostRight != null){
                while(mostRight.right != null && mostRight != cur){
                    mostRight = mostRight.right;
                }
                if(mostRight.right == null){
                    mostRight.right = cur;
                    cur = cur.left;
                    continue;
                }else {//第二次达到 逆序打印左子树的右边界
                    mostRight.right = null;
                    printRightEdge(cur.left);
                }
            }
            cur = cur.right;
        }
        //最后退出循环之后，单独打印整棵树的右边界
        printRightEdge(head);
    }

Morris遍历的应用

如何判断一棵树是否是搜索二叉树？

中序遍历升序就是搜索二叉树。

    public static boolean isBST(TreeNode head){
        if(head == null) return true;
        TreeNode cur = head;
        TreeNode mostRight = null;
        int preValue = Integer.MIN_VALUE;//上一次得到的值
        while(cur != null){
            mostRight = cur.left;
            if(mostRight != null){
                while(mostRight.right != null && mostRight != cur){
                    mostRight = mostRight.right;
                }
                if(mostRight.right == null){
                    mostRight.right = cur;
                    cur = cur.left;
                    continue;
                }else {
                    mostRight.right = null;
                }
            }
            //中序遍历的操作时机在这里 所以在这里进行判断
            if(cur.val <= preValue){//没有递增
                return false;
            }
            preValue = cur.val;
            cur = cur.right;
        }
        return true;
    }

总结

树型DP问题的套路：定义一个类收集树的信息，定义一个递归函数，递归地收集左子树的信息和右子树的信息，再整合得到以当前节点为根的树的信息。

什么时候用树型DP什么时候用Morris遍历？

当必须得到左树的信息和右树的信息后，再在当前节点整合二者信息后做出判断则用树型DP是最优解。

当不需要整合左树和右树信息的时候，可以用树型DP，但是Morris是最优解。