Merge pull request geekxh#25 from geekxh/feature/0817_refactor

Feature/0817 refactor

Author: geekxh

README.md

@@ -1,12 +1,9 @@
 # 和小浩学算法
 
-English version repo and Gitbook is on [english branch](https://github.com/geekxh/hello-algorithm/tree/english).Star
-! Star! Star!
-
-> 本项目于 2020.7.22 位于 github 日总榜第一！截图留念！(还没有助力的，右上角快来个 star )
-
-> [![图片展示失败，点击查看](https://www.geekxh.com/mark.png)](https://www.geekxh.com/mark.png)
-
+<div align="center">
+    <a href="https://www.geekxh.com"><img src="https://www.geekxh.com/logo_tmp.png" width="250px"></a>
+</div>
+  
 ## 简介
 
 > [![图片展示失败，点击查看](https://www.geekxh.com/book.png)](https://www.geekxh.com/book.png)

剑指 Offer 100 天/03_01_DuplicationInArray/README.md

@@ -0,0 +1,72 @@
+## 找出数组中重复的数字
+
+### 题目描述
+在一个长度为 `n` 的数组里的所有数字都在 `0` 到 `n-1` 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。例如，如果输入长度为 `7` 的数组 `{2, 3, 1, 0, 2, 5, 3}`，那么对应的输出是重复的数字 `2` 或者 `3`。
+
+
+### 解法
+#### 解法一
+排序后，顺序扫描，判断是否有重复，时间复杂度为 `O(n²)`。
+
+#### 解法二
+利用哈希表，遍历数组，如果哈希表中没有该元素，则存入哈希表中，否则返回重复的元素。时间复杂度为 `O(n)`，空间复杂度为 `O(n)`。
+
+#### 解法三
+长度为 `n`，元素的数值范围也为 `n`，如果没有重复元素，那么数组每个下标对应的值与下标相等。
+
+从头到尾遍历数组，当扫描到下标 `i` 的数字 `nums[i]`：
+- 如果等于 `i`，继续向下扫描；
+- 如果不等于 `i`，拿它与第 `nums[i]` 个数进行比较，如果相等，说明有重复值，返回 `nums[i]`。如果不相等，就把第 `i` 个数 和第 `nums[i]` 个数交换。重复这个比较交换的过程。
+
+此算法时间复杂度为 `O(n)`，因为每个元素最多只要两次交换，就能确定位置。空间复杂度为 `O(1)`。
+
+```java
+
+/**
+ * @author Anonymous
+ * @since 2019/10/27
+ */
+
+public class Solution {
+    /**
+     * 查找数组中的重复元素
+     * @param numbers 数组
+     * @param length 数组长度
+     * @param duplication duplication[0]存储重复元素
+     * @return boolean
+     */
+    public boolean duplicate(int[] numbers, int length, int[] duplication) {
+        if (numbers == null || length < 1) {
+            return false;
+        }
+        for (int e : numbers) {
+            if (e >= length) {
+                return false;
+            }
+        }
+
+        for (int i = 0; i < length; ++i) {
+            while (numbers[i] != i) {
+                if (numbers[i] == numbers[numbers[i]]) {
+                    duplication[0] = numbers[i];
+                    return true;
+                }
+                swap(numbers, i, numbers[i]);
+            }
+        }
+
+        return false;
+    }
+
+    private void swap(int[] numbers, int i, int j) {
+        int t = numbers[i];
+        numbers[i] = numbers[j];
+        numbers[j] = t;
+    }
+}
+```
+
+### 测试用例
+1. 长度为 n 的数组中包含一个或多个重复的数字；
+2. 数组中不包含重复的数字；
+3. 无效测试输入用例（输入空指针；长度为 n 的数组中包含 0~n-1 之外的数字）。

剑指 Offer 100 天/03_01_DuplicationInArray/Solution.java

@@ -0,0 +1,43 @@
+
+/**
+ * @author Anonymous
+ * @since 2019/10/27
+ */
+
+public class Solution {
+    /**
+     * 查找数组中的重复元素
+     * @param numbers 数组
+     * @param length 数组长度
+     * @param duplication duplication[0]存储重复元素
+     * @return boolean
+     */
+    public boolean duplicate(int[] numbers, int length, int[] duplication) {
+        if (numbers == null || length < 1) {
+            return false;
+        }
+        for (int e : numbers) {
+            if (e >= length) {
+                return false;
+            }
+        }
+
+        for (int i = 0; i < length; ++i) {
+            while (numbers[i] != i) {
+                if (numbers[i] == numbers[numbers[i]]) {
+                    duplication[0] = numbers[i];
+                    return true;
+                }
+                swap(numbers, i, numbers[i]);
+            }
+        }
+
+        return false;
+    }
+
+    private void swap(int[] numbers, int i, int j) {
+        int t = numbers[i];
+        numbers[i] = numbers[j];
+        numbers[j] = t;
+    }
+}

剑指 Offer 100 天/03_02_DuplicationInArrayNoEdit/README.md

@@ -0,0 +1,86 @@
+## 不修改数组找出重复的数字
+
+### 题目描述
+在一个长度为 `n+1` 的数组里的所有数字都在 `1` 到 `n` 的范围内，所以数组中至少有一个数字是重复的。请找出数组中任意一个重复的数字，但不能修改输入的数组。例如，如果输入长度为 `8` 的数组 `{2, 3, 5, 4, 3, 2, 6, 7}`，那么对应的输出是重复的数字 `2` 或者 `3`。
+
+
+### 解法
+#### 解法一
+创建长度为 `n+1` 的辅助数组，把原数组的元素复制到辅助数组中。如果原数组被复制的数是 `m`，则放到辅助数组第 `m` 个位置。这样很容易找出重复元素。空间复杂度为 `O(n)`。
+
+#### 解法二
+数组元素的取值范围是 `[1, n]`，对该范围对半划分，分成 `[1, middle]`, `[middle+1, n]`。计算数组中有多少个(count)元素落在 `[1, middle]` 区间内，如果 count 大于 middle-1+1，那么说明这个范围内有重复元素，否则在另一个范围内。继续对这个范围对半划分，继续统计区间内元素数量。
+
+时间复杂度 `O(n * log n)`，空间复杂度 `O(1)`。
+
+注意，此方法无法找出所有重复的元素。
+
+```java
+/**
+ * @author Anonymous
+ * @since 2019/10/27
+ */
+
+public class Solution {
+    /**
+     * 不修改数组查找重复的元素，没有则返回-1
+     * @param numbers 数组
+     * @return 重复的元素
+     */
+    public int getDuplication(int[] numbers) {
+        if (numbers == null || numbers.length < 1) {
+            return -1;
+        }
+
+        int start = 1;
+        int end = numbers.length - 1;
+        while (end >= start) {
+            int middle = start + ((end - start) >> 1);
+
+            // 调用 log n 次
+            int count = countRange(numbers, start, middle);
+            if (start == end) {
+                if (count > 1) {
+                    return start;
+                }
+                break;
+            } else {
+                // 无法找出所有重复的数
+                if (count > (middle - start) + 1) {
+                    end = middle;
+                } else {
+                    start = middle + 1;
+                }
+            }
+        }
+        return -1;
+    }
+
+
+    /**
+     * 计算整个数组中有多少个数的取值在[start, end] 之间
+     * 时间复杂度 O(n)
+     * @param numbers 数组
+     * @param start 左边界
+     * @param end 右边界
+     * @return 数量
+     */
+    private int countRange(int[] numbers, int start, int end) {
+        if (numbers == null) {
+            return 0;
+        }
+        int count = 0;
+        for(int e : numbers) {
+            if (e >= start && e <= end) {
+                ++count;
+            }
+        }
+        return count;
+    }
+}
+```
+
+### 测试用例
+1. 长度为 n 的数组中包含一个或多个重复的数字；
+2. 数组中不包含重复的数字；
+3. 无效测试输入用例（输入空指针）。

剑指 Offer 100 天/03_02_DuplicationInArrayNoEdit/Solution.java

@@ -0,0 +1,62 @@
+/**
+ * @author Anonymous
+ * @since 2019/10/27
+ */
+
+public class Solution {
+    /**
+     * 不修改数组查找重复的元素，没有则返回-1
+     * @param numbers 数组
+     * @return 重复的元素
+     */
+    public int getDuplication(int[] numbers) {
+        if (numbers == null || numbers.length < 1) {
+            return -1;
+        }
+
+        int start = 1;
+        int end = numbers.length - 1;
+        while (end >= start) {
+            int middle = start + ((end - start) >> 1);
+
+            // 调用 log n 次
+            int count = countRange(numbers, start, middle);
+            if (start == end) {
+                if (count > 1) {
+                    return start;
+                }
+                break;
+            } else {
+                // 无法找出所有重复的数
+                if (count > (middle - start) + 1) {
+                    end = middle;
+                } else {
+                    start = middle + 1;
+                }
+            }
+        }
+        return -1;
+    }
+
+
+    /**
+     * 计算整个数组中有多少个数的取值在[start, end] 之间
+     * 时间复杂度 O(n)
+     * @param numbers 数组
+     * @param start 左边界
+     * @param end 右边界
+     * @return 数量
+     */
+    private int countRange(int[] numbers, int start, int end) {
+        if (numbers == null) {
+            return 0;
+        }
+        int count = 0;
+        for(int e : numbers) {
+            if (e >= start && e <= end) {
+                ++count;
+            }
+        }
+        return count;
+    }
+}

剑指 Offer 100 天/04_FindInPartiallySortedMatrix/README.md

@@ -0,0 +1,57 @@
+## 二维数组中的查找
+
+### 题目描述
+在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
+
+
+### 解法
+从二维数组的右上方开始查找：
+- 若元素值等于 `target`，返回 `true`；
+- 若元素值大于 `target`，砍掉这一列，即 `--j`；
+- 若元素值小于 `target`，砍掉这一行，即 `++i`。
+
+也可以从二维数组的左下方开始查找，以下代码使用左下方作为查找的起点。
+
+注意，不能选择左上方或者右下方的数字，因为这样无法缩小查找的范围。
+
+```java
+/**
+ * @author Anonymous
+ * @since 2019/10/27
+ */
+
+public class Solution {
+    /**
+     * 二维数组中的查找
+     * @param target 目标值
+     * @param array 二维数组
+     * @return boolean
+     */
+    public boolean find(int target, int[][] array) {
+        if (array == null) {
+            return false;
+        }
+        int rows = array.length;
+        int columns = array[0].length;
+        
+        int i = rows - 1;
+        int j = 0;
+        while (i >= 0 && j < columns) {
+            if (array[i][j] == target) {
+                return true;
+            }
+            if (array[i][j] < target) {
+                ++j;
+            } else {
+                --i;
+            }
+        }
+        return false;
+    }
+}
+```
+
+### 测试用例
+1. 二维数组中包含查找的数字（查找的数字是数组中的最大值和最小值；查找的数字介于数组中的最大值和最小值之间）；
+2. 二维数组中没有查找的数字（查找的数字大于/小于数组中的最大值；查找的数字在数组的最大值和最小值之间但数组中没有这个数字）；
+3. 特殊输入测试（输入空指针）。

剑指 Offer 100 天/04_FindInPartiallySortedMatrix/Solution.java

@@ -0,0 +1,34 @@
+/**
+ * @author Anonymous
+ * @since 2019/10/27
+ */
+
+public class Solution {
+    /**
+     * 二维数组中的查找
+     * @param target 目标值
+     * @param array 二维数组
+     * @return boolean
+     */
+    public boolean find(int target, int[][] array) {
+        if (array == null) {
+            return false;
+        }
+        int rows = array.length;
+        int columns = array[0].length;
+
+        int i = rows - 1;
+        int j = 0;
+        while (i >= 0 && j < columns) {
+            if (array[i][j] == target) {
+                return true;
+            }
+            if (array[i][j] < target) {
+                ++j;
+            } else {
+                --i;
+            }
+        }
+        return false;
+    }
+}