leecode更新

Leecode/src/main/java/com/markilue/leecode/hot100/T98_FindUnsortedSubarray.java

@@ -0,0 +1,91 @@
+package com.markilue.leecode.hot100;
+
+import java.util.Arrays;
+
+/**
+ *@BelongsProject: Leecode
+ *@BelongsPackage: com.markilue.leecode.hot100
+ *@Author: markilue
+ *@CreateTime: 2023-04-11  12:47
+ *@Description:
+ * TODO  力扣581  最短无序连续子数组:
+ *   给你一个整数数组 nums ，你需要找出一个 连续子数组 ，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。
+ *   请你找出符合题意的 最短 子数组，并输出它的长度。
+ *@Version: 1.0
+ */
+public class T98_FindUnsortedSubarray {
+
+
+    /**
+     * 官方排序法:
+     * TODO 最短的思路:
+     *  本质上就是考虑把数组分为三段子数组:numsA,numsB,numsC ；当对numsB进行排序，整个数组就会变得有序
+     *  所以要找到最短的numsB,就是找到最大的numsA和numsC的长度之和
+     *  因此将数组排序与原数组对比，找到最长相同的前缀numsA和最长相同的后缀numsC,就可以最短numsB
+     *  时间复杂度O(nlogn)
+     *  时间击败36.47%  内存击败15.19%  6ms
+     * @param nums
+     * @return
+     */
+    public int findUnsortedSubarray(int[] nums) {
+        if (isSorted(nums)) {
+            return 0;
+        }
+        int[] numsSorted = new int[nums.length];
+        System.arraycopy(nums, 0, numsSorted, 0, nums.length);
+        Arrays.sort(numsSorted);
+        int left = 0;
+        while (nums[left] == numsSorted[left]) {
+            left++;
+        }
+        int right = nums.length - 1;
+        while (nums[right] == numsSorted[right]) {
+            right--;
+        }
+        return right - left + 1;
+    }
+
+    public boolean isSorted(int[] nums) {
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] < nums[i - 1]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+
+    /**
+     * 一次遍历:对于需要排序的优化:
+     * 时间复杂度O(n)
+     * 速度击败93.39%  内存击败68.96%  1ms
+     * @param nums
+     * @return
+     */
+    public int findUnsortedSubarray1(int[] nums) {
+        //2,6,4,8,10,9,15
+        //升序开始索引:0,2,5
+        //降序开始索引:1,4
+        int n = nums.length;
+        int maxn = Integer.MIN_VALUE, right = -1;
+        int minn = Integer.MAX_VALUE, left = -1;
+        for (int i = 0; i < n; i++) {
+            // 因此 从左到右  找最大值  这期间如果有值比最大值还要小 那么这个值就有可能是 中段的右边界
+            //因为升序的时候（左右段） 最大值一直在替换，所以最后一个小  它就是 中段的右边界
+            if (maxn > nums[i]) {
+                right = i;
+            } else {
+                maxn = nums[i];
+            }
+            //因此 从右到左  找最小值  这期间如果有值比最小值还要大 那么这个值就有可能是 中段的左边界
+            //因为降序的时候（左右段） 最小值一直在替换，所以最后一个大 它就是 中段的左边界
+            if (minn < nums[n - i - 1]) {
+                left = n - i - 1;
+            } else {
+                minn = nums[n - i - 1];
+            }
+        }
+        return right == -1 ? 0 : right - left + 1;
+
+    }
+}

Leecode/src/main/java/com/markilue/leecode/hot100/T99_MergeTrees.java

@@ -0,0 +1,40 @@
+package com.markilue.leecode.hot100;
+
+import com.markilue.leecode.tree.TreeNode;
+
+/**
+ *@BelongsProject: Leecode
+ *@BelongsPackage: com.markilue.leecode.hot100
+ *@Author: markilue
+ *@CreateTime: 2023-04-11  14:27
+ *@Description:
+ * TODO  力扣617  合并二叉树:
+ *   给你两棵二叉树： root1 和 root2 。
+ *   想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。
+ *   返回合并后的二叉树。
+ *   注意: 合并过程必须从两个树的根节点开始。
+ *@Version: 1.0
+ */
+public class T99_MergeTrees {
+
+    /**
+     * 递归法
+     * @param root1
+     * @param root2
+     * @return
+     */
+    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
+        if (root1 == null) {
+            return root2;
+        } else if (root2 == null) {
+            return root1;
+        }
+
+        //两者都不等于null
+        TreeNode root = new TreeNode(root1.val + root2.val);
+        root.left = mergeTrees(root1.left, root2.left);
+        root.right = mergeTrees(root1.right, root2.right);
+        return root;
+
+    }
+}