leetcode 树

1.构建树

• 用前序和中序建树105
• 用后序和中序建树106
• 数组构建BST 108
• 链表构建BST 109

2.树的遍历

• 前序 144
• 中序 94
• 后序 145
• 层次 102 103 107

3.树的属性

• 求深度 104
• 是否平衡是平衡树 110
• 最小深度 111

4.BST树

• 判断BST是否合法 98
• 恢复BST 99
• BST实现迭代：173（用到某一遍历）

 

 

98 判断BST是否合法 98

Given a binary tree, determine if it is a valid binary search tree (BST).

Assume a BST is defined as follows:

The left subtree of a node contains only nodes with keys less than the node's key.
The right subtree of a node contains only nodes with keys greater than the node's key.
Both the left and right subtrees must also be binary search trees.

Example 1:
Input:
2
/ \
1 3
Output: true

Example 2:

    5
   / \
  1   4
     / \
    3   6
Output: false
Explanation: The input is: [5,1,4,null,null,3,6]. The root node's value
             is 5 but its right child's value is 4.

 

• Solution:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode* root) {
       TreeNode* amin=nullptr;  //记录最小值节点
       TreeNode* amax=nullptr;  //记录最大值节点
    

        if(root)
            return search(root,amin,amax); //DP调用
        return true; 
    }
    bool search(TreeNode* root,TreeNode* & amin,TreeNode* & amax)
    {
        TreeNode* a1min=nullptr;
        TreeNode* a1max=nullptr;
        TreeNode* a2min=nullptr;
        TreeNode* a2max=nullptr;
        bool b1,b2;
        if(root){
           
            if(root->left)  //如果有左子树
                b1=search(root->left,a1min,a1max);
            else
            {
                b1=true;
            }
            if(root->right)  //如果有右子树
                b2=search(root->right,a2min,a2max);
            else
            {
                b2=true;
            }
            if(b1&&b2){     
                if((!a1max)&&(!a2min))   //如果没左右子树
                {    
                     amin=root;
                     amax=root;
                     return true;
                }
                if((!a1max)&&(a2min))   //如果没左子树
                {
                    
                    if((root->val < a2min->val))
                    {
                        amin=root;   //记录最min值
                        amax=a2max;   //记录最max值
                        return true;
                     }
                    else
                        return false;
                    
                }
                
                if((!a2min)&&(a1max))  //如果没右子树
                {
                    
                    if((root->val > a1max->val))
                    {
                        amin=a1min;   //记录最min值
                        amax=root;    //记录最大值
                        return true;
                     }
                    else
                        return false;
                    
                }
                
                //如果左右子树都存在
                if(((a2min)&&(root->val < a2min->val))&&(a1max)&&((root->val >a1max->val)))
                {
                    amin=a1min;   //记录最小值
                    amax=a2max;   //记录最大值
                    return true;
                }
                else
                {
                    return false;
                }
                    
            }
            else
                return false;  
        }
        else
        {
                 return true;
        }
        
    }
};