add leetcode: offer-16

Author: CodeWater404

Algorithm/src/offer/_16NumbericalInteger.java

@@ -0,0 +1,29 @@
+package offer;
+
+/**
+ * @author ： CodeWater
+ * @create ：2022-07-12-20:59
+ * @Function Description ：16.数值的整数次方
+ */
+public class _16NumbericalInteger {
+    class Solution {
+        public double myPow(double x, int n) {
+            if( x == 0 ) return 0;
+            /*Java 代码中 int32 变量n∈[−2147483648,2147483647] ，因此当 n = -2147483648 时执行 
+            n = -n会因越界而赋值出错。解决方法是先将 n 存入 long 变量 b ，后面用 b 操作即可。
+             */
+            long b = n;
+            double res = 1.0;
+            if( b < 0 ){
+                x = 1 / x ;
+                b = -b;
+            }
+            while( b > 0 ){
+                if( (b & 1) == 1 ) res *= x;
+                x *= x;
+                b >>= 1;
+            }
+            return res;
+        }
+    }
+}

Algorithm/src/offer/_7BuildTree.java

@@ -15,6 +15,18 @@ public class _7BuildTree {
     //    键为结点元素值；值为结点下标
     private Map<Integer, Integer> indexMap;
 
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        int n = preorder.length;
+        // 构造哈希映射，帮助我们快速定位根节点
+        indexMap = new HashMap<Integer, Integer>();
+        for (int i = 0; i < n; i++) {
+//            把数组值当做键；下标当做值；这样后面求左子树结点数可以
+            indexMap.put(inorder[i], i);
+        }
+//        传入的参数是先序和后序的下标；其实也就相当于一段范围内二叉树的范围
+        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
+    }
+    
     //    按照的层次遍历序列输出的；参数都是下标索引，这样好理解
     public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
 //        超出范围，空
@@ -40,19 +52,45 @@ public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorder_left, in
         return root;
     }
 
-    public TreeNode buildTree(int[] preorder, int[] inorder) {
-        int n = preorder.length;
-        // 构造哈希映射，帮助我们快速定位根节点
-        indexMap = new HashMap<Integer, Integer>();
-        for (int i = 0; i < n; i++) {
-//            把数组值当做键；下标当做值；这样后面求左子树结点数可以
-            indexMap.put(inorder[i], i);
-        }
-//        传入的参数是先序和后序的下标；其实也就相当于一段范围内二叉树的范围
-        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
-    }
 
+    //==========================另外一种============================
+    /**
+     * Definition for a binary tree node.
+     * public class TreeNode {
+     *     int val;
+     *     TreeNode left;
+     *     TreeNode right;
+     *     TreeNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        // 声明成员变量，方便在递归创建时使用
+        int[] preorder ;
+        // 键是结点值  ，  值是结点在中序中的下标。 方便在创建过程中确定左右子树范围
+        Map<Integer , Integer> dic = new HashMap<>();
+        public TreeNode buildTree(int[] preorder, int[] inorder) {
+            this.preorder = preorder;
+            for( int i = 0 ; i < inorder.length ; i++ ){
+                dic.put( inorder[i] , i );
+            }
+            // 初始从root开始（0），范围是是整个中序范围
+            return recursion( 0 , 0 , inorder.length - 1 );
+        }
 
+        // 从前序中确定根结点root，从中序中确定左右子树的范围（left,right）。 （root，left，right都是数组中的下标）
+        public TreeNode recursion( int root , int left , int right ){
+            // 左子树下标超过右子树，递归结束
+            if( left > right ) return null;
+            // 找到划分左右子树的根结点
+            TreeNode node = new TreeNode( preorder[root] );
+            // 找到根结点在先序中的下标
+            int i = dic.get( preorder[root] );
+            // 递归查找左右子树的根结点，同时创捷左右指针
+            node.left = recursion( root + 1 , left , i - 1 );
+            node.right = recursion( root + i - left + 1 , i + 1 , right );
+            return node;
+        }
+    }
 }
 
 class TreeNode {