空间复杂度为O(1)的Morris遍历代码(python)

前面讲了二叉树的迭代遍历写法，可以看出空间复杂度都是O(n)的。

 J. H. Morris 在 1979 年的论文「Traversing Binary Trees Simply and Cheaply」中首次 Morris 遍历。

Morris遍历的基本思想是：

记作当前节点为cur。

1. 如果cur无左孩子，cur向右移动（cur=cur.right）
2. 如果cur有左孩子，找到cur左子树上最右的节点，记为mostright
   1. 如果mostright的right指针指向空，让其指向cur，cur向左移动（cur=cur.left）
   2. 如果mostright的right指针指向cur，让其指向空，cur向右移动（cur=cur.right）

实现以上的原则，即实现了morris遍历。

实质在于，对于没有左子树的节点只到达一次，有左子树的节点会到达两次。

（Insight From: 神级遍历——morris - 知乎)

其前序遍历规则总结如下：

    新建临时节点，令该节点为 root；

    如果当前节点的左子节点为空，将当前节点加入答案，并遍历当前节点的右子节点；

    如果当前节点的左子节点不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点：

        如果前驱节点的右子节点为空，将前驱节点的右子节点设置为当前节点。然后将当前节点加入答案，并将前驱节点的右子节点更新为当前节点。当前节点更新为当前节点的左子节点。

        如果前驱节点的右子节点为当前节点，将它的右子节点重新设为空。当前节点更新为当前节点的右子节点。

    重复步骤 2 和步骤 3，直到遍历结束。

这样我们利用 Morris 遍历的方法，前序遍历该二叉树，即可实现线性时间与常数空间的遍历。

前序遍历代码：

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
      
        p1 = root
        while p1:
            p2 = p1.left
            if p2:
                # 找当前节点在中序遍历中的前驱节点
                while p2.right and p2.right != p1:
                    p2 = p2.right
                if not p2.right:
                    res.append(p1.val)
                    p2.right = p1
                    p1 = p1.left
                    continue
                else:
                    p2.right = None
            else:
                res.append(p1.val)
            p1 = p1.right
        
        return res

       

中序遍历规则如下：

如果x无左孩子，先将x的值加入答案数组，再访问x的右孩子，即 x=x.right
如果x有左孩子，则找到 x左子树上最右的节点（即左子树中序遍历的最后一个节点，x在中序遍历中的前驱节点），我们记为 predecessor，根据predecessor的右孩子是否为空，进行如下操作。

    如果 predecessor 的右孩子为空，则将其右孩子指向x，然后访问x的左孩子，即 x=x.left
    如果 predecessor 的右孩子不为空，则此时其右孩子指向 x，说明我们已经遍历完 x的左子树，将 predecessor 的右孩子置空，将x的值加入答案数组，然后访问 x的右孩子，即 x=x.right

代码：

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        while root:
            if root.left:
                # find out predecessor
                predecessor = root.left
                while predecessor.right:
                    predecessor = predecessor.right
                # link predecessor to root
                predecessor.right = root
                # set left child of root to None
                temp = root
                root = root.left
                # （这里改变了原有的树的结构，如果有更优化的代码，之后会更新）
                # 结构被改变后，root的左子树不会再被访问
                temp.left = None
            else:
                res.append(root.val)
                root = root.right
        return res

后续遍历规则如下：

新建临时节点，令该节点为 root；

如果当前节点的左子节点为空，则遍历当前节点的右子节点；

如果当前节点的左子节点不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点；

    如果前驱节点的右子节点为空，将前驱节点的右子节点设置为当前节点，当前节点更新为当前节点的左子节点。

    如果前驱节点的右子节点为当前节点，将它的右子节点重新设为空。倒序输出从当前节点的左子节点到该前驱节点这条路径上的所有节点。当前节点更新为当前节点的右子节点。

重复步骤 2 和步骤 3，直到遍历结束。

代码：

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        def addPath(node: TreeNode):
            count = 0
            while node:
                count += 1
                res.append(node.val)
                node = node.right
            i, j = len(res) - count, len(res) - 1
            while i < j:
                res[i], res[j] = res[j], res[i]
                i += 1
                j -= 1
        
        if not root:
            return list()
        
        res = list()
        p1 = root

        while p1:
            p2 = p1.left
            if p2:
                while p2.right and p2.right != p1:
                    p2 = p2.right
                if not p2.right:
                    p2.right = p1
                    p1 = p1.left
                    continue
                else:
                    p2.right = None
                    addPath(p1.left)
            p1 = p1.right
        
        addPath(root)
        return res