94. 二叉树的中序遍历，递归，基于栈的遍历，莫里斯遍历+前序遍历和后序遍历

二叉树的四大遍历之一中序遍历。使用三大方法，递归，基于栈的遍历，莫里斯遍历

方法一：递归方法效率低，栈迭代方法虽提高了效率，但嵌套循环太麻烦。本方法递归+栈迭代

核心思想：新节点为白色，已访问的节点为灰色。遇到白色节点，标为灰色，其右根左一次入栈，遇到灰节点输出

class Solution:
    def inorderTraversal(self,root):
        WHITE,GRAY=0,1
        res=[]
        stack=[(WHITE,root)]
        while stack:
            color,node = stack.pop()
            if node is None: continue
            if color==WHITE:
                stack.append((WHITE,node.right))
                stack.append((GRAY,node))
                stack.append((WHITE,node.left))
            else:
                res.append(node.val)
        return res

方法二：递归

class Solution:
    def inorderTraversal(self,root):
        res=[]
        def dfs(root):
            if not root:
                return
            dfs(root.left)
            res.append(root.val)
            dfs(root.right)
        dfs(root)
        return res
时间复杂度O(n)
空间复杂度(h),h是树的高度

重点！

★方法三：栈的迭代遍历。二叉树的遍历的难点在于如何用非递归的方式实现。递归实现时，是函数自己调用自己，一层层的嵌套，操作系统自动帮我们使用栈来保存每个调用的函数。现在用栈来自己实现这样的调用过程。

递归的调用过程是不断往左边走，当左边走不下去时，就打印节点，并转向右边，然后右边继续这个过程。
在迭代的过程中，用栈来实现上面的调用过程。

class Solution:
    def inorderTraversal(self,root):
        res=[]
        stack=[]
        while stack or root:
            while root:
                stack.append(root)#不断添加左边的节点
                root=root.left
            #elsewhile结束说明左边走不下去了，节点为空了，则打印节点，并转向右边，继续上面的过程
            tmp = stack.pop()#将左子树遍历的节点打印添加
            res.append(tmp.val)
            root = tmp.right#遍历右子树
        return res
时间复杂度O(n)
空间复杂度(h),h是树的高度

本方法的前序遍历和后序遍历怎么做待会看？
二叉树的遍历都可以借助栈结构使用DFS算法完成。

对于先序遍历
class Solution:
    def preorderTraversal(self,root):
        res=[]
        stack=[]
        while stack or root:
            while root:
                res.append(root.val)
                stack.append(root)
                root=root.left
            tmp=stack.pop()
            root=tmp.right
        return res
对于后序遍历
class Solution:
    def postorderTraversal(self,root):
        res=[]
        stack=[]
        while stack or root:
            while root:
                res.append(root.val)
                stack.append(root)
                root=root.right#和前序遍历相反处
            tmp=stack.pop()
            root=tmp.left#和前序遍历相反处
        return res[::-1]
因为前序遍历是中左右，后序遍历是左右中，反过来就是中右左。和前序遍历仅仅是后两个
的关系，所以按照前序遍历写，再结果翻转就ok了

方法四：莫里斯遍历 递归和迭代的方法都会使用辅助空间，而莫里斯遍历是没有使用任何辅助空间的，改变了整个树的结构，强行把一棵二叉树改成一段链表结构

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    def inorderTraversal(self, root: TreeNode):
        res = []
        pre=None
        while root:
            if root.left: #如果左节点不为空，则将当前节点连带右子树全部挂到左节点的最右子树下面
                pre=root.left
                while pre.right:
                    pre = pre.right
                pre.right = root
                tmp=root
                root=root.left
                tmp.left=None
            else: #左子树为空，则打印这个节点，并向右遍历
                res.append(root.val)
                root=root.right
        return res
root=TreeNode(1)
root.left=None
root.right=TreeNode(2)
root.right.left=TreeNode(3)
root.right.right=None
print(Solution().inorderTraversal(root))
上述为完整实现过程，加上了TreeNode生成树的过程
时间复杂度：找到前驱节点的复杂度是O(n),因为n个节点的二叉树有n-1条边，每条边只可能
使用2次，1次定位到节点，1次找到前驱节点，所以时间复杂度为O(n) 
空间复杂度：O(1)