二叉树的莫里斯(Morris)遍历

什么是Morris遍历

其实就是把空间复杂度优化到O(1)的二叉树遍历算法。

对于一般的遍历算法，我们都是利用栈来存储之后需要再次访问的节点。最差情况下，我们需要存储整个二叉树节点。所以空间复杂度为O(n)。而Morris遍历则是将空间复杂度降到了O(1)级别。Morris遍历用到了“线索二叉树”的概念，其实就是利用了叶子节点的左右空指针来存储某种遍历前驱节点或者后继节点。因此没有使用额外的空间。

Morris遍历的算法思想

假设当前节点为cur，并且开始时赋值为根节点root。

1. 判断cur节点是否为空
2. 如果不为空
   1）如果cur没有左孩子，cur向右更新，即（cur = cur.right）
   2）如果cur有左孩子，则从左子树找到最右侧节点pre
   • 如果pre的右孩子为空，则将右孩子指向cur。pre.right = cur
   • 如果pre的右孩子为cur，则将其指向为空。pre.right = null。（还原树结构）
3. cur为空时，停止遍历

Morris前序遍历

我们以下面的一个简单二叉树为例，简单说明一下Morris前序遍历的流程。

• 将根节点1设置为cur。
• 因为cur（节点1）不为空，且cur（节点1）的左孩子节点2不为空，所以我们找到以节点2为根节点的左子树中最右端的节点5。
• 节点5右孩子为空，此时我们输出cur（节点1）的值，然后将节点5右孩子指向为cur，即节点1。更新cur节点为cur左孩子，即节点2。
• 因为cur（节点2）左孩子不为空，找到其左子树最右端节点4
• 节点4右孩子为空，先输出cur（节点2）的值，再将节点4右孩子指向cur（节点2）,并更新cur（节点2）为其左孩子节点4。
• 这个时候cur（节点4）的左孩子为空，所以访问其右孩子，发现右孩子指向了节点2，所以我们将cur更新为节点2。
• 这个时候我们发现cur又指向了节点2，所以左孩子节点4不为空，我们再次找到左子树中最右端节点4，但是这个时候节点4的右孩子指向了cur，所以我们将其删除，即节点4右孩子指向为空，恢复原来的树结构。并且由于已经访问了左孩子和根节点，所以这个时候我们访问其右孩子节点5。
• …

public void Morris_preorderTraversal(TreeNode root){
    TreeNode cur = root;
    while(cur!=null){
        if(cur.left!=null){
            TreeNode pre = cur.left;
            while(pre.right!=null && pre.right!=cur){
                pre = pre.right;
            }
            if(pre.right == null){	// 第一次到达左子树的最右端
                System.out.print(cur.val);
                pre.right = cur;
                cur = cur.left;
            }
            else{ // 第二次到达左子树的最右端
                pre.right = null;
                cur = cur.right;
            }
        }
        else{
            System.out.print(cur.val);
            cur = cur.right;
        }
    }
}

Morris中序遍历

Morris中序遍历和前序遍历相差不大，只是在输出位置上出现了变化。

public void Morris_inorderTraversal(TreeNode root){
        TreeNode cur = root;
        while(cur!=null){
            if(cur.left!=null){
                TreeNode pre = cur.left;
                while(pre.right!=null && pre.right!=cur){
                    pre = pre.right;
                }
                if(pre.right == null){
                    pre.right = cur;
                    cur = cur.left;
                }
                else{
                    pre.right = null;
                    System.out.print(cur.val);
                    cur = cur.right;
                }
            }
            else {
                System.out.print(cur.val);
                cur = cur.right;
            }
        }
    }

Morris后序遍历

Morris后序遍历也是这当中最复杂的一种。因为右孩子需要在根节点之前输出。对于下图，后序遍历的顺序时：4、5、2、6、3、1。我们可以看到对于节点1的左子树，节点2和节点5是其右边界，我们只要逆序输出，就可以实现后序遍历的访问顺序。因此我们需要一个函数对其进行逆转，即节点5指向节点2。并且在输出之后，再将其逆转回来（不改变树的结构）。

public TreeNode reverseNode(TreeNode node){
    TreeNode pre = null;
    TreeNode next = null;
    while(node!=null){
        next = node.right;
        node.right = pre;
        pre = node;
        node = next;
    }
    return pre;
}

public void printNode(TreeNode node){
    TreeNode tail = reverseNode(node);
    TreeNode cur = tail;
    while(cur!=null){
        System.out.println(cur.val);
        cur = cur.right;
    }
    reverseNode(tail);
}

public void Morris_postorderTraversal(TreeNode root) {
    TreeNode cur = root;
    while(cur != null){
        if(cur.left!=null){
            TreeNode pre = cur.left;
            while(pre.right!=null && pre.right!=cur){
                pre = pre.right;
            }
            if(pre.right==null){
                pre.right = cur;
                cur = cur.left;
            }
            else{
                pre.right = null;
                printNode(cur.left);
                cur = cur.right;
            }
        }
        else{
            cur = cur.right;
        }
    }
    printNode(root);
}

总结

Morris遍历将二叉树遍历的空间复杂度降到了O(1)，当然时间复杂度依然是O(n)。