add leetcode: offer-64-68.1-68.2

Author: CodeWater404

Algorithm/src/acwing/basic/chapter2/_3302ExpressionEvaluation.java

@@ -36,11 +36,11 @@
  */
 public class _3302ExpressionEvaluation {
     /*流程：
-   1.从左至右遍历表达式，数字和（直接压入对应的栈，只不过数字需要另外的判别是不是多位数，如
+   1.从左至右遍历表达式，数字和（直接压入对应的num栈，只不过数字需要另外的判别是不是多位数，如
    983，这个时候就需要把这个983从字符串中处理出来。
    2.如果是）说明已经有一个（）里面的表达式子部分可以处理出结果，一直进行运算，直到对应的（
-   出现，并把它弹出栈，运算结果存入数字栈。
-   3.如果是运算符，只有在运算符栈不空并且栈顶不是（，栈顶优先级大于当前运算符优先级，才进行
+   出现，并把它弹出栈，运算结果存入数字栈num。
+   3.如果是运算符，只有在运算符栈op不空并且栈顶不是（，栈顶优先级大于当前运算符优先级，才进行
    运算；当后两种情况不满足时退出while，压入运算符栈
    4. 最后检查运算符栈是否还有元素
    5.输出数字栈栈顶，即结果
@@ -85,7 +85,7 @@ else if (c == ')') {
             } else {
 // 第四种情况，运算符，运算符栈不空并且栈顶不是（，栈顶优先级大于当前运算符优先级，就进行运算
                 while (!op.isEmpty() && op.peek() != '(' && pr.get(op.peek()) >= pr.get(c))
-                    eval();
+                    eval();  //先处理op栈顶优先级大的运算
                 //直接操作到上面三个条件中的后两个条件为止，然后把这个运算符压入运算符栈
                 op.push(c);
             }

Algorithm/src/offer/_55_1TheDepthOfTheBinaryTree.java

@@ -57,4 +57,77 @@ public int maxDepth(TreeNode root) {
             return Math.max( maxDepth(root.left) , maxDepth(root.right) ) + 1;
         }
     }
+    
+    /*
+    * public class HashMapInitializeDemo {
+
+    /1**
+     * HashMap初始化 使用匿名内部类的方式
+     *1/
+    public static void initialize() {
+        HashMap<String, Integer> map = new HashMap<String, Integer>() {{
+            put("a", 1);
+            put("b", 2);
+            put("c", 3);
+        }};
+    }
+
+    static class Num {
+
+        public Num() {
+
+            System.out.println("initialize num");
+        }
+
+        void put() {
+            System.out.println("put something");
+
+        }
+    }
+
+    public static void main(String[] args) {
+        //这是匿名内部类的写法，第一个大括号是代表类，第二个大括号代表匿名内部类的初始化代码块。 
+        这种语法表示该匿名内部类继承了Num类，还有我们经常使用匿名内部类来作为接口的实现类，作为方法入参。
+     
+
+        // 1.匿名内部类不能是抽象类，因为系统在创建匿名内部类时，会立即创建匿名内部类的对象，因此不允许
+        将匿名内部类定义为抽象类。
+     
+
+        // 2.匿名内部类不能定义构造器（Constructor），由于匿名内部类没有类名，所以无法定义构造器，但匿名
+        构造类可以定义初始化块，可以通过实例初始化块来完成构造函数需要完成的部分。
+     
+        Num num = new Num() {{
+            put();
+        }};
+
+        Num num1 = new Num() {{
+            System.out.println("create num");
+        }};
+
+        List<String> list = new LinkedList<String>() {{
+            add("a");
+            add("b");
+        }};
+        System.out.println(list.get(0));
+
+        List<String> list1 = new LinkedListAnonymity<>();
+        System.out.println(list1.get(0));
+    }
+
+    /1**
+     * LinkedListAnonymity
+     * new LinkedListAnonymity<>(); 等同于HashMapInitializeDemo中的匿名类  List<String> list = new LinkedList<String>(){{add("a");add("b");}};
+     * @param <T>
+     *1/
+    static class LinkedListAnonymity<T> extends LinkedList<T> {
+    public LinkedListAnonymity() {
+    add((T) "a");
+    add((T) "b");
+    }
+    }
+
+    }
+
+     */
 }

Algorithm/src/offer/_64Request.java

@@ -0,0 +1,23 @@
+package offer;
+
+/**
+ * @author ： CodeWater
+ * @create ：2022-07-11-17:32
+ * @Function Description ：64. 求1+2+…+n
+ */
+public class _64Request {
+    class Solution {
+        int res = 0 ;
+        public int sumNums(int n) {
+        /*需要实现 “当 n = 1n=1 时终止递归” 的需求，可通过短路效应实现.
+        因为正常情况下递归需要结束条件用到if，但是本题禁止。。。
+            当 n = 1 时 n > 1 不成立 ，此时 “短路” ，终止后续递归.
+            为构成语句，需加一个辅助布尔量 x ，否则会报错；其余并无别的意思
+        */
+            boolean x = n - 1 > 0 && sumNums( n - 1 ) > 0 ;
+            res += n ;
+            return res;
+        }
+
+    }
+}

Algorithm/src/offer/_68_1TheRecentPublicAncestorOfTheBinarySearchTree.java

@@ -0,0 +1,45 @@
+package offer;
+
+/**
+ * @author ： CodeWater
+ * @create ：2022-07-11-18:02
+ * @Function Description ： 68.1 二叉搜索树的最近公共祖先
+ */
+public class _68_1TheRecentPublicAncestorOfTheBinarySearchTree {
+    /**
+     * Definition for a binary tree node.
+     * public class TreeNode {
+     *     int val;
+     *     TreeNode left;
+     *     TreeNode right;
+     *     TreeNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        /*解题思路：
+        ① 树为 二叉搜索树 ，② 树的所有节点的值都是 唯一 的。根据以上条件，可方便地判断 p,q 与 root 的子树关系，即：
+    若 root.val < p.val ，则 p 在 root 右子树 中；
+    若 root.val > p.val ，则 p 在 root 左子树 中；
+    若 root.val = p.val ，则 p 和 root 指向 同一节点 。
+    
+        */
+        public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+            // 始终保持p结点的值小于q，方便下面while遍历时不用写判断
+            if( p.val > q.val ){
+                TreeNode temp = p ;
+                p = q;
+                q = temp;
+            }
+            while( root != null ){
+                // pq都在root结点的左子树
+                if( root.val > q.val )
+                    root = root.left;
+                    // pq都在root结点的右子树
+                else if( root.val < p.val )
+                    root = root.right;
+                else break;//找到
+            }
+            return root;
+        }
+    }
+}

Algorithm/src/offer/_68_2TheRecentPublicAncestorOfTheBinaryTree.java

@@ -0,0 +1,46 @@
+package offer;
+
+/**
+ * @author ： CodeWater
+ * @create ：2022-07-12-1:04
+ * @Function Description ：68.2 二叉树的最近公共祖先
+ */
+public class _68_2TheRecentPublicAncestorOfTheBinaryTree {
+    /**
+     * Definition for a binary tree node.
+     * public class TreeNode {
+     *     int val;
+     *     TreeNode left;
+     *     TreeNode right;
+     *     TreeNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        // 本题是一个普通的二叉树，不是二叉搜索树！！！！！
+        public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        /*
+       1. 当 left 和 right 同时为空 ：说明 root 的左 / 右子树中都不包含p,q ，返回 null ；
+2.当 left 和 right 同时不为空 ：说明 p,q 分列在 root 的 异侧 （分别在 左 / 右子树），因此 root为最近公共祖先，返回 rootroot ；
+3.当 left 为空 ，right 不为空 ：p,q 都不在root 的左子树中，直接返回right 。具体可分为两种情况：
+    3.1p,q 其中一个在 root 的 右子树 中，此时 right 指向 pp（假设为 p ）；
+    3.2p,q 两节点都在 root的 右子树 中，此时的 right 指向 最近公共祖先节点 ；
+4.当 left 不为空 ， right 为空 ：与情况 3. 同理；
+观察发现， 情况 1. 可合并至 3. 和 4. 内，详见文章末尾代码。
+
+
+        */
+            // 先序遍历
+            // 终止条件：当越过叶节点，则直接返回 null ；当 root 等于 p, qp,q ，则直接返回 root ；
+
+            if( root == null || root == p || root == q ) return root;
+            TreeNode left = lowestCommonAncestor( root.left , p , q );
+            TreeNode right = lowestCommonAncestor( root.right , p , q );
+            // 左树空，pq在右子树中
+            if( left == null ) return right ;
+            // 右树空，pq在左子树中
+            if( right == null ) return left;
+            return root;
+        }
+
+    }
+}