LeetCode98/99 验证二叉搜索树/恢复二叉搜索树

原题目

第一题

给定一个二叉树，判断其是否是一个有效的二叉搜索树。
假设一个二叉搜索树具有如下特征：
节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。
示例 1:

输入:

  2
 / \
1   3
输出: true

示例 2:

输入:

  5
 / \
1   4
   / \
  3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
根节点的值为 5 ，但是其右子节点值为 4 。

来源：力扣（LeetCode）
点击进入题目

第二题

二叉搜索树中的两个节点被错误地交换。
请在不改变其结构的情况下，恢复这棵树。
示例 1:

输入: [1,3,null,null,2]
   1
  /
 3
  \
   2
输出: [3,1,null,null,2]

   3
  /
 1
  \
   2
示例 2:

输入: [3,1,4,null,null,2]

  3
 / \
1   4
   /
  2
输出: [2,1,4,null,null,3]

  2
 / \
1   4
   /
  3
进阶:
使用 O(n) 空间复杂度的解法很容易实现。
你能想出一个只使用常数空间的解决方案吗？

来源：力扣（LeetCode）
点击进入题目

题目分析

第一题

方法一：找每个节点左子树最大值和右子树最小值，与其当前节点比较，左子树最大值要小于当前节点，右子树最小值要大于当前节点
方法二：确定每个节点所在的区间，先定义根节点的区间为负无穷到正无穷，然后不断的缩小区间，以当前节点为分界线，划分新区间，判断下一节点在不在区间内
方法三：将方法二改迭代dfs模拟2的前序遍历，bfs模拟层序遍历
方法四：用中序遍历比较前后两个值是否为递增，中序递归
方法无:方法四改迭代

第二题

方法一：按中序遍历将节点存入数组中，二叉搜索树的中序遍历是按从小到大排列的，所以如果有两个节点交换，如果是相邻节点则有一个前者小于后者的情况，如果交换的节点不相邻则有两个前者小于后者的情况，找到这两个节点，将两者的值进行交换即可
方法二：
1.根节点和左子树的某个数字交换 -> 由于根节点大于左子树中的所有数，所以交换后我们只要找左子树中最大的那个数，就是所交换的那个数
2.根节点和右子树的某个数字交换 -> 由于根节点小于右子树中的所有数，所以交换后我们只要在右子树中最小的那个数，就是所交换的那个数
3.左子树和右子树的两个数字交换 -> 找左子树中最大的数，右子树中最小的数，即对应两个交换的数
4.左子树中的两个数字交换
5.右子树中的两个数字交换
方法三：改进方法一：递归中序遍历，用一个变量存储中序遍历上一个节点，与当前节点比较，找到前者小于后者的节点，进行交换
放法四：栈版中序遍历，递归改迭代
方法五：Morris 版中序遍历：Morris中序遍历就是将一颗二叉树线索化，

完整代码

方法一：

bool isValidBST(struct TreeNode* root){
    if (root == NULL || root->left == NULL && root->right == NULL) {
        return true;
    }
    //左子树是否合法
    if (isValidBST(root->left)) {
        if (root->left != NULL) {
            int max = getMaxOfBST(root->left);//得到左子树中最大的数
            if (root->val <= max) { //相等的情况，代表有重复的数字
                return false;
            }
        }

    } else {
        return false;
    }

    //右子树是否合法
    if (isValidBST(root->right)) {
        if (root->right != NULL) {
            int min = getMinOfBST(root->right);//得到右子树中最小的数
            if (root->val >= min) { //相等的情况，代表有重复的数字
                return false;
            }
        }

    } else {
        return false;
    }
    return true;
}

int getMinOfBST(struct TreeNode *root) {
    int min = root->val;
    while (root != NULL) {
        if (root->val <= min) {
            min = root->val;
        }
        root = root->left;
    }
    return min;
}

int getMaxOfBST(struct TreeNode *root) {
    int max = root->val;
    while (root != NULL) {
        if (root->val >= max) {
            max = root->val;
        }
        root = root->right;
    }
    return max;
}

方法二：

bool getAns(struct TreeNode *root, long minVal, long maxVal)
{
    if(root==NULL)return true;
    if(root->val<=minVal||root->val>=maxVal)
    {
        return false;
    }
    return getAns(root->left,minVal,root->val)&&getAns(root->right,root->val,maxVal);
}

bool isValidBST(struct TreeNode* root){
    return getAns(root,LONG_MIN,LONG_MAX);
}

方法三：
dfs

typedef struct MyNode{
    struct TreeNode *root;
    long minVal;
    long maxVal;
}MyNode;

bool isValidBST(struct TreeNode* root){
    if(root==NULL)return true;
    MyNode stack[1000];
    int top=0;
    stack[top].root=root;
    stack[top].minVal=LONG_MIN;
    stack[top].maxVal=LONG_MAX;
    top++;
    while(top)
    {
        MyNode s=stack[--top];
        if(s.root->val<=s.minVal||s.root->val>=s.maxVal)return false;
        if(s.root->right)
        {
            stack[top].root=s.root->right;
            stack[top].minVal=s.root->val;
            stack[top].maxVal=s.maxVal;
            top++;
        }
        if(s.root->left)
        {
            stack[top].root=s.root->left;
            stack[top].minVal=s.minVal;
            stack[top].maxVal=s.root->val;
            top++;
        }
    }
    return true;
}

bfs

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
typedef struct MyNode{
    struct TreeNode *root;
    long minVal;
    long maxVal;
}MyNode;

bool isValidBST(struct TreeNode* root){
    if(root==NULL)return true;
    MyNode queue[1000];
    int front=0,rear=0;
    queue[rear].root=root;
    queue[rear].minVal=LONG_MIN;
    queue[rear].maxVal=LONG_MAX;
    rear++;
    while(front!=rear)
    {
        MyNode s=queue[front];
        front=(front+1)%1000;
        if(s.root->val<=s.minVal||s.root->val>=s.maxVal)return false;
        if(s.root->left)
        {
            queue[rear].root=s.root->left;
            queue[rear].minVal=s.minVal;
            queue[rear].maxVal=s.root->val;
            rear=(rear+1)%1000;
        }
        if(s.root->right)
        {
            queue[rear].root=s.root->right;
            queue[rear].minVal=s.root->val;
            queue[rear].maxVal=s.maxVal;
            rear=(rear+1)%1000;
        }
    }
    return true;
}

方法四：

bool inorder(struct TreeNode *root,long *minVal){
    if(root==NULL)return true;
    if(inorder(root->left,minVal)==false)return false;
    if(root->val<=*minVal)return false;
    *minVal=root->val;
    return inorder(root->right,minVal);
}

bool isValidBST(struct TreeNode* root){
    long minVal=LONG_MIN;
    return inorder(root,&minVal);
}

迭代：

bool isValidBST(struct TreeNode* root){
    struct TreeNode *stack[1000];
    int top=0;
    struct TreeNode *pre=NULL;
    while(root||top)
    {
        while(root)
        {
            stack[top++]=root;
            root=root->left;
        }
        root=stack[--top];
        if(pre!=NULL&&root->val<=pre->val)
            return false;
        pre=root;
        root=root->right;
    }
    return true;
}

第二题

方法一：

 int resSize;
void traverse(struct TreeNode *root,struct TreeNode *list[])
{
    if(root->left)
    traverse(root->left,list);
    list[resSize++]=root;
    if(root->right)
    traverse(root->right,list);
}

void recoverTree(struct TreeNode* root){
    struct TreeNode *list[1000],*s1=NULL,*s2=NULL;
    resSize=0;
    traverse(root,list);
    for(int i=0;i<resSize-1;i++)
    {
        if(s1==NULL&&list[i]->val>list[i+1]->val)
        {
            s1=list[i];
            s2=list[i+1];
        }
        else if(list[i]->val>list[i+1]->val)
        {
            s2=list[i+1];
        }
    }
    int temp=s1->val;
    s1->val=s2->val;
    s2->val=temp;
    return root;
}

方法二：

struct TreeNode *getMinNode(struct TreeNode *root){
    if(root==NULL)return NULL;
    struct TreeNode *minLeft=getMinNode(root->left);
    struct TreeNode *minRight=getMinNode(root->right);
    struct TreeNode *min=root;
    if(minLeft!=NULL&&min->val>minLeft->val)
    {
        min=minLeft;
    }
    if(minRight!=NULL&&min->val>minRight->val)
    {
        min=minRight;
    }
    return min;
}

struct TreeNode *getMaxNode(struct TreeNode *root){
    if(root==NULL)return NULL;
    struct TreeNode *maxLeft=getMaxNode(root->left);
    struct TreeNode *maxRight=getMaxNode(root->right);
    struct TreeNode *max=root;
    if(maxLeft!=NULL&&max->val<maxLeft->val)
    {
        max=maxLeft;
    }
    if(maxRight!=NULL&&max->val<maxRight->val)
    {
        max=maxRight;
    }
    return max;
}

void swap(int *a,int *b){
    int temp=*a;
    *a=*b;
    *b=temp;
}

void recoverTree(struct TreeNode* root){
    if(root==NULL)return;
    struct TreeNode *maxLeft=getMaxNode(root->left);
    struct TreeNode *minRight=getMinNode(root->right);
    if(minRight!=NULL&&maxLeft!=NULL)
    {
        if(minRight->val<root->val&&maxLeft->val>root->val)
        {
            swap(&minRight->val,&maxLeft->val);
        }
    }
    
    if(minRight!=NULL){
        if(minRight->val<root->val)
        {
            swap(&minRight->val,&root->val);
        }
    }
    
    if(maxLeft!=NULL)
    {
        if(maxLeft->val>root->val)
        {
            swap(&maxLeft->val,&root->val);
        }
    }
    
    recoverTree(root->left);
    recoverTree(root->right);
}

方法三：

struct TreeNode *pre,*firstNode,*secondNode;
void inorderTraversal(struct TreeNode *root){
    if(root==NULL)return;
    inorderTraversal(root->left);
    if(pre!=NULL&&pre->val>root->val)
    {
        if(firstNode==NULL){
            firstNode=pre;
            secondNode=root;
        }
        else
        {
            secondNode=root;
        }
    }
    pre=root;
    inorderTraversal(root->right);
}

void swap(int *a,int *b){
    int temp=*a;
    *a=*b;
    *b=temp;
}

void recoverTree(struct TreeNode* root){
    pre=firstNode=secondNode=NULL;
    inorderTraversal(root);
    swap(&firstNode->val,&secondNode->val);
}

方法四：

struct TreeNode *pre,*firstNode,*secondNode;

void swap(int *a,int *b){
    int temp=*a;
    *a=*b;
    *b=temp;
}

void inorderTraversal(struct TreeNode *root){
    if(root==NULL)return NULL;
    struct TreeNode *stack[1000];
    int top=0;
    while(root!=NULL||top!=0)
    {
        while(root!=NULL)
        {
            stack[top++]=root;
            root=root->left;
        }
        root=stack[--top];
        if(pre!=NULL&&root->val<pre->val)
        {
            if(firstNode==NULL)
            {
                firstNode=pre;
                secondNode=root;
            }
            else
            {
                secondNode=root;
            }
        }
        pre=root;
        root=root->right;
    }
}

void recoverTree(struct TreeNode* root){
    pre=firstNode=secondNode=NULL;
    inorderTraversal(root);
    swap(&firstNode->val,&secondNode->val);
}

方法五：

struct TreeNode *pre_new,*firstNode,*secondNode;

void swap(int *a,int *b){
    int temp=*a;
    *a=*b;
    *b=temp;
}

void inorderTraversal(struct TreeNode *root){
    struct TreeNode *cur=root,*pre;
    while(cur!=NULL)
    {//情况一
        if(cur->left==NULL)
        {
            /**********************************************/
            if(pre_new!=NULL&&cur->val<pre_new->val)
            {
                if(firstNode==NULL)
                {
                    firstNode=pre_new;
                    secondNode=cur;
                }
                else
                {
                    secondNode=cur;
                }
            }
            pre_new=cur;
            /***********************************************/
            cur=cur->right;
        }
        else
        {//找左子树最右节点
            pre=cur->left;
            while(pre->right!=NULL&&pre->right!=cur)
            {
                pre=pre->right;
            }
            
            //情况2.1
            if(pre->right==NULL)
            {
                pre->right=cur;
                cur=cur->left;
            }
            //情况2,2
            if(pre->right==cur)
            {
                pre->right=NULL;//恢复为null
                /****************************************/
                if(pre_new!=NULL&&cur->val<pre_new->val)
                    {
                        if(firstNode==NULL)
                        {
                            firstNode=pre_new;
                            secondNode=cur;
                        }
                        else
                        {
                            secondNode=cur;
                        }
                    }
                    pre_new=cur;
                /****************************************/
                    cur=cur->right;
            }
        }
    }
}

void recoverTree(struct TreeNode* root){
    pre_new=firstNode=secondNode=NULL;
    inorderTraversal(root);
    swap(&firstNode->val,&secondNode->val);
}