99. 恢复二叉搜索树(中序，递规非递规)

#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.

        """
        self.pre=None
        self.x=None
        self.y=None
       
        # def inorder(root):
        #     if root==None:
        #         return
        #     inorder(root.left)
        #     if self.pre!=None and self.pre.val>root.val:
        #         if self.x==None:
        #             self.x=self.pre
        #         self.y=root
        #     self.pre=root
        #     inorder(root.right)
        # inorder(root)
        stack=[]
        stack.append(root)
        self.cur=root
        while(stack):
            if self.cur.left!=None:
                stack.append(self.cur.left)
                self.cur=self.cur.left   
            else:
                node =stack.pop()
                if self.pre and self.pre.val>node.val :
                    if self.x==None:
                        self.x=self.pre
                    self.y=node
                if node.right:
                    stack.append(node.right)
                    self.cur=node.right
                self.pre=node
                    
        # print(self.x.val) 
        # print(self.y.val) 
        
        self.x.val,self.y.val=self.y.val,self.x.val

c++ 递规

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
        TreeNode * pre;
        TreeNode *x;
        TreeNode *y;
    void inorder(TreeNode *root){
        if (root==nullptr) return;
        inorder(root->left);
        if(pre!=nullptr && pre->val>root->val){
            if(x==nullptr) x=pre;
            y=root;
        }
        pre=root;
        inorder(root->right);
    }
    void recoverTree(TreeNode* root) {
        inorder(root);
        int tmp=x->val;
        x->val=y->val;
        y->val=tmp;
    }
};

c++ 非递规

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void recoverTree(TreeNode* root) {
        TreeNode * pre=nullptr;
        TreeNode *x=nullptr;
        TreeNode *y=nullptr;
        stack<TreeNode *> st;
        st.push(root);
        TreeNode *cur=root;
        while(!st.empty()){
            if (cur->left!=nullptr)
            {   st.push(cur->left);
                cur=cur->left;
                }
            else{
                TreeNode *node =st.top();
                st.pop();
                if (pre!=nullptr && pre->val> node->val){
                    if(x==nullptr) 
                        x=pre; 
                    y=node;
                }
                if (node->right){
                    st.push(node->right);
                    cur=node->right;
                }
                pre=node;
            }
        }
       
        int tmp=x->val;
        x->val=y->val;
        y->val=tmp;
    }
};