📚sort

Author: Jstarfish

docs/.DS_Store

@@ -213,6 +213,7 @@
   },
   "active": "e24a131a4a8c13f9",
   "lastOpenFiles": [
+    "interview/Ability-FAQ~.md",
     "data-structure-algorithms/algorithm/BFS.md",
     "data-structure-algorithms/algorithm/Untitled.md",
     "interview/Algorithm.md",
@@ -239,7 +240,6 @@
     "Untitled.md",
     "2024-08-05.md",
     "java/JVM/GC.md",
-    "interview/RPC-FAQ~.md",
     "data-structure-algorithms/algorithm",
     "data-structure-algorithms/未命名文件夹"
   ]

docs/.obsidian/workspace.json

@@ -69,19 +69,6 @@ public void reverseString(char[] s) {
 }
 ```
 
-简化一下
-
-```java
-public void reverseString(char[] s) {
-  int n = s.length;
-  for (int left = 0, right = n - 1; left < right; ++left, --right) {
-    char tmp = s[left];
-    s[left] = s[right];
-    s[right] = tmp;
-  }
-}
-```
-
 
 
 ### [两数之和 II - 输入有序数组](https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted/)
@@ -170,7 +157,7 @@ public List<List<Integer>> threeSum(int[] nums) {
                     //不要用成 if 判断，只跳过 1 条，还会有重复的，且需要再加上 l<r，以防死循环
                     while (l < r && nums[l] == nums[l + 1]) l++;
                     while (l < r && nums[r] == nums[r - 1]) r--;
-                    //移动指针
+                    //移动指针, 必须在去重后再移动
                     l++;
                     r--;
                 }
@@ -370,6 +357,8 @@ public boolean hasCycle(ListNode head) {
 
 
 
+
+
 ### [链表的中间结点](https://leetcode.cn/problems/middle-of-the-linked-list/)
 
 > 给定一个头结点为 `head` 的非空单链表，返回链表的中间结点。
@@ -629,20 +618,6 @@ public static double getMaxAverage(int[] nums, int k) {
 
 
 
-#### [字符串的排列（567）](https://leetcode.cn/problems/permutation-in-string/description/)
-
-> 给你两个字符串 `s1` 和 `s2` ，写一个函数来判断 `s2` 是否包含 `s1` 的排列。如果是，返回 `true` ；否则，返回 `false` 。
->
-> 换句话说，`s1` 的排列之一是 `s2` 的 **子串** 。
->
-> ```
-> 输入：s1 = "ab" s2 = "eidbaooo"
-> 输出：true
-> 解释：s2 包含 s1 的排列之一 ("ba").
-> ```
-
-
-
 ### 3.2 不定长度的滑动窗口
 
 #### [无重复字符的最长子串（3）](https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/)
@@ -720,7 +695,138 @@ int lengthOfLongestSubstring(String s) {
 > 输出："BANC"
 > ```
 
+思路：
 
+1. 我们在字符串 `S` 中使用双指针中的左右指针技巧，初始化 `left = right = 0`，把索引**左闭右开**区间 `[left, right)` 称为一个「窗口」。
+
+   > [!IMPORTANT]
+   >
+   > 为什么要「左闭右开」区间
+   >
+   > **理论上你可以设计两端都开或者两端都闭的区间，但设计为左闭右开区间是最方便处理的**。
+   >
+   > 因为这样初始化 `left = right = 0` 时区间 `[0, 0)` 中没有元素，但只要让 `right` 向右移动（扩大）一位，区间 `[0, 1)` 就包含一个元素 `0` 了。
+   >
+   > 如果你设置为两端都开的区间，那么让 `right` 向右移动一位后开区间 `(0, 1)` 仍然没有元素；如果你设置为两端都闭的区间，那么初始区间 `[0, 0]` 就包含了一个元素。这两种情况都会给边界处理带来不必要的麻烦。
+
+2. 我们先不断地增加 `right` 指针扩大窗口 `[left, right)`，直到窗口中的字符串符合要求（包含了 `T` 中的所有字符）。
+
+3. 此时，我们停止增加 `right`，转而不断增加 `left` 指针缩小窗口 `[left, right)`，直到窗口中的字符串不再符合要求（不包含 `T` 中的所有字符了）。同时，每次增加 `left`，我们都要更新一轮结果。
+
+4. 重复第 2 和第 3 步，直到 `right` 到达字符串 `S` 的尽头。
+
+```java
+public String minWindow(String s, String t) {
+    // 两个map，window 代表字符字符出现的次数，need 记录所需字符出现次数
+    HashMap<Character, Integer> window = new HashMap<>();
+    HashMap<Character, Integer> need = new HashMap<>();
+
+    for (int i = 0; i < t.length(); i++) {
+        char c = t.charAt(i);
+        //算出每个字符的数量，有可能有重复的
+        need.put(c, need.getOrDefault(c, 0) + 1);
+    }
+
+    //左开右闭的区间，然后创建移动窗口
+    int left = 0, right = 0;
+    // 窗口中满足need条件的字符个数， valid == need.size 说明窗口满足条件
+    int valid = 0;
+    //记录最小覆盖子串的开始索引和长度
+    int start = 0, len = Integer.MAX_VALUE;
+    while (right < s.length()) {
+        // c 代表将移入窗口的字符
+        char c = s.charAt(right);
+        //扩大窗口
+        right++;
+
+        if (need.containsKey(c)) {
+            window.put(c, window.getOrDefault(c, 0) + 1);
+            if (window.get(c).equals(need.get(c))) {
+                valid++;
+            }
+        }
+        //判断左窗口是否需要收缩
+        while (valid == need.size()) {
+            if (right - left < len) {
+                start = left;
+                len = right - left;
+            }
+            //d 是将移除窗口的字符
+            char d = s.charAt(left);
+            left++;  //缩小窗口
+
+            //更新窗口
+            if (need.containsKey(d)) {
+                if (window.get(d).equals(need.get(d))) {
+                    valid--;
+                    window.put(d, window.get(d) - 1);
+                }
+            }
+        }
+    }
+    //返回最小覆盖子串
+    return len == Integer.MAX_VALUE ? "" : s.substring(start, start + len);
+}
+```
+
+
+
+#### [字符串的排列（567）](https://leetcode.cn/problems/permutation-in-string/description/)
+
+> 给你两个字符串 `s1` 和 `s2` ，写一个函数来判断 `s2` 是否包含 `s1` 的排列。如果是，返回 `true` ；否则，返回 `false` 。
+>
+> 换句话说，`s1` 的排列之一是 `s2` 的 **子串** 。
+>
+> ```
+> 输入：s1 = "ab" s2 = "eidbaooo"
+> 输出：true
+> 解释：s2 包含 s1 的排列之一 ("ba").
+> ```
+
+思路：和上一题基本一致，只是 移动 `left` 缩小窗口的时机是窗口大小大于 `t.length()` 时，当发现 `valid == need.size()` 时，就说明窗口中就是一个合法的排列
+
+```java
+class Solution {
+    // 判断 s 中是否存在 t 的排列
+    public boolean checkInclusion(String t, String s) {
+        Map<Character, Integer> need = new HashMap<>();
+        Map<Character, Integer> window = new HashMap<>();
+        for (char c : t.toCharArray()) {
+            need.put(c, need.getOrDefault(c, 0) + 1);
+        }
+
+        int left = 0, right = 0;
+        int valid = 0;
+        while (right < s.length()) {
+            char c = s.charAt(right);
+            right++;
+            // 进行窗口内数据的一系列更新
+            if (need.containsKey(c)) {
+                window.put(c, window.getOrDefault(c, 0) + 1);
+                if (window.get(c).intValue() == need.get(c).intValue())
+                    valid++;
+            }
+
+            // 判断左侧窗口是否要收缩
+            while (right - left >= t.length()) {
+                // 在这里判断是否找到了合法的子串
+                if (valid == need.size())
+                    return true;
+                char d = s.charAt(left);
+                left++;
+                // 进行窗口内数据的一系列更新
+                if (need.containsKey(d)) {
+                    if (window.get(d).intValue() == need.get(d).intValue())
+                        valid--;
+                    window.put(d, window.get(d) - 1);
+                }
+            }
+        }
+        // 未找到符合条件的子串
+        return false;
+    }
+}
+```
 
 
 
@@ -744,10 +850,6 @@ int lengthOfLongestSubstring(String s) {
 
 思路：
 
-- 
-
-
-
 ```java
 public int characterReplacement(String s, int k) {
   int len = s.length();

docs/data-structure-algorithms/algorithm/Double-Pointer.md

@@ -568,6 +568,10 @@ public class BucketSort {
 - 什么时候最快：当输入的数据可以均匀的分配到每一个桶中。
 - 什么时候最慢：当输入的数据被分配到了同一个桶中。
 
+> 思路一定要理解了，不背题哈，比如有些直接问你
+>
+> 已知一组记录的排序码为（46，79，56，38，40，80, 95，24），写出对其进行快速排序的第一趟的划分结果
+
 
 
 ## 基数排序

docs/data-structure-algorithms/algorithm/Sort.md

@@ -16,19 +16,19 @@
 
 假设我们是一家饮品店的师傅，起码需要以下两个手艺
 
-![](https://tva1.sinaimg.cn/large/007S8ZIlly1gigzsl1cnpj32gj0sk4ck.jpg)
+![img](https://static001.geekbang.org/infoq/19/196f4c041c71d63442c2c688051c893a.jpeg)
 
 真简单哈，这么看，步骤大同小异，我的第一反应就是写个业务接口，不同的饮品实现其中的方法就行，像这样
 
-![](https://tva1.sinaimg.cn/large/007S8ZIlly1gih087fykdj31pk0u0nbj.jpg)
+![img](https://static001.geekbang.org/infoq/a2/a226b8a9219cd7a29af2f3b626cd5fcb.jpeg)
 
 
 
 画完类图，猛地发现，第一步和第三步没什么差别，而且做饮品是个流程式的工作，我希望使用时，直接调用一个方法，就去执行对应的制作步骤。
 
 灵机一动，不用接口了，用一个**抽象父类**，把步骤方法放在一个大的流程方法 `makingDrinks()` 中，且第一步和第三步，完全一样，没必要在子类实现，改进如下
 
-![](https://tva1.sinaimg.cn/large/007S8ZIlly1giidk5vt5cj31pf0u0nal.jpg)
+![img](https://static001.geekbang.org/infoq/21/2146409c43149828b8a12949daf5b0a4.jpeg)
 
 再看下我们的设计，感觉还不错，现在用同一个 `makingDrinks()` 方法来处理咖啡和茶的制作，而且我们不希望子类覆盖这个方法，所以可以申明为 final，不同的制作步骤，我们希望子类来提供，必须在父类申明为抽象方法，而第一步和第三步我们不希望子类重写，所以我们声明为非抽象方法
 
@@ -117,7 +117,7 @@ public static void main(String[] args) {
 
 模板方法模式是所有模式中最为常见的几个模式之一，是**基于继承**的代码复用的基本技术，我们再看下类图
 
-![](https://tva1.sinaimg.cn/large/007S8ZIlly1gih2dmwutxj31ug0u0h0i.jpg)
+![img](https://static001.geekbang.org/infoq/b1/b114ec408fb0231529d8748618df9ed7.jpeg)
 
 模板方法模式就是用来创建一个算法的模板，这个模板就是方法，该方法将算法定义成一组步骤，其中的任意步骤都可能是抽象的，由子类负责实现。这样可以**确保算法的结构保持不变，同时由子类提供部分实现**。
 
@@ -207,7 +207,7 @@ public class Coffee extends Drinks {
 
 接着再去测试下代码，看看结果吧。
 
-![](https://tva1.sinaimg.cn/large/007S8ZIlly1gih3og312yj315y07uta9.jpg)
+![img](https://static001.geekbang.org/infoq/e6/e608360ad552adc44dab00293fddd671.jpeg)
 
 
 
@@ -252,7 +252,7 @@ public static void main(String[] args) {
 }
 ```
 
-![](https://tva1.sinaimg.cn/large/007S8ZIlly1giha6rya5nj319006adhb.jpg)
+![img](https://static001.geekbang.org/infoq/92/9241c28ee542321b3e6f4e2a2fbf805a.jpeg)
 
 你可能会说，这个看着不像我们常规的模板方法，是的。我们看下比较器实现的步骤
 
@@ -329,7 +329,7 @@ public abstract class AbstractRefreshableWebApplicationContext extends …… {
 
 看下大概的类图：
 
-![](https://tva1.sinaimg.cn/large/007S8ZIlly1giie97gicdj31c20u0hdt.jpg)
+![img](https://static001.geekbang.org/infoq/13/1360f5528a2e86e5b0d0bf3a97b3c04b.jpeg)
 
 
 
@@ -350,5 +350,3 @@ public abstract class AbstractRefreshableWebApplicationContext extends …… {
 《Head First 设计模式》、《研磨设计模式》
 
 https://sourcemaking.com/design_patterns/template_method
-
-![](https://cdn.jsdelivr.net/gh/Jstarfish/picBed/img/20200907141047.png)

docs/design-pattern/Template-Pattern.md

@@ -154,3 +154,6 @@ ls –la input_file_name
    - **个人经验**: 可以提到如何配置 Prometheus 采集日志指标、设置警报规则，以及如何利用 Grafana 创建可视化面板。
 
 我们使用 ELK Stack 来集中管理和分析日志数据。通过 Logstash 我们收集来自不同服务的日志，并将其存储在 Elasticsearch 中，然后使用 Kibana 创建了多个仪表盘来监控系统的健康状况和性能
+
+
+

docs/interview/.DS_Store

@@ -55,8 +55,7 @@ public class Singleton
     {
     }
 
-    public static Singleton getInstance()
-    {
+    public static Singleton getInstance(){
         if (singleton == null)
             singleton = new Singleton();
         return singleton;
@@ -71,12 +70,10 @@ public class Singleton
 {
     private static Singleton singleton;
 
-    private Singleton()
-    {
+    private Singleton(){
     }
 
-    public synchronized static Singleton getInstance()
-    {
+    public synchronized static Singleton getInstance(){
         if (singleton == null)
             singleton = new Singleton();
         return singleton;