add leetcode: offer-56.1-56.2

Author: CodeWater404

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

@@ -75,16 +75,17 @@ public static void main(String[] args) throws IOException {
         // System.out.println( str.length );
         for (int i = 0; i < n; i++) a[i] = toInt(str[i]);
 
-
+        // 递增的队列，输出最小值
         for (int i = 0; i < n; i++) {
   /*首先判断当前队头元素还是不是在窗口的内部，如果不在的话就要删掉
          i此时是窗口右侧的端点，i - k + 1得到的是窗口左侧的端点，这样就可以判断
          此时队列的头部时候还在窗口内
          */
             if (hh <= tt && q[hh] < i - k + 1) hh++;
             //当队列不空，并且队尾元素比当前要加入进来的元素大，那就把他删掉
+//            （对于递增队列来说，其实是把较小的值插到队列的前面。所以队尾大于当前元素，队尾指针减减）
             while (hh <= tt && a[q[tt]] >= a[i]) tt--;
-            // a的下标存储进队列
+            // a的下标存储进队列（到这一步就会把最小的入队）-----这里不用判断hh<= tt因为tt最多减到-1
             q[++tt] = i;
 
             //当窗口满足k个数时，才输出最小值
@@ -95,12 +96,15 @@ public static void main(String[] args) throws IOException {
         // 这里要记得重新初始化队列长度
         hh = 0;
         tt = -1;
+        //递减队列，输出最大值
         for (int i = 0; i < n; i++) {
             if (hh <= tt && q[hh] < i - k + 1) hh++;
             //当队列不空，并且队尾元素比当前要加入进来的元素小，那就把他删掉
+            //            （对于递减队列来说，其实是把较大的值插到队列的前面）
             while (hh <= tt && a[q[tt]] <= a[i]) tt--;
             q[++tt] = i;
 
+//            满足有k个窗口的时候，直接输出队头即可
             if (i >= k - 1) System.out.print(a[q[hh]] + " ");
         }
 

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

@@ -35,6 +35,7 @@ public class _830MonotoneStack {
     public static int tt = 0;
     public static int n;
 
+    //==========================可以覆盖最近比当前数较大的，所以是单调栈============================
     public static void main(String[] args) throws IOException {
         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
         String[] str = br.readLine().split(" ");
@@ -53,7 +54,7 @@ public static void main(String[] args) throws IOException {
                 // 否则输出栈顶元素
                 System.out.print(stk[tt] + " ");
             }
-            // 然后把当前元素记录到找中
+            // 然后把当前元素记录到栈中（这一步其实就已经覆盖栈中最小大于当前数的了）
             stk[++tt] = x;
             // 遍历的变量加加
             i++;

Algorithm/src/offer/_55_1TheDepthOfTheBinaryTree.java

@@ -23,7 +23,7 @@ class Solution {
         public int maxDepth(TreeNode root) {
             if( root == null ) return 0;
 //            queue本层结点， temp下一层结点
-            List<TreeNode> queue = new LinkedList<>(){{ add(root); }} , temp;
+            List<TreeNode> queue = new LinkedList<TreeNode>(){{ add(root); }} , temp;
             int res = 0;
             while( queue.size() != 0 ){
                 temp = new LinkedList<>();

Algorithm/src/offer/_56_1_NumberOfNumbersInTheArray.java

@@ -0,0 +1,31 @@
+package offer;
+
+/**
+ * @author ： CodeWater
+ * @create ：2022-07-14-14:31
+ * @Function Description ：56.1数组中数字出现的次数
+ */
+public class _56_1_NumberOfNumbersInTheArray {
+    class Solution {
+        public int[] singleNumbers(int[] nums) {
+            // xy记录只出现一次的数字
+            int x = 0 , y = 0 , n = 0 , m = 1;
+            // 异或一遍之后，n就是两个只出现一次的异或值，其余出现两次的抵消了
+            for( int num : nums ){
+                n ^= num;
+            }
+            // 通过与运算从右向左循环判断，可 获取整数x⊕y 首位 1 ，记录于 m 中
+            while( (n & m) == 0 )
+                m <<= 1;
+            //把xy分离出来 
+            for( int num : nums ){
+                // 跟m相与等于1为一组，说明是其中一个
+                if( (num & m) != 0 ) x ^= num;
+                    // 等于0另外一组，是另外一个。        其余出现两次的会在异或过程中抵消
+                else y ^= num;
+            }
+
+            return new int[]{x , y};
+        }
+    }
+}

Algorithm/src/offer/_56_2_NumberOfNumbersInTheArray.java

@@ -0,0 +1,38 @@
+package offer;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author ： CodeWater
+ * @create ：2022-07-14-14:51
+ * @Function Description ：56.2 数组中数字出现的次数
+ */
+public class _56_2_NumberOfNumbersInTheArray {
+    //==========================位运算============================
+    class Solution {
+        public int singleNumber(int[] nums) {
+            int ones = 0 , twos = 0;
+            for( int num : nums ){
+                ones = ones ^ num & ~twos;
+                twos = twos ^ num & ~ones;
+            }
+            return ones;
+        }
+    }
+    
+    //==========================hashmap============================
+    class Solution2 {
+        public int singleNumber(int[] nums) {
+            Map<Integer , Integer> map = new HashMap<>();
+            for( int i = 0 ; i < nums.length ; i++ ){
+                if( map.containsKey(nums[i]) ) map.put( nums[i] , map.get(nums[i]) + 1 );
+                else map.put(nums[i] , 1 );
+            }
+            for( Map.Entry<Integer , Integer>  entry : map.entrySet() ){
+                if( entry.getValue() == 1 ) return entry.getKey();
+            }
+            return -1;
+        }
+    }
+}