LeetCode刷题day16

算法打卡第十六天,今天你刷题了吗
😄😄😄😄😄😄😄😄😄😄
😃😃😃😃😃😃😃😃😃😃
💓💓💓大家一起来刷题!💓💓💓
😍😍😍😍😍😍😍😍😍😍
😘😘😘😘😘😘😘😘😘😘

​​226. 翻转二叉树​​

翻转一棵二叉树。

示例：

输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9
输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

方法一:递归

动图演示:

其实就是交换一下左右节点，然后再递归的交换左节点，右节点
根据动画图我们可以总结出递归的两个条件如下：

• 终止条件：当前节点为 null 时返回
• 交换当前节点的左右节点，再递归的交换当前节点的左节点，递归的交换当前节点的右节点

时间复杂度：每个元素都必须访问一次，所以是 O(n)
空间复杂度：最坏的情况下，需要存放 O(h) 个函数调用(h是树的高度)，所以是 O(h)

代码实现

//结束条件为左右都为空
TreeNode* invertTree(TreeNode* root) {
  if(root==NULL) {
    return root;
  }
  TreeNode* temp = root->left;
  root->left = root->right;
  root->right = temp;
  invertTree(root->left);
  invertTree(root->right);
  
  return root;

}

方法二:迭代

递归实现也就是深度优先遍历的方式，那么迭代对应的就是广度优先遍历。
广度优先遍历需要额外的数据结构–队列，来存放临时遍历到的元素。
深度优先遍历的特点是一竿子插到底，不行了再退回来继续；而广度优先遍历的特点是层层扫荡。
所以，我们需要先将根节点放入到队列中，然后不断的迭代队列中的元素。对当前元素调换其左右子树的位置，然后：

• 判断其左子树是否为空，不为空就放入队列中
• 判断其右子树是否为空，不为空就放入队列中

动态图如下：

代码实现

//迭代法bfs 
TreeNode* invertTree(TreeNode* root) {
  if(root==NULL){
    return root;
  }
  //将二叉树的节点逐层放到队列中,再跌倒处理队列中的元素
  queue<TreeNode*> Q;
  Q.push(root);
  while(!Q.empty()){
    TreeNode* node= Q.front();
    Q.pop();
    TreeNode* temp = node->left;
    node->left = node->right;
    node->right = temp;
    if(node->left!=NULL){
      Q.push(node->left);
    }
    if(node->right!=NULL){
      Q.push(node->right);
    }    
  } 
  return root;
}
}

​​112. 路径总和​​

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false

示例 3：

输入：root = [1,2], targetSum = 0
输出：false

方法一:递归

参考代码

//方法一:递归 
bool hasPathSum(TreeNode* root, int targetSum) {
  if(root==NULL){
    return false;//要么是根节点为null,要么不是叶子节点. 
  } 
  int sum = targetSum - root->val;
  //判断当前节点是否是叶子节点 
  if(root->left==NULL&&root->right==NULL){
    return sum==0;
  } 
  //如果不是叶子节点 ,则继续递归,判断左子树和右子树上面的叶子节点 
  return hasPathSum(root->left,sum)||hasPathSum(root->right,sum); 
}

方法二:dfs

方法二:dfs
bool hasPathSum(TreeNode* root, int targetSum) {
  return dfs(root,0,targetSum);
} 

bool dfs(TreeNode* root,int sum,int targetSum){
  if(root==NULL){//结束条件 
    return false;
  }
  sum += root->val;
  //判断是否是叶子节点
  if(root->left==NULL&&root->right==NULL){
    return sum==targetSum;
  } 
  return dfs(root->left,sum,targetSum)||dfs(root->right,sum,targetSum);
}

😜😜😜😜😜 大家卷起来! 😝😝😝😝😝