leecode更新

2022-09-22 13:19:38 +08:00 · 2022-09-22 13:19:38 +08:00 · 39fc3ed9a8
parent b812f6384d
commit 39fc3ed9a8
2 changed files with 393 additions and 0 deletions
--- a/Leecode/src/main/java/com/markilue/leecode/tree/MaxDepth.java
+++ b/Leecode/src/main/java/com/markilue/leecode/tree/MaxDepth.java
@ -0,0 +1,214 @@
+package com.markilue.leecode.tree;
+
+import org.junit.Test;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * @BelongsProject: Leecode
+ * @BelongsPackage: com.markilue.leecode.tree
+ * @Author: dingjiawen
+ * @CreateTime: 2022-09-22  10:23
+ * @Description: TODO  力扣104题:二叉树的最大深度：
+ * 给定一个二叉树，找出其最大深度。
+ * 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
+ * 说明: 叶子节点是指没有子节点的节点。
+ * @Version: 1.0
+ */
+public class MaxDepth {
+
+    @Test
+    public void test() {
+
+        TreeNode root = new TreeNode(3);
+        TreeNode TreeNode2 = new TreeNode(9);
+        TreeNode TreeNode3 = new TreeNode(20);
+//        TreeNode TreeNode4 = new TreeNode(4);
+//        TreeNode TreeNode5 = new TreeNode(5);
+        TreeNode TreeNode6 = new TreeNode(15);
+        TreeNode TreeNode7 = new TreeNode(7);
+
+        root.setRight(TreeNode3);
+        root.setLeft(TreeNode2);
+//        TreeNode2.setLeft(TreeNode4);
+//        TreeNode2.setRight(TreeNode5);
+        TreeNode3.setRight(TreeNode7);
+        TreeNode3.setLeft(TreeNode6);
+
+        System.out.println(maxDepth(root));
+
+    }
+
+    @Test
+    public void test1() {
+
+        TreeNode root = new TreeNode(3);
+        TreeNode TreeNode2 = new TreeNode(9);
+        TreeNode TreeNode3 = new TreeNode(20);
+//        TreeNode TreeNode4 = new TreeNode(4);
+//        TreeNode TreeNode5 = new TreeNode(5);
+        TreeNode TreeNode6 = new TreeNode(15);
+        TreeNode TreeNode7 = new TreeNode(7);
+
+//        root.setRight(TreeNode3);
+//        root.setLeft(TreeNode2);
+//        TreeNode2.setLeft(TreeNode4);
+//        TreeNode2.setRight(TreeNode5);
+//        TreeNode3.setRight(TreeNode7);
+//        TreeNode3.setLeft(TreeNode6);
+
+        System.out.println(maxDepth(root));
+
+    }
+
+
+    @Test
+    public void test2(){
+        TreeNode root = new TreeNode(4);
+        TreeNode TreeNode2 = new TreeNode(2);
+        TreeNode TreeNode3 = new TreeNode(6);
+        TreeNode TreeNode4 = new TreeNode(1);
+        TreeNode TreeNode5 = new TreeNode(3);
+        TreeNode TreeNode6 = new TreeNode(5);
+
+        root.setLeft(TreeNode2);
+        root.setRight(TreeNode3);
+        TreeNode2.setLeft(TreeNode4);
+        TreeNode2.setRight(TreeNode5);
+        TreeNode3.setLeft(TreeNode6);
+
+        int integers = maxDepth2(root);
+
+        System.out.println(integers);
+
+    }
+
+
+
+    /**
+     * 自己思路递归法,传递当前深度，然后比较左右子树的深度
+     *  速度击败100%，内存击败39.53%
+     * @param root
+     * @return
+     */
+    public int maxDepth(TreeNode root) {
+
+        return deep(root,0);
+
+    }
+
+    public int deep(TreeNode root, int depth) {
+        if (root == null) {
+            return depth;
+        }
+        depth += 1;
+        int leftDepth = deep(root.left, depth);
+        int rightDepth = deep(root.right, depth);
+
+        return leftDepth > rightDepth ? leftDepth : rightDepth;
+
+
+    }
+
+
+    /**
+     * 不传深度的版本
+     * @param root
+     * @return
+     */
+    public int deep1(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        int leftDepth = deep1(root.left);
+        int rightDepth = deep1(root.right);
+
+        return (leftDepth > rightDepth ? leftDepth : rightDepth)+1;
+
+
+    }
+
+
+    /**
+     * 自己思路迭代法:可以使用栈的前序遍历或者Morris遍历来解决,这里尝试使用Morris遍历
+     * TODO 尚且有问题,Morris前序遍历写出来了，但是不知道depth在何时加，感觉很乱，不知何时用temp何时用depth
+     *
+     * @param root
+     * @return
+     */
+    public int maxDepth1(TreeNode root) {
+
+        if(root==null){
+            return 0;
+        }
+        int depth=1;
+        TreeNode node1=root;
+        TreeNode node2=null;
+
+        while (node1!=null){
+            node2=node1.left;
+            int tempDepth=depth;
+            if(node2!=null){
+                //找到回到node1的节点
+                while (node2.right!=null&&node2.right!=node1){
+                    node2=node2.right;
+                }
+
+                //判断上面是从什么条件出来的
+                if(node2.right==null){
+                    //从第一个条件出来的
+
+                    node2.right=node1;
+                    //放心将node1左移
+                    node1=node1.left;
+                    depth+=1;
+                }else {
+                    //node2已经遍历过了
+                    node2.right=null;
+                }
+            }else {
+                //左边遍历完了,往右移
+                node1=node1.right;
+            }
+
+
+
+        }
+
+        return depth;
+
+    }
+
+    /**
+     * 自己思路迭代法:可以使用层序遍历
+     * 速度击败19.47% 内存击败85.16%
+     * @param root
+     * @return
+     */
+    public int maxDepth2(TreeNode root) {
+
+        if(root==null){
+            return 0;
+        }
+
+        int depth=0;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+
+        while (queue.size()>0){
+            int size=queue.size();
+            depth+=1;
+            for (int i = 0; i < size; i++) {
+                TreeNode poll = queue.poll();
+                if(poll.left!=null)queue.offer(poll.left);
+                if(poll.right!= null)queue.offer(poll.right);
+            }
+        }
+        return depth;
+    }
+
+
+}
--- a/Leecode/src/main/java/com/markilue/leecode/tree/MinDepth.java
+++ b/Leecode/src/main/java/com/markilue/leecode/tree/MinDepth.java
@ -0,0 +1,179 @@
+package com.markilue.leecode.tree;
+
+import org.junit.Test;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * @BelongsProject: Leecode
+ * @BelongsPackage: com.markilue.leecode.tree
+ * @Author: dingjiawen
+ * @CreateTime: 2022-09-22  11:28
+ * @Description: TODO  力扣111题  二叉树的最小深度问题:
+ * 给定一个二叉树，找出其最小深度。
+ * 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
+ * 说明：叶子节点是指没有子节点的节点。
+ * 注意：深度是从根节点到最近叶子结点的最短路径上的节点数量。左右孩子都为空的节点才是叶子结点
+ * @Version: 1.0
+ */
+public class MinDepth {
+
+    @Test
+    public void test() {
+
+        TreeNode root = new TreeNode(3);
+        TreeNode TreeNode2 = new TreeNode(9);
+        TreeNode TreeNode3 = new TreeNode(20);
+//        TreeNode TreeNode4 = new TreeNode(4);
+//        TreeNode TreeNode5 = new TreeNode(5);
+        TreeNode TreeNode6 = new TreeNode(15);
+        TreeNode TreeNode7 = new TreeNode(7);
+
+        root.setRight(TreeNode3);
+        root.setLeft(TreeNode2);
+//        TreeNode2.setLeft(TreeNode4);
+//        TreeNode2.setRight(TreeNode5);
+        TreeNode3.setRight(TreeNode7);
+        TreeNode3.setLeft(TreeNode6);
+
+        System.out.println(minDepth1(root));
+
+    }
+
+    @Test
+    public void test1() {
+
+        TreeNode root = new TreeNode(3);
+        TreeNode TreeNode2 = new TreeNode(9);
+        TreeNode TreeNode3 = new TreeNode(20);
+//        TreeNode TreeNode4 = new TreeNode(4);
+//        TreeNode TreeNode5 = new TreeNode(5);
+        TreeNode TreeNode6 = new TreeNode(15);
+        TreeNode TreeNode7 = new TreeNode(7);
+
+//        root.setRight(TreeNode3);
+//        root.setLeft(TreeNode2);
+//        TreeNode2.setLeft(TreeNode4);
+//        TreeNode2.setRight(TreeNode5);
+//        TreeNode3.setRight(TreeNode7);
+//        TreeNode3.setLeft(TreeNode6);
+
+        System.out.println(minDepth1(root));
+
+    }
+
+    @Test
+    public void test2() {
+
+        TreeNode root = new TreeNode(2);
+        TreeNode TreeNode2 = new TreeNode(3);
+        TreeNode TreeNode3 = new TreeNode(4);
+        TreeNode TreeNode4 = new TreeNode(5);
+        TreeNode TreeNode5 = new TreeNode(6);
+//        TreeNode TreeNode6 = new TreeNode(15);
+//        TreeNode TreeNode7 = new TreeNode(7);
+
+//        root.setRight(TreeNode3);
+        root.setLeft(TreeNode2);
+        TreeNode2.setLeft(TreeNode3);
+        TreeNode3.setLeft(TreeNode4);
+        TreeNode4.setLeft(TreeNode5);
+//        TreeNode5.setLeft(TreeNode7);
+//        TreeNode2.setRight(TreeNode5);
+//        TreeNode3.setRight(TreeNode7);
+//        TreeNode3.setLeft(TreeNode7);
+
+        System.out.println(minDepth(root));
+
+    }
+
+
+    /**
+     * 自己思路递归法:由于必须是叶子节点才算完，所以需要将出来的条件变为判断当前节点是否还有子节点
+     * 速度击败66.79%，内存击败69.22%
+     * @param root
+     * @return
+     */
+    public int minDepth(TreeNode root) {
+
+        if (root == null) {
+            return 0;
+        }
+
+        return deep1(root);
+
+    }
+
+    public int deep(TreeNode node) {
+        if (node.left == null && node.right == null) {
+            return 1;
+        }
+
+        int deep1=Integer.MAX_VALUE;
+        int deep2=Integer.MAX_VALUE;
+        if(node.left!=null){
+            deep1 = deep(node.left);
+        }
+        if(node.right!=null){
+            deep2 = deep(node.right);
+        }
+
+
+        return (deep1 < deep2 ? deep1 : deep2) + 1;
+
+    }
+
+    /**
+     * 改进版:不需要全部遍历完,找到第一个叶子结点就可以return了
+     * 似乎没有改进:速度超过66.5%,内存超过37.25%
+     * @param node
+     * @return
+     */
+    public int deep1(TreeNode node) {
+        if (node.left != null && node.right != null) {
+            return Math.min(deep(node.left),deep(node.right))+1;
+        }else if(node.right != null){
+            return deep(node.right)+1;
+        }else if(node.left != null){
+            return deep(node.left)+1;
+        }else {
+            return 1;
+        }
+    }
+
+    /**
+     * 自己思路层序遍历:
+     * 速度击败66.79%，内存击败69.22%
+     * @param root
+     * @return
+     */
+    public int minDepth1(TreeNode root) {
+
+        if (root == null) {
+            return 0;
+        }
+
+        Queue<TreeNode> treeNodes = new LinkedList<>();
+        int depth=0;
+
+        treeNodes.offer(root);
+        while (!treeNodes.isEmpty()){
+            int size = treeNodes.size();
+            depth+=1;
+
+            for (int i = 0; i < size; i++) {
+                TreeNode poll = treeNodes.poll();
+                //层序遍历，找到的叶子结点一定是第一个叶子结点
+                if(poll.left==null&&poll.right==null){
+                    return depth;
+                }
+                if(poll.left!=null)treeNodes.offer(poll.left);
+                if(poll.right!=null)treeNodes.offer(poll.right);
+            }
+        }
+
+
+        return depth;
+    }
+}