Recover Binary Search Tree

最近在用python刷题，但是写着各种出问题，什么变量名用错啊之类的低级错误。总感觉存在实现的障碍，写着很不爽，可能随着python代码量的增加会好很多吧。

这道题是说在一棵正确的二叉搜索树中有两个node的值发生了交换，让你在不改变树的结构的情况下，将原本的二叉搜索树还原回来。

这道题还是挺有意思的哈，本来一棵规整的搜索树，根据其递归的定义，当前节点左边的值大于其左子树的值，小于其右子树的值。于是如果存在任意两个节点值发生交换的话，只能是如下的三种情况：

（1）当前节点与其左子树的某个节点值发生交换，因此左子树的最大值大于当前节点值；

（2）当前节点与其右子树的某个节点值发生交换，因此右子树的最小值小于当前节点值；

（3）当前节点分别属于左右子树中的某两个节点发生了交换，因此此时存在左子树的最大值大于当前节点值，并且右子树的最小值小于当前节点值。

因此只需要对上面三种情况，找到相应的节点，交换回来就可以了。还是挺简单的，奉上python代码吧：

# Definition for a  binary tree node
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    # @param root, a tree node
    # @return a tree node
    def recoverTree(self, root):
        if root == None:
            return None
        leftFlag = False
        rightFlag = False
        
        leftMax = 1
        if root.left != None:
            leftMax = self.findMax(root.left)
            if leftMax.val > root.val:
                leftFlag = True
        
        rightMin = 1
        if root.right != None:
            rightMin = self.findMin(root.right)
            if rightMin.val < root.val:
                rightFlag = True
        
        if leftFlag==True and rightFlag==True:
            self.swapVal(leftMax, rightMin)
        elif leftFlag==True:
            self.swapVal(root, leftMax)
        elif rightFlag == True:
            self.swapVal(root, rightMin)
        else:
            if root.left != None:
                self.recoverTree(root.left)
            if root.right != None:
                self.recoverTree(root.right)
        return root
            
    def swapVal(self, a, b):
        temp = a.val
        a.val = b.val
        b.val = temp
    
    def findMax(self, root):
        if root == None:
            return None
        ans = root
        if root.left != None:
            left = self.findMax(root.left)
            if ans.val < left.val:
                ans = left
                
        if root.right != None:
            right = self.findMax(root.right)
            if ans.val < right.val:
                ans = right
        return ans
        
    def findMin(self, root):
        if root == None:
            return None
        
        ans = root
        if root.left != None:
            left = self.findMin(root.left)
            if ans.val > left.val:
                ans = left
                
        if root.right != None:
            right = self.findMin(root.right)
            if ans.val > right.val:
                ans = right
        return ans