Morris遍历

Morris主要解决一个问题，如何实现二叉树的前中后序遍历，有两个要求：

1. O(1)空间复杂度，O(N)时间复杂度；

2. 二叉树的形状不能被破坏（中间过程允许改变其形状）。

以往是用栈结构辅助实现从下到上，但此算法是用到了线索二叉树的概念，通过让底层结点指向null的空闲指针指向上层的某个结点。

先不论先中后序，Morris遍历的过程为：

1、如果cur 为null，则过程停止，否则继续；

2、如果cur没有左子树，则cur = cur.right；

3、如果cur有左子树，则找到cur左子树上最右的结点，记为mostRight

1）如果mostRight的right指针指向null，则mostRight.right = cur，然后cur = cur.left

2）如果mostRight的right指针指向cur(即已经经过第一次遍历）,令mostRight.right = null，cur = cur.right

根据以上过程写出的代码为：

    def Morris(self,root):
        if not root:
            return None
        cur = root
        while cur:
            mostRight = cur.left
            if mostRight:
                while mostRight.right and mostRight.right != cur:
                    mostRight = mostRight.right
                if mostRight.right == None:
                    mostRight.right = cur
                    cur = cur.left
                    continue
                else:
                    mostRight.right = None
            cur = cur.right

那么先序遍历，则是将打印函数放在第一次遍历到的结点处：

    def Morris(self,root):
        if not root:
            return None
        cur = root
        while cur:
            mostRight = cur.left
            if mostRight:
                while mostRight.right and mostRight.right != cur:
                    mostRight = mostRight.right
                if mostRight.right == None:
                    mostRight.right = cur
                    print(cur.val)#这里是根结点
                    cur = cur.left
                    continue
                else:
                    mostRight.right = None
            else:
                print(cur.val)#无左就直接打印右
            cur = cur.right

中序遍历，则是等左子树都遍历完成后再开始打印

    def Morris(self,root):
        if not root:
            return None
        cur = root
        while cur:
            mostRight = cur.left
            if mostRight:
                while mostRight.right and mostRight.right != cur:
                    mostRight = mostRight.right
                if mostRight.right == None:
                    mostRight.right = cur
                    cur = cur.left
                    continue
                else:
                    mostRight.right = None
            print(cur.val)
            cur = cur.right

后序比较复杂，程序如下：

1、对于无左子树的（只遍历一次的），直接跳过，无打印行为；

2、对于有左子树的（可以遍历两次的），cur第一次时无打印，第二次时逆序打印左子树的右边界；

3、cur遍历完成后，逆序打印整个树的右边界。

其实整个程序就如下图所示：

打印顺序为4，5，2，6，7，3，1

    def Morris(self,root):
        if not root:
            return None
        cur = root
        while cur:
            mostRight = cur.left
            if mostRight:#有左子树，可以遍历两次
                while mostRight.right and mostRight.right != cur:
                    mostRight = mostRight.right
                if mostRight.right == None:
                    mostRight.right = cur
                    cur = cur.left
                    continue
                else:
                    mostRight.right = None
                    #第二次
                    self.printEdge(cur.left)
            cur = cur.right
        # 最后逆序打印整棵树右边界
        self.printEdge(root)
    def printEdge(self,head):
        tail = self.reverseEdge(head)
        cur = tail
        while cur:
            print(cur.val)
            cur = cur.right
        #不能改变二叉树结构，逆序完了逆回去
        self.reverseEdge(tail)
    def reverseEdge(self,cur):
        pre = None
        while cur:
            next = cur.right
            cur.right = pre
            pre = cur
            cur = next
        return pre

最后证明一下Morris符合题目要求：

代码只使用了有限几个变量，故额外空间复杂度为O(1)，而遍历对于有左子树的只遍历两次，无左子树的只遍历一次，总时间复杂度还是O(N)