LeetCode 99 | 如何不用递归遍历二叉搜索树？MT方法给你答案

Input: [1,3,null,null,2]

   1
  /
 3
  
   2

Output: [3,1,null,null,2]

   3
  /
 1
  
   2

Input: [3,1,4,null,null,2]

  3
 / 
1   4
   /
  2

Output: [2,1,4,null,null,3]

  2
 / 
1   4
   /
  3

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def recoverTree(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        inorder = []
        
        def dfs(node):
            if node is None:
                return
            
            dfs(node.left)
            inorder.append(node)
            dfs(node.right)
            
        # 中序遍历获得所有元素
        dfs(root)
        n = len(inorder)
        x, y = None, None
        for i in range(n-1):
            if inorder[i+1].val < inorder[i].val:
                # 我们用y记录后一个错误的位置
                # 如果遇到两次，那么取最后出现的y
                y = inorder[i+1]
                # x用来记录第一次错位时的前位元素
                # 如果遇到两次错位，直接break
                if x is None:
                    x = inorder[i]
                else:
                    break
                    
                    
        x.val, y.val = y.val, x.val

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def recoverTree(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        
        x, y, pnt = None, None, None
        pre = None
        
        while root is not None:
            # 如果存在左子树那么找到pnt
            if root.left is not None:
                pnt = root.left
                while pnt.right is not None and pnt.right.val != root.val:
                    pnt = pnt.right
                    
                # 如果pnt的right是空，说明root是第一次遍历到
                if pnt.right is None:
                    pnt.right = root
                    root = root.left
                else:
                    # 否则比较前驱和root的大小
                    # 这里要注意没有break，因为我们遍历完之后需要去掉多余的指针，否则会导致死循环
                    if pre is not None and pre.val > root.val:
                        y = root
                        if x is None:
                            x = pre
                    # 将root更新成前驱
                    pre = root
                    pnt.right = None
                    root = root.right
            else:
                # 向右移动比较简单，只需要考虑前驱的情况
                if pre is not None and pre.val > root.val:
                    y = root
                    if x is None:
                        x = pre
                pre = root
                root = root.right
                
        x.val, y.val = y.val, x.val