feat: update

Author: funnycoderstar

README.md

@@ -28,15 +28,13 @@ this is my blog
 
 ## 你可以在以下地方找到我
 
--   [aboutMe](http://wangyaxing.cn/)
+-   [aboutMe](http://ionestar.cn/)
 -   [github](https://github.com/funnycoderstar)
 -   [掘金](https://juejin.im/user/58c6a15544d9040068046025/activities)
 -   [segmentfault](https://segmentfault.com/u/funnycoderstar)
 -   [简书](https://www.jianshu.com/u/92fec6da2d1a)
 -   微信公众号: 牧码的星星
 
-![牧码的星星](https://cdn.suisuijiang.com/ImageMessage/5adad39555703565e79040fa_1583655092168.png)
-
 ## 100 天前端进阶计划
 
 每天一个知识点的原理解析+一道算法题或者一篇一类问题(算法)的总结。

docs/.vuepress/config.js

@@ -12,7 +12,6 @@ const SortList = GeneratorMenu('/algorithm/排序/', ['冒泡排序', '快速排
 
 const linkList = GeneratorMenu('/algorithm/链表/', [
     '合并两个有序链表',
-    '反转链表',
     '回文链表',
     '倒数第K个节点',
     '找出链表的中间节点',
@@ -94,8 +93,9 @@ module.exports = {
     base: '/blog/',
     title: '前端学习总结',
     description: '前端学习总结',
+    // plugins: ['autobar'],
     // theme: 'vuepress-theme-lemon',
-    head: [['link', { rel: 'icon', href: 'https://cdn.wangyaxing.cn/icon-128x128.png' }]],
+    head: [['link', { rel: 'icon', href: 'https://cdn.ionestar.cn/icon-128x128.png' }]],
     themeConfig: {
         sidebarDepth: 2,
         lastUpdated: 'Last Updated',
@@ -132,13 +132,47 @@ module.exports = {
                 {
                     title: '链表',
                     collapsable: true,
-                    children: linkList,
+                    children: [
+                        ...linkList,
+                        ['/algorithm/链表/反转链表/反转链表', '反转链表'],
+                        ['/algorithm/链表/反转链表/92. 反转链表 II', '92. 反转链表 II'],
+                        ['/algorithm/链表/反转链表/25. K 个一组翻转链表', '25. K 个一组翻转链表'],
+                    ],
+                },
+                {
+                    title: '字符串',
+                    collapsable: true,
+                    children: [['/algorithm/字符串/反转字符串', '反转字符串']],
                 },
                 {
                     title: '数组',
                     collapsable: true,
                     children: ArrayList,
                 },
+                {
+                    title: '优先队列',
+                    collapsable: true,
+                    children: [
+                        [
+                            '/algorithm/优先队列/703. 数据流中的第 K 大元素',
+                            '703. 数据流中的第 K 大元素',
+                        ],
+                        ['/algorithm/优先队列/滑动窗口的最大值', '滑动窗口的最大值'],
+                        ['/algorithm/优先队列/TopK', 'TopK'],
+                    ],
+                },
+                {
+                    title: '双指针',
+                    collapsable: true,
+                    children: [
+                        [
+                            '/algorithm/优先队列/703. 数据流中的第 K 大元素',
+                            '703. 数据流中的第 K 大元素',
+                        ],
+                        ['/algorithm/优先队列/滑动窗口的最大值', '滑动窗口的最大值'],
+                        ['/algorithm/优先队列/TopK', 'TopK'],
+                    ],
+                },
                 {
                     title: '数学',
                     collapsable: true,
@@ -232,6 +266,7 @@ module.exports = {
                         ['/jsCode/实现一个轮播图', '实现一个轮播图'],
                         ['/jsCode/放大镜效果', '放大镜效果'],
                         ['/jsCode/沙箱', '实现一个沙箱'],
+                        ['/jsCode/模版渲染', '模版渲染'],
                     ],
                 },
             ],

docs/algorithm/二分查找/0～n-1中缺失的数字.md

@@ -0,0 +1,45 @@
+### 剑指 Offer 53 - II. 0 ～ n-1 中缺失的数字
+
+一个长度为 n-1 的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围 0 ～ n-1 之内。在范围 0 ～ n-1 内的 n 个数字中有且只有一个数字不在该数组中，请找出这个数字。
+
+示例 1:
+
+输入: [0,1,3]
+输出: 2
+示例  2:
+
+输入: [0,1,2,3,4,5,6,7,9]
+输出: 8
+
+来源：力扣（LeetCode）
+链接：https://leetcode.cn/problems/que-shi-de-shu-zi-lcof
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+### 代码
+
+```js
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function(nums) {
+    /**
+     * 使用二分搜索
+     * 左数组：nums[i] == i
+     * 右数组：nums[i] !== i
+     * 结果：找到第一个 nums[i] !== i的 值，即查找左边界
+     */
+    let left = 0;
+    let right = nums.length - 1;
+    while (left <= right) {
+        let mid = Math.floor(left + (right - left) / 2);
+        if (nums[mid] === mid) {
+            // [mid + 1, right]区间查找
+            left = mid + 1;
+        } else {
+            right = mid - 1;
+        }
+    }
+    return left;
+};
+```

docs/algorithm/链表/25. K 个一组翻转链表.md renamed to docs/algorithm/二分查找/1011. 在 D 天内送达包裹的能力.md

@@ -0,0 +1,71 @@
+### 33. 搜索旋转排序数组
+
+整数数组 nums 按升序排列，数组中的值 互不相同 。
+
+在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
+
+给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
+
+示例 1：
+
+输入：nums = [4,5,6,7,0,1,2], target = 0
+输出：4
+示例 2：
+
+输入：nums = [4,5,6,7,0,1,2], target = 3
+输出：-1
+示例 3：
+
+输入：nums = [1], target = 0
+输出：-1
+
+### 代码
+
+关键词：排序数组，可以使用二分
+
+```js
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function(nums, target) {
+    let i = 0;
+    let j = nums.length - 1;
+    while (i <= j) {
+        let mid = Math.floor(i + (j - i) / 2);
+        if (nums[mid] === target) {
+            return mid;
+        }
+        if (nums[i] === target) {
+            return i;
+        }
+        if (nums[j] === target) {
+            return j;
+        }
+
+        if (nums[i] < nums[mid]) {
+            // 说明 i 到mid是有序的
+            if (nums[i] < target && target < nums[mid]) {
+                j = mid - 1;
+            } else {
+                i = mid + 1;
+            }
+        } else {
+            //  mid 到 j有序的
+            if (nums[mid] < target && target < nums[j]) {
+                i = mid + 1;
+            } else {
+                j = mid - 1;
+            }
+        }
+    }
+    return -1;
+};
+```
+
+相似题目：
+
+-   [剑指 Offer 11. 旋转数组的最小数字](https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/)
+-   「153. 寻找旋转排序数组中的最小值」
+-   「154. 寻找旋转排序数组中的最小值 II」

docs/algorithm/二分查找/33. 搜索旋转排序数组.md

@@ -61,7 +61,7 @@ function searchLeftBound(arr, target) {
     let left = 0;
     let right = arr.length - 1;
     while (left <= right) {
-        const mid = Math.floor((left + right) / 2);
+        let mid = Math.floor(left + (right - left) / 2);
         if (arr[mid] === target) {
             // 收缩右侧边界
             right = mid - 1;
@@ -71,7 +71,7 @@ function searchLeftBound(arr, target) {
             right = mid - 1;
         }
     }
-    // 检查出界情况
+    // 检查出界情况，大于右边界或者二不定于target
     if (left >= nums.length || nums[left] != target) {
         return -1;
     }
@@ -107,6 +107,10 @@ function searchRightBound(arr, target) {
 
 -   704. 二分查找
 -   34. 在排序数组中查找元素的第一个和最后一个位置
+-   剑指 Offer 53 - I. 在排序数组中查找数字 I
+-   剑指 Offer 53 - II. 0 ～ n-1 中缺失的数字，
+
+排序数组中的搜索问题，首先想到的是二分查找
 
 ## 二分查找的运用
 

docs/algorithm/链表/92. 反转链表 II.md renamed to docs/algorithm/二分查找/875. 爱吃香蕉的珂珂.md

@@ -0,0 +1,77 @@
+### 剑指 Offer 53 - I. 在排序数组中查找数字 I
+
+统计一个数字在排序数组中出现的次数。
+
+示例 1:
+
+输入: nums = [5,7,7,8,8,10], target = 8
+输出: 2
+示例  2:
+
+输入: nums = [5,7,7,8,8,10], target = 6
+输出: 0
+
+来源：力扣（LeetCode）
+链接：https://leetcode.cn/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+
+### 思路解析
+
+关键词：排序数组，可以使用二分查找。
+所以该题可以转换为求排序数组的左边界 left，和右边界 right，最后结果为 right - left + 1。
+
+```js
+// 寻找左边界
+function findTargetLeft(nums, target) {
+    let left = 0;
+    let right = nums.length - 1;
+    while (left <= right) {
+        let mid = Math.floor(left + (right - left) / 2);
+        if (nums[mid] === target) {
+            right = mid - 1;
+        } else if (nums[mid] < target) {
+            left = mid + 1;
+        } else if (nums[mid] > target) {
+            right = mid - 1;
+        }
+    }
+    // 返回值的处理逻辑，判断是否超出边界
+    if (left >= nums.length || nums[left] !== target) {
+        return -1;
+    }
+    return left;
+}
+// 寻找右边界
+function findTargetRight(nums, target) {
+    let left = 0;
+    let right = nums.length - 1;
+    while (left <= right) {
+        let mid = Math.floor(left + (right - left) / 2);
+        if (nums[mid] === target) {
+            left = mid + 1;
+        } else if (nums[mid] < target) {
+            left = mid + 1;
+        } else if (nums[mid] > target) {
+            right = mid - 1;
+        }
+    }
+    // 返回值的处理逻辑，判断是否超出边界
+    if (right < 0 || nums[right] !== target) {
+        return -1;
+    }
+    return right;
+}
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function(nums, target) {
+    const left = findTargetLeft(nums, target);
+    const right = findTargetRight(nums, target);
+    if (left === -1 && right === -1) {
+        return 0;
+    }
+    return right - left + 1;
+};
+```

docs/algorithm/其他/二分查找.md renamed to docs/algorithm/二分查找/二分查找.md

@@ -0,0 +1,52 @@
+## 887. 鸡蛋掉落
+
+给你 k 枚相同的鸡蛋，并可以使用一栋从第 1 层到第 n 层共有 n 层楼的建筑。
+
+已知存在楼层 f ，满足 0 <= f <= n ，任何从 高于 f 的楼层落下的鸡蛋都会碎，从 f 楼层或比它低的楼层落下的鸡蛋都不会破。
+
+每次操作，你可以取一枚没有碎的鸡蛋并把它从任一楼层 x 扔下（满足 1 <= x <= n）。如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。
+
+请你计算并返回要确定 f 确切的值 的 最小操作次数 是多少？
+
+示例 1：
+
+输入：k = 1, n = 2
+输出：2
+解释：
+鸡蛋从 1 楼掉落。如果它碎了，肯定能得出 f = 0 。
+否则，鸡蛋从 2 楼掉落。如果它碎了，肯定能得出 f = 1 。
+如果它没碎，那么肯定能得出 f = 2 。
+因此，在最坏的情况下我们需要移动 2 次以确定 f 是多少。
+示例 2：
+
+输入：k = 2, n = 6
+输出：3
+
+## 代码
+
+动态规划+二分查找
+
+```js
+/**
+ * @param {number} k
+ * @param {number} n
+ * @return {number}
+ */
+var superEggDrop = function(k, n) {
+    // dp[i][j]表示一共j个鸡蛋，从i层扔下去
+    let dp = new Array(k + 1).fill(0).map(() => new Array(n + 1).fill(0));
+    let j = 0;
+    while (dp[k][j] < n) {
+        j++;
+        for (let i = 1; i <= k; i++) {
+            // 状态：dp[i][j] 有i个鸡蛋，j次扔鸡蛋的测得的最多楼层
+            // 转移方程：dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j] + 1
+            // dp[i - 1][j - 1] 表示碎了，dp[i - 1][j]，表示没碎
+            dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1] + 1;
+        }
+    }
+    return j;
+};
+```
+
+[]()

docs/algorithm/二分查找/在排序数组中查找数字 I.md

@@ -50,3 +50,25 @@
     -   最长公共子序列
     -   最长递增子序列
     -   编辑距离
+
+算法 - Algorithms
+
+-   排序算法：快速排序、归并排序、计数排序
+-   搜索算法：回溯、递归、剪枝技巧
+-   图论：最短路、最小生成树、网络流建模
+-   动态规划：背包问题、最长子序列、计数问题
+-   基础技巧：分治、倍增、二分、贪心
+
+数据结构 - Data Structures
+
+-   数组与链表：单 / 双向链表、跳舞链
+-   栈与队列
+-   树与图：最近公共祖先、并查集
+-   哈希表
+-   堆：大 / 小根堆、可并堆
+-   字符串：字典树、后缀树
+
+作者：力扣 (LeetCode)
+链接：https://leetcode.cn/leetbook/read/top-interview-questions/xm8xw2/
+来源：力扣（LeetCode）
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。