auto commit

2020-05-27 00:44:06 +08:00
parent 15324cf9e7
commit afcfca0a9d
19 changed files with 150 additions and 321 deletions
@@ -1141,7 +1141,7 @@ System.out.println(InterfaceExample.x);

 使用接口：

- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
+- 需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Comparable 接口中的 compareTo() 方法；
 - 需要使用多重继承。

 使用抽象类：
@@ -521,7 +521,7 @@ public static final int value = 123;
 其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。

 <div data="补充为什么可以支持动态绑定 --> <--"></div>
-###  5. 初始化
+### 5. 初始化

 <div data="modify -->"></div>
 初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段是虚拟机执行类构造器 &lt;clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
@@ -1,5 +1,4 @@
 <!-- GFM-TOC -->
-* [0. 原理](#0-原理)
 * [1. 统计两个数的二进制表示有多少位不同](#1-统计两个数的二进制表示有多少位不同)
 * [2. 数组中唯一一个不重复的元素](#2-数组中唯一一个不重复的元素)
 * [3. 找出数组中缺失的那个数](#3-找出数组中缺失的那个数)
@@ -16,9 +15,7 @@
 <!-- GFM-TOC -->


-# 0. 原理
-
-**基本原理** 
+**基本原理**  

 0s 表示一串 0，1s 表示一串 1。

@@ -28,79 +25,23 @@ x ^ 1s = ~x     x & 1s = x      x | 1s = 1s
 x ^ x = 0       x & x = x       x | x = x
 ```

-利用 x ^ 1s = \~x 的特点，可以将一个数的位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。
+- 利用 x ^ 1s = \~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。
+- 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。
+- 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1。

-```
-1^1^2 = 2
-```
+位与运算技巧：

-利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。
+- n&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110100，减去 1 得到 10110011，这两个数相与得到 10110000。
+- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110100，-n 得到 01001100，相与得到 00000100。
+- n-n&(\~n+1) 去除 n 的位级表示中最高的那一位。

-```
-01011011 &
-00111100
--------
-00011000
-```
+移位运算：

-利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1。
+- \>\> n 为算术右移，相当于除以 2<sup>n</sup>；
+- \>\>\> n 为无符号右移，左边会补上 0。
+- &lt;&lt; n 为算术左移，相当于乘以 2<sup>n</sup>。

-```
-01011011 |
-00111100
--------
-01111111
-```
-
-**位与运算技巧** 
-
-n&(n-1) 去除 n 的位级表示中最低的那一位 1。例如对于二进制表示 01011011，减去 1 得到 01011010，这两个数相与得到 01011010。
-
-```
-01011011 &
-01011010
--------
-01011010
-```
-
-n&(-n) 得到 n 的位级表示中最低的那一位 1。-n 得到 n 的反码加 1，也就是 -n=\~n+1。例如对于二进制表示 10110100，-n 得到 01001100，相与得到 00000100。
-
-```
-10110100 &
-01001100
--------
-00000100
-```
-
-n-(n&(-n)) 则可以去除 n  的位级表示中最低的那一位 1，和 n&(n-1) 效果一样。
-
-**移位运算** 
-
-\>\> n 为算术右移，相当于除以 2<sup>n</sup>，例如 -7 >> 2 = -2。
-
-```
-11111111111111111111111111111001  >> 2
--------
-11111111111111111111111111111110
-```
-
-\>\>\> n 为无符号右移，左边会补上 0。例如 -7 >>> 2 = 1073741822。
-
-```
-11111111111111111111111111111001  >>> 2
--------
-00111111111111111111111111111111
-```
-
-&lt;&lt; n 为算术左移，相当于乘以 2<sup>n</sup>。-7 << 2 = -28。
-
-```
-11111111111111111111111111111001  << 2
--------
-11111111111111111111111111100100
-```
-
-**mask 计算**  
+** mask 计算**  

 要获取 111111111，将 0 取反即可，\~0。

@@ -34,7 +34,7 @@

 <div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/95903878-725b-4ed9-bded-bc4aae0792a9.jpg"/> </div><br>

-广度优先搜索一层一层地进行遍历，每层遍历都是以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。
+广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。

 第一层：

@@ -75,39 +75,33 @@
 题目描述：0 表示可以经过某个位置，求解从左上角到右下角的最短路径长度。

 ```java
-		public int shortestPathBinaryMatrix(int[][] grids) {
-        if (grids == null || grids.length == 0 || grids[0].length == 0) {
-            return -1;
-        }
-        int[][] direction = {{1, -1}, {1, 0}, {1, 1}, {0, -1}, {0, 1}, {-1, -1}, {-1, 0}, {-1, 1}};
-        int m = grids.length, n = grids[0].length;
-        Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
-        queue.add(new Pair<>(0, 0));
-        int pathLength = 0;
-        while (!queue.isEmpty()) {
-            int size = queue.size();
-            pathLength++;
-            while (size-- > 0) {
-                Pair<Integer, Integer> cur = queue.poll();
-                int cr = cur.getKey(), cc = cur.getValue();
-                if (grids[cr][cc] == 1) {
+public int shortestPathBinaryMatrix(int[][] grids) {
+    int[][] direction = {{1, -1}, {1, 0}, {1, 1}, {0, -1}, {0, 1}, {-1, -1}, {-1, 0}, {-1, 1}};
+    int m = grids.length, n = grids[0].length;
+    Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
+    queue.add(new Pair<>(0, 0));
+    int pathLength = 0;
+    while (!queue.isEmpty()) {
+        int size = queue.size();
+        pathLength++;
+        while (size-- > 0) {
+            Pair<Integer, Integer> cur = queue.poll();
+            int cr = cur.getKey(), cc = cur.getValue();
+            grids[cr][cc] = 1; // 标记
+            for (int[] d : direction) {
+                int nr = cr + d[0], nc = cc + d[1];
+                if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 1) {
                    continue;
                }
-                if (cr == m - 1 && cc == n - 1) {
-                    return pathLength;
-                }
-                grids[cr][cc] = 1; // 标记
-                for (int[] d : direction) {
-                    int nr = cr + d[0], nc = cc + d[1];
-                    if (nr < 0 || nr >= m || nc < 0 || nc >= n) {
-                        continue;
-                    }
-                    queue.add(new Pair<>(nr, nc));
+                if (nr == m - 1 && nc == n - 1) {
+                    return pathLength + 1;
                }
+                queue.add(new Pair<>(nr, nc));
            }
        }
-        return -1;
    }
+    return -1;
+}
 ```

 ## 2. 组成整数的最小平方数数量
@@ -827,7 +827,7 @@ https://leetcode.com/problems/rank-scores/description/
 | 2 | 4.2 | 2 | 2 |
 | 3 | 4.3 | 1 | 1 |

-使用连接操作找到某个 score 对应的大于等于其值的记录：
+使用连接操作找到某个 score 对应的大于其值的记录：

 ```sql
 SELECT
@@ -890,7 +890,7 @@ ORDER BY
 | score | Rank |
 | :---: | :--: |
 |  4.2  |  1   |
-|  4.2  |  1   |
+|  4.2  |  2   |
 |  4.1  |  2   |

 连接情况如下：
@@ -1021,7 +1021,7 @@ g/re/p（globally search a regular expression and print)，使用正则表示式

 ```html
 $ grep [-acinv] [--color=auto] 搜寻字符串 filename
-c ： 统计匹配到行的个数
+-c ： 统计个数
 -i ： 忽略大小写
 -n ： 输出行号
 -v ： 反向选择，也就是显示出没有 搜寻字符串 内容的那一行
@@ -1039,7 +1039,7 @@ $ grep -n 'the' regular_express.txt
 18:google is the best tools for search keyword
 ```

-示例：正则表达式 a{m,n} 用来匹配字符 a m\~n 次，这里需要将 { 和 } 进行转义，因为它们在 shell 是有特殊意义的。
+示例：正则表达式 a{m,n} 用来匹配字符 a m\~n 次，这里需要将 { 和 } 进行转移，因为它们在 shell 是有特殊意义的。

 ```html
 $ grep -n 'a\{2,5\}' regular_express.txt
@@ -1,10 +1,3 @@
-# 前言
-
-题目来自《何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.》，刷题网站推荐：
-
- [牛客网](https://www.nowcoder.com/ta/coding-interviews?from=cyc_github)
- [Leetcode](https://leetcode-cn.com/problemset/lcof/)
-
 # 目录


@@ -85,6 +78,10 @@
 - [67. 把字符串转换成整数](67.%20把字符串转换成整数.md)
 - [68. 树中两个节点的最低公共祖先](68.%20树中两个节点的最低公共祖先.md)

+# 参考文献
+
+何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.
+



@@ -73,7 +73,6 @@
 ```

 <div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/eb859228-c0f2-4bce-910d-d9f76929352b.png"/> </div><br>
-
 ## 3. 最近未使用

 > NRU, Not Recently Used
@@ -89,7 +88,7 @@

 NRU 优先换出已经被修改的脏页面（R=0，M=1），而不是被频繁使用的干净页面（R=1，M=0）。

-##  4. 先进先出
+## 4. 先进先出

 > FIFO, First In First Out