leetcode题解(2)

调用level会遍历一遍所有的子节点，原因在于level没有记忆性，当输入为同一个节点时，level进行完整的计算


一种改进方法，可以考虑利用动态规划的思想，将TreeNode指针作为键，高度作为值，一旦发现节点已经被计算过，直接返回结果，这样level函数对每个节点只计算一次，另一种更为巧妙地方法是，isBalanced返回当前节点的高度，用-1表示树不平衡，将结果自底向上传递，并且确保每个节点只被计算一次复杂度O(n)

int isBalancedHelper(TreeNode * root){
    if(root==NULL){
       return 0;
    }
    int left Height = isBalanced(root->left);
    if(leftHeight== -1){
        return -1;
    }
    int rightHeight = isBalanced(root->right);
    if(rightHeight==-1){  
        return -1;
    }
     
    if(abs(leftHeight-rightHeight)>1){
      return -1;
   }
    return max(leftHeight,rightHeight)+1;
}
bool isBalanced(TreeNode *root){
     if(isBalancedHelper(root)==-1){
         return -1;
     }else{
        return 1;
   }
}

判断一颗二叉树是否是二叉搜索树

bool helper(TreeNode *root,int min,int max){
    if(!root)
       return true;
    if((root->val<min || (root->val==INT_MAX && root->right == NULL))
      && (root->val > min || (root->val == INT_MIN &&root->left==NULL))
    && helper(root->left,min,root->val) &&
    helpfer(root->right,root->val,max))
    return 1;
return false;
}
bool isValidBST(TreeNode * root){
    return helper(root,INT_MIN,INT_MAX);
}

判断2是否是1的子树

bool subTree(TreeNode *root1,TreeNode *root2){
    if(root2 ==NULL){
       return true;
   }
    if(root1==NULL){
       return false;
    }
     if(root->val==root2->val){
         if(match(root1,root2){
            return true;
          }
     }
   return isSubTree(root1->left,root2) || isSubTree(root1->right,root2);
}
bool match(TreeNode *root1,TreeNode *root2){
   if(root1==NULL&&root2==NULL){ 
     return true;
   }
    if(root1==NULL||root2==NULL){
     return false;
   }
   if(root1->val!=root2->val){  
    return false;
    }
    return match(root1->left,root2->left)&&match(root1->right,root2->right);
}

获取一个二叉树的路径，其和等于一个给定的值

void pathSumHelper(vector<int> path,vector<vector<int>> &answer,TreeNode * root,int sum){
    if(root==NULL)
       return;
    path.push_back(root->val);
    if(root->val==sum)
         answer.push_back(path);
   pathSumHelper(path,answer,root-left,sum-root->val);
   pathSumHelper(path,answer,root->right,sum-root->val);
}

vector<vector<int>> pathSum(TreeNode*root,int sum){
    vector<int> path;
   vector<vector<int>> result;
    pathSumHelper(path,result,root,sum);
   return result;
}

变形1 获取一个二叉树中的所有路径，总是从根和叶子的末端开始，路径之和等于一个给定的值

void pathSumHelper(vector<int> path,vector<vector<int>> &answer,TreeNode * root,int sum){
    if(root==NULL)
       return;
    path.push_back(root->val);
    //if(root->val==sum)
    //这里相比前一道题目做了修改
    if(root->left==NULL&&root->right==NULL&&root->val==sum){
         answer.push_back(path);
} 
   pathSumHelper(path,answer,root-left,sum-root->val);
   pathSumHelper(path,answer,root->right,sum-root->val);
    //这里加一句
    path.pop_back();
}

vector<vector<int>> pathSum(TreeNode*root,int sum){
    vector<int> path;
   vector<vector<int>> result;
    pathSumHelper(path,result,root,sum);
   return result;
}

获取一个二叉树中的所有路径，总任何一个节点到另一个更深层次的节点，路径之和应该等于一个给定的值
反向搜索，找到和为满足的开始点。

void pathSumHelper(vector<int> path,vector<vector<int>> &answer,
TreeNode *root,int sum){
   if(root==NULL)
     return ;
   path.push_back(root->val);
   int tempSum = sum;
    vector<int> partialPath;
   for(int i =(int)path.size()-1;i>=0;i--){
     tempSum -=path[i];
       partialPath.push_back(path[i]);
     if(tempSum ==0 ){ 
      answer.push_back(partialPath);
     }
   }
   pathSumHelper(path,answer,root->left,sum);
 pathSumHelper(path,answer,root->right,sum-root->val);
}
vector<vector<int>> pathSum(TreeNode*root,int sum){
    vector<int> path;
   vector<vector<int>> result;
    pathSumHelper(path,result,root,sum);
   return result;
}