【LeetCode热题100】打卡第41天：二叉树的最近公共祖先&除自身以外数组的乘积

【LeetCode热题100】打卡第41天：二叉树的最近公共祖先&除自身以外数组的乘积

⛅前言

大家好，我是知识汲取者，欢迎来到我的LeetCode热题100刷题专栏！

精选 100 道力扣（LeetCode）上最热门的题目，适合初识算法与数据结构的新手和想要在短时间内高效提升的人，熟练掌握这 100 道题，你就已经具备了在代码世界通行的基本能力。在此专栏中，我们将会涵盖各种类型的算法题目，包括但不限于数组、链表、树、字典树、图、排序、搜索、动态规划等等，并会提供详细的解题思路以及Java代码实现。如果你也想刷题，不断提升自己，就请加入我们吧！QQ群号：827302436。我们共同监督打卡，一起学习，一起进步。

博客主页💖：知识汲取者的博客

LeetCode热题100专栏🚀：LeetCode热题100

Gitee地址📁：知识汲取者 (aghp) - Gitee.com

题目来源📢：LeetCode 热题 100 - 学习计划 - 力扣（LeetCode）全球极客挚爱的技术成长平台

PS：作者水平有限，如有错误或描述不当的地方，恳请及时告诉作者，作者将不胜感激

二叉树的最近公共祖先

🔒题目

原题链接：236.二叉树的最近公共祖先

🔑题解

• 解法一：DFS

  算法思路：

  1. 通过DFS遍历左右子树，判断目标节点当前节点的左子树还是右子树
  2. 如果当前节点在左子树，则将左节点更细为当前根节点；如果当前节点在右子树，同理
  3. 不断执行1和2，可以不断缩小树的范围，最终可以得到 p 和 q 的最近公共祖先节点

  class Solution {
      public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
          if (root.val == p.val || root.val == q.val) {
              // p或q为根节点，则公共祖先节点为根节点
              return root;
          }
          if (find(root.left, p.val) && find(root.left, q.val)) {
              // p、q都在左子树，则公共祖先节点在左子树
              return lowestCommonAncestor(root.left, p, q);
          }
          if (find(root.right, p.val) && find(root.right, q.val)) {
              // p、q都在右子树，则公共祖先节点在右子树
              return lowestCommonAncestor(root.right, p, q);
          }
          // p、q在根节点左右两侧，则公共祖先节点为根节点
          return root;
      }
  
      /**
       * DFS寻找目标值
       * @param cur 当前遍历的节点
       * @param target 目标值
       * @return
       */
      private boolean find(TreeNode cur, int target) {
          if (cur == null) {
              // 当前节点下已无节点，说明这条路径上没有目标值，直接返回false
              return false;
          }
          if (cur.val == target) {
              // 当前节点就是目标节点，直接返回true
              return true;
          }
          // 遍历当前节点左右子树
          return find(cur.left, target) || find(cur.right, target);
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n)$，递归调用发生在每个子树上，而每个子树的大小不超过原始树的大小。因此，递归调用的时间复杂度可以表示为 $T(N)=2T(N/2)+O(1)$，其中 N 是树的大小。根据主定理，这个递归关系的时间复杂度是 O(N)。
  • 空间复杂度：最坏$O(n)$，最好$O(logn)$

  其中 $n$ 为树节点的个数

  代码优化：时间优化

  上面的解法中，我们每次都需要通过DFS去判断目标节点在左子树还是右子树，这个操作是重复的，我们没必每次去重复性的判断，因为我们已经直到了，目标节点p和q无非就三种情况：

  1. p和q同时在左子树
  2. p和q同时在右子树
  3. p和q在左右两侧

  当我们找到p或q时，就直接返回对应的节点即可，这样就能够减少一层递归，从而避免了很多重复性的判断，整体而言是自底向上不断递归寻找目标节点，而前面我们是自上而下寻找目标节点

  本题解参考Krahets

  

  PS：此图也转自 Krahets，如有侵权或不当之处恳请及时告知，笔者立马删除

  class Solution {
      public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
          if (root == null || root.val == p.val || root.val == q.val) {
              // 递归终止条件: 未找到目标节点 或 找到目标节点
              return root;
          }
          TreeNode left = lowestCommonAncestor(root.left, p, q);
          TreeNode right = lowestCommonAncestor(root.right, p, q);
          if (right == null){
              // p、q都在左子树，则返回左节点
              return left;
          }
          if (left == null){
              // p、q都在右子树，则返回右节点
              return right;
          }
          // p、q在根节点左右两侧，则返回当前节点
          return root;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n)$，递归调用发生在每个子树上，而每个子树的大小不超过原始树的大小。因此，递归调用的时间复杂度可以表示为 $T(N)=T(N/2)+O(1)$，其中 N 是树的大小。根据主定理，这个递归关系的时间复杂度是 O(N)。
  • 空间复杂度：最坏$O(n)$，最好$O(logn)$

  其中 $n$ 为树节点的个数

除自身以外数组的乘积

🔒题目

原题链接：238.除自身以外数组的乘积

🔑题解

• 解法一：暴力（超时，22个示例数据过了19个）

  class Solution {
      public int[] productExceptSelf(int[] nums) {
          int[] product = new int[nums.length];
          for (int i = 0; i < nums.length; i++) {
              int t = 1;
              for (int j = 0; j < nums.length; j++) {
                  if (i != j) {
                      t *= nums[j];
                  }
              }
              product[i] = t;
          }
          return product;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n^2)$
  • 空间复杂度：$O(n)$

  其中 $n$ 为数组中元素的个数

• 解法二：用除法

  能够达到100%，但是题目禁止使用，这里写一下，锻炼一下逻辑能力，写算法题我感觉重要的不是结果，而是过程，过程大于结果，并不是说我能够默写除答案就说我会了，重在理解和思路

  class Solution {
      public int[] productExceptSelf(int[] nums) {
          int[] product = new int[nums.length];
          // 记录所有非0元素的乘积
          int allProduct = 1;
          // 记录0出现的次数
          int count = 0;
          // 记录出现0的位置
          int index = 0;
          for (int i = 0; i < nums.length; i++) {
              if (nums[i] == 0) {
                  count++;
                  index = i;
                  if (count > 1) {
                      // 出现两个0，直接结束遍历
                      break;
                  }
                  continue;
              }
              allProduct *= nums[i];
          }
          if (count > 1){
              // 0的出现次数大于1，则product中所有元素都是0（默认就是0）
              return product;
          }
          if (count == 1){
              // 0的出现次数等于1，则只有0对应元素的位置有值，其它位置都是0
              product[index] = allProduct;
              return product;
          }
          // 0没有出现，则当前元素为总的乘积除以当前元素
          for (int i = 0; i <nums.length; i++) {
              product[i] = allProduct/nums[i];
          }
          return product;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n)$
  • 空间复杂度：$O(n)$

  其中 $n$ 为数组中元素的个数

  代码优化：这里还可以优化一下，直接将空间复杂度降低至$O(1)$

  class Solution {
      public int[] productExceptSelf(int[] nums) {
          int allProduct = 1;
          int count = 0;
          int index = 0;
          for (int i = 0; i < nums.length; i++) {
              if (nums[i] == 0) {
                  count++;
                  index = i;
                  if (count > 1) {
                      break;
                  }
                  continue;
              }
              allProduct *= nums[i];
          }
          if (count > 1) {
              Arrays.fill(nums, 0);
              return nums;
          }
          if (count == 1) {
              Arrays.fill(nums, 0);
              nums[index] = allProduct;
              return nums;
          }
          for (int i = 0; i < nums.length; i++) {
              nums[i] = allProduct / nums[i];
          }
          return nums;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n)$
  • 空间复杂度：$O(1)$

  其中 $n$ 为数组中元素的个数

• 解法三：动态规划（左右相乘）

  从解法二中，我们参悟到了，最后的结果无法三种情况

  1. 出现两个0，都为0
  2. 出现一个0，为0的位置有值，其它位置都是0
  3. 没有出现0，则所有位置都有值

  有值的情况，其实就是一种情况：当前元素左侧乘积 乘以 当前元素右侧乘积。分析到这里，我们可以惊讶的发现，其实前面三种情况都可以由这一种情况推导而出：

  1. 出现两个0，则所有元素的左右乘积至少会出现一个0，所以最后的结果一定都是0
  2. 出现一个0，非0位的左右乘积至少出现一个0，所以非0位都是0，而位0的位置左右肯定是不为0的，所以最后的结果为只有为0的位置有值，其它位置都是0
  3. 没有出现0，所有位置的左右乘积都不为0，那么肯定所有位置上都有值

  实现起来也是相当的简单，只需要使用两个数组，一个记录左侧乘积，一个记录右侧乘积，至于两个数组的计算我们显然是可以使用动态规划，而这个状态转移方程也是相当So easy的，即：

  左侧乘积：leftProduct[i] = leftProduct[i - 1] * nums[i - 1]，表示第i个元素的左侧所有元素的乘积（不含i）

  右侧乘积：rightProduct[i] = nums[i + 1] * rightProduct[i + 1]，表示第i给元素的右侧所有元素的乘积（不含i）

  class Solution {
      public int[] productExceptSelf(int[] nums) {
          int len = nums.length;
          // 构建leftProduct
          int[] leftProduct = new int[len];
          leftProduct[0] = 1;
          for (int i = 1; i < len; i++) {
              leftProduct[i] = leftProduct[i - 1] * nums[i - 1];
          }
          // 构建rightProduct
          int[] rightProduct = new int[len];
          rightProduct[len - 1] = 1;
          for (int i = len - 2; i >= 0; i--) {
              rightProduct[i] = nums[i + 1] * rightProduct[i + 1];
          }
          // 计算每一个元素的左右乘积
          for (int i = 0; i < len; i++) {
              nums[i] = leftProduct[i] * rightProduct[i];
          }
          return nums;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n)$
  • 空间复杂度：$O(n)$

  其中 $n$ 为数组中元素的个数

  代码优化：空间优化

  我们可以发现，我们的状态转移方程只有前一个状态相关，所以我们在 遍历计算每一个元素的左右乘积 的时候，使用一个变量存储左侧乘积，这样就能够省掉一个leftProduct的内存空间开销，从而实现空间优化

  PS：这个优化操作，好像已经见过很多次了，在最大矩形面积、最大正方形面积、接雨水等DP题中都有讲解，至于是那一天打的卡，我也不太记得了，我也没有回头去找了，感兴趣的，可以自行去查看我对应的博客文章或者直接去LeetCode官网，去刷一下

  class Solution {
      public int[] productExceptSelf(int[] nums) {
          int len = nums.length;
          // 构建rightProduct
          int[] rightProduct = new int[len];
          rightProduct[len - 1] = 1;
          for (int i = len - 2; i >= 0; i--) {
              rightProduct[i] = nums[i + 1] * rightProduct[i + 1];
          }
          int leftProduct = nums[0];
          nums[0] = rightProduct[0];
          // 计算每一个元素的左右乘积
          for (int i = 1; i < len; i++) {
              int pre = nums[i];
              nums[i] = leftProduct * rightProduct[i];
              leftProduct *= pre;
          }
          return nums;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n)$
  • 空间复杂度：$O(n)$

  其中 $n$ 为数组中元素的个数