系列文章目录和关于我

一丶[无重复字符的最长子串](3. 无重复字符的最长子串 - 力扣（Leetcode）)

思路:

维护一个窗口，窗口中不存在重复的字符，窗口右边界从第一个字符移动到最后，使用一个变量记录窗口大小的最大值

那么问题就变成了：怎么确保窗口中不存在重复的字符，我们可以使用一个set，每次发现right位置的字符A重复后，就一直移动到之前A字符位置的下一个。比如 BACDHA，此时right位于第二个A，set中包含字符BACDH，为了维持不重复，我们要将左边界移动到第一个C的位置，while循环让left右移，并删除left位置的字符，直到第一个A被删除

继续思考下，其实没必要使用一个set，直接使用一个map即可，map需要记录字符和这个字符最近出现的位置,当前字符重复A的时候，就让left移动到A最近出现位置的前一个。比如BACDHA，此时right为A，map中记录了B->0，A->1等信息，我们只需要让left移动到1+1（A最近出现于下标1，left需要移动到2位置）然后再map中重新记录A->5即可

代码：

  1.    public int lengthOfLongestSubstring(String s) {
  2.        //空字符串
  3.         if(s==null||s.length()==0){
  4.             return 0 ;
  5.         }
  7.        //窗口大小 最大值
  8.         int res = 0;
  10.         int left = 0;
  11.         int right = 0;
  12.         int len = s.length();
  14.        //key字符，value 这个字符最近在什么位置出现
  15.        HashMap<Character,Integer> recentLocation = new HashMap<>();
  17.         while(right<len){
  18.             //当前子u发
  19.             char curChar = s.charAt(right);
  20. 			//获取这个字符出现的位置
  21.             Integer index = recentLocation.get(curChar);
  22. 			//如果不为null 说明这个字符曾经出现过 那么这时候需要 让left 移动
  23.             if(index!=null){
  24.                 left = Math.max(index+1,left);
  25.             }
  26.             //记录下最近的位置
  27.             recentLocation.put(curChar,right);
  29.             right++;
  31.             //窗口最大长度更新
  32.             res = Math.max(res,right-left);
  33.         }
  34.         return res;
  35.     }

二丶[最小覆盖子串](76. 最小覆盖子串 - 力扣（Leetcode）)

思路：

使用一个Map表示当前滑动串口亏欠t中字符的数量， key 字符 value 当前窗口中亏欠的数目，亏欠的意思是当前窗口至少还需要多少个key的字符才满足t

当left小于right的时候，我们尽可能让left向右滑动，那么什么时候left可以向右滑昵？——当前left是一个t中根本不存在的字符，或者窗口中left位置的字符数量大于t中的数量（对应下面两图）（这其实是有贪心的思想在其中的，题目是找最短的，那么left越接近right 那么越短）并且亏欠map需要同时维护

然后我们需要移动right指针，同时维护亏欠map

那么什么时候窗口中满足要求包含了t中所有字符昵——亏欠map中不存在value大于0的entry，这时候我们需要更新最佳结果

并且找到一个答案之后，我们需要left向右移动一个位置，并维护亏欠map，比如s=ADOBECODEBANC，t=ABC我们第一次找到符合的结果是ADOBEC，这时候需要left向右，因为后面存在更优秀的答案。

代码：

  1. class Solution {
  2.    public String minWindow(String s, String t) {
  4.         //逆天用例
  5.         if (s == null || s.length() == 0) {
  6.             return null;
  7.         }
  9.         if(s.length() < t.length()){
  10.             return "";
  11.         }
  13.         char[] tCharArray = t.toCharArray();
  14.         // key 字符 value 当前窗口中亏欠的数目，亏欠的意思是当前窗口至少还需要多少个key的字符才满足t
  15.         // value 为正数 表示窗口欠 t，0表示互不亏欠，负数表示窗口中此字符数目多于t
  16.         Map<Character, Integer> owesCharCountMap = new HashMap<Character, Integer>();
  18.         //初始化亏欠的数目
  19.         for (char loop : tCharArray) {
  20.             owesCharCountMap.put(loop, owesCharCountMap.getOrDefault(loop, 0) + 1);
  21.         }
  23.         String res = null;
  24.         int left = 0;
  25.         int right = 0;
  27.         while (right < s.length()) {
  29.             //如果left对应字符是无关紧要的字符（t中不包含的字符）
  30.             //或者left对应的字符那怕删掉 窗口中的字符也不会亏钱t中的字符
  31.             //满足上面任意一点 那么 left++
  32.             while (left < right && !isNecessary(left, s, owesCharCountMap)) {
  33.                 //当前left的字符
  34.                 char leftChar = s.charAt(left);
  35.                 left++;
  36.                 //当前窗口亏欠窗口中多少个
  37.                 Integer count = owesCharCountMap.get(leftChar);
  38.                 //如果不为null 说明leftChar 是t中的字符
  39.                 if (count != null) {
  40.                     //亏欠数++
  41.                     owesCharCountMap.put(leftChar, count + 1);
  42.                 }
  43.             }
  45.             //right位置的字符
  46.             char rightChar = s.charAt(right);
  48.             //right位置字符 窗口亏欠的数目
  49.             Integer count = owesCharCountMap.get(rightChar);
  50.             //right处字符是一个t中的字符 那么亏欠数-1
  51.             if (count != null) {
  52.                 owesCharCountMap.put(rightChar, count - 1);
  53.             }
  55.             //如果窗口满足要求——指最起码不欠t中字符，及包含了所有t中的字符，那怕存在富足
  56.             if (meetRequirementsOrNot(owesCharCountMap)) {
  58.                 //sub以下
  59.                 String tempRes = s.substring(left, right + 1);
  60.                 //记录
  61.                 if (res == null || tempRes.length() < res.length()) {
  62.                     res = tempRes;
  63.                 }
  65.                 //从窗口中 强制删除left位置处的字符
  66.                 //比如s=ADOBECODEBANC t = ABC 此时窗口中字符为ADOBEC 我们找到了一种结果，但是后续可能存在更好的答案
  67.                 //删除left位置的A 我们继续找更好的结果
  68.                 char leftChar = s.charAt(left);
  69.                 Integer leftCount = owesCharCountMap.get(leftChar);
  70.                 if (leftCount!=null){
  71.                     owesCharCountMap.put(leftChar,leftCount+1);
  72.                 }
  73.                 left++;
  74.             }
  75.             right++;
  77.         }
  79.         return res == null ? "" : res;
  80.     }
  82.     private boolean meetRequirementsOrNot(Map<Character, Integer> owesCharCountMap) {
  84.         for (Integer v : owesCharCountMap.values()) {
  85.             if (v == null) {
  86.                 continue;
  87.             }
  88.             if (v > 0) {
  89.                 return false;
  90.             }
  91.         }
  92.         return true;
  93.     }
  95.     private boolean isNecessary(int left, String s, Map<Character, Integer> owesCharCountMap) {
  96.         //left 位置的字符
  97.         char leftChar = s.charAt(left);
  98.         //当前亏欠map中的对应的亏欠数目
  99.         Integer count = owesCharCountMap.get(leftChar);
  101.         //为null 说明这个字符都不是t字符串中的字符 那么说明left位置的字符没必要存在于窗口中
  102.         if (count == null) {
  103.             return false;
  104.         }
  106.         //如果大于等于0 说明当前亏欠这个字符， 或者刚刚好，
  107.         //如果移动那么窗口中的字符数将不够覆盖t中所有字符
  108.         if (count >= 0) {
  109.             return true;
  110.         }
  112.         //说明left处的字符不是必要的
  113.         //说明 当前窗口中这个字符的数量已经大于t中这个字符的数量
  114.         return false;
  115.     }
  117. }

三丶[串联所有单词的子串](30. 串联所有单词的子串 - 力扣（Leetcode）)

思路：

我的思路其实和第二题一样，也是恢复一个亏欠map 然后进行滑动窗口，只是这个开始滑动的位置应该是1~单个单词长度这个范围都进行滑动窗口，这一点很关键。

然后我们需要处理两种情况

  • 滑动窗口中包含了 words中不存在的单词 ，那么前功尽弃，我们需要从这个不存在单词的结尾继续滑动
  • 滑动窗口中包含单词1的数量大于了words数组中单词1的数量，那么其实我们应该从第一个出现单词1位置的下一个位置开始滑动

这个题推荐看题解30. 串联所有单词的子串 - 力扣（Leetcode）我的解法并不是很优秀

代码：

  1. class Solution {
  2.   public List<Integer> findSubstring(String s, String[] words) {
  4.         List<Integer> res = new ArrayList<>();
  6.         int singleWordLen = words[0].length();
  7.         if (singleWordLen * words.length > s.length()) {
  8.             return res;
  9.         }
  11.       	//亏欠map
  12.         Map<String, Integer> owensMap = new HashMap<>();
  13.         for (String loop : words) {
  14.             owensMap.put(loop, owensMap.getOrDefault(loop, 0) + 1);
  15.         }
  17.         int roundStartPos = 0;
  18.       //从第一个位置开始 ，第二个位置开始 。。到单个单词长度个位置
  19.       while (roundStartPos < singleWordLen) {
  20.             Map<String, Integer> owensMapTemp = new HashMap<>(owensMap);
  21.             int left = roundStartPos;
  22.             int right = roundStartPos;
  24.             //滑动窗口
  25.             while (right <= s.length() - singleWordLen) {
  27.                 //left 位置的单词 不是必要的
  28.                 while (left < right && !isNecessary(left, singleWordLen, s, owensMapTemp)) {
  29.                     String temp = s.substring(left, left + singleWordLen);
  30.                     Integer count = owensMapTemp.get(temp);
  31.                     if (count != null) {
  32.                         owensMapTemp.put(temp, count + 1);
  33.                     }
  34.                     left += singleWordLen;
  35.                 }
  37.                 //right位置的单词
  38.                 String rightString = s.substring(right, right + singleWordLen);
  39.                 Integer count = owensMapTemp.get(rightString);
  41.                 //right位置的单词 是我们需要的 那么维护亏欠map
  42.                 if (count != null && count >= 1) {
  43.                     owensMapTemp.put(rightString, count - 1);
  44.                     right += singleWordLen;
  45.                 } else {
  46.                     //right 位置的单词 不是words数组中的单词 那么直接然后right 跨过这个单词，直接从下一个单词开始
  47.                     if (count == null) {
  48.                         right = right + singleWordLen;
  49.                         left = right;
  50.                         owensMapTemp = new HashMap<>(owensMap);
  51.                     } else {
  52.                         //right位置的单词是words数组中的单词 但是当前窗口中这个单词数量 已经 大于words数组中这个单词数量的单词
  53.                         //那么删除头部的第一个单词 然后继续，
  54.                         String temp = s.substring(left, left + singleWordLen);
  55.                         Integer tempCount = owensMapTemp.get(temp);
  56.                         if (tempCount != null) {
  57.                             owensMapTemp.put(temp, tempCount + 1);
  58.                         }
  59.                         left += singleWordLen;
  60.                     }
  61.                 }
  63.                 //符合要求 那么left 移动到下一个单词 并继续 找出所有答案
  64.                 if (meetRequire(owensMapTemp)) {
  65.                     res.add(left);
  66.                     String temp = s.substring(left, left + singleWordLen);
  67.                     Integer tempCount = owensMapTemp.get(temp);
  68.                     if (tempCount != null) {
  69.                         owensMapTemp.put(temp, tempCount + 1);
  70.                     }
  71.                     left += singleWordLen;
  72.                 }
  73.             }
  74.             roundStartPos++;
  75.         }
  76.         return res;
  77.     }
  79.     private boolean isNecessary(int left, int singleWordLen, String s, Map<String, Integer> owensMapTemp) {
  80.         String temp = s.substring(left, left + singleWordLen);
  81.         Integer count = owensMapTemp.get(temp);
  82.         if (count == null) {
  83.             return false;
  84.         }
  85.         if (count < 0) {
  86.             return false;
  87.         }
  88.         return true;
  89.     }
  91.     private boolean meetRequire(Map<String, Integer> owensMapTemp) {
  92.         for (Integer c : owensMapTemp.values()) {
  93.             if (c == null) {
  94.                 continue;
  95.             }
  96.             if (c > 0) {
  97.                 return false;
  98.             }
  99.         }
  100.         return true;
  101.     }
  103. }

四丶[重复的DNA序列](187. 重复的DNA序列 - 力扣（Leetcode）)

思路：

这个题挺逆天的，很难想到怎么用滑动窗口做，使用2进制表示字母A，C，G，T，分别使用00，01，02，03，这样窗口滑动的时候就是第一个字母出去，意味着二进制表示左移位2，右边字符进来，使用位操作

代码：

  1. class Solution {
  2.     public List<String> findRepeatedDnaSequences(String s) {
  3.         if(s == null || s.length()<=10){
  4.             return new ArrayList<>();
  5.         }
  7.         List<String> res =  new LinkedList<>();
  8.         Map<Integer,Integer> memory = new  HashMap<Integer,Integer>();
  10.         int right = 0;
  12.         int firstBi = 0;
  13.         while(right<10){
  14.             firstBi = (firstBi<<2)| binaryOf(s.charAt(right));
  15.             right++;
  16.         }
  17.         memory.put(firstBi,1);
  18.         while(right < s.length()){
  19.             int bi = binaryOf(s.charAt(right));
  20.             //左边字符出去  右边字符进来
  21.             firstBi = ((firstBi<<2) |bi)&((1<<20)-1);;
  22.             int count =memory.getOrDefault(firstBi,0)+1;
  23.              memory.put(firstBi,count);
  24.             if(count == 2){
  25.                 res.add(s.substring(right+1-10,right+1));
  26.             }
  28.             right++;
  29.         }
  30.         return res;
  31.     }
  33.     private int binaryOf(char a){
  34.         if(a == 'A'){
  35.             return 0;
  36.         }
  37.          if(a == 'C'){
  38.             return 1;
  39.         }
  40.         if(a == 'G'){
  41.             return 2;
  42.         }
  43.          if(a == 'T'){
  44.             return 3;
  45.         }
  46.         return -1;
  47.     }
  48. }

五丶[长度最小的子数组](209. 长度最小的子数组 - 力扣（Leetcode）)

思路：太简单了，窗口描述当前子数据，使用sum记录当前和，如果大于target那么更新长度，如果减去左边界的值还能大于，那么left++。直到right到 数组边界

  1. class Solution {
  2.    public int minSubArrayLen(int target, int[] nums) {
  3.         if(nums == null||nums.length == 0){
  4.             return 0;
  5.         }
  7.         int left = 0;
  8.         int right = 1;
  9.         int sum =nums[0];
  10.         int minLen = sum>target?1:0;;
  11.         while(right<nums.length){
  13.             sum +=nums[right];
  15.             while(left<right && sum - nums[left]>=target){
  16.                 sum -= nums[left];
  17.                 left++;
  18.             }
  20.             if(sum>=target){
  21.                 if(minLen == 0||minLen>right-left+1){
  22.                     minLen = right - left+1;
  23.                 }
  24.             }
  26.             right++;
  27.         }
  28.         return minLen;
  30.     }
  31. }

六丶[存在重复元素 II](219. 存在重复元素 II - 力扣（Leetcode）)

思路：

维护一个长度为k的滑动窗口，使用set记录窗口中的数字，每次left位置的数据从窗口中出去，right位置的数进来，首先删除set中left代表的数字，然后如果right位置的数字存在于set中那么说明重复

代码：

  1.   public boolean containsNearbyDuplicate(int[] nums, int k) {
  2.         if(nums == null || nums.length<=1){
  3.             return false;
  4.         }
  5.         if(k == 0){
  6.             return false;
  7.         }
  8.         int left = 0;
  9.         int right = 0;
  10.         Set<Integer>memory = new HashSet<Integer>();
  12.         while(right<k+1 && right<nums.length){
  13.             if(!memory.add(nums[right])){
  14.                 return true;
  15.             }
  16.             right++;
  17.         }
  19.         while(right <nums.length){
  20.             int newNum = nums[right];
  21.             memory.remove(nums[left++]);
  22.             right++;
  23.             if(!memory.add(newNum)){
  24.                 return true;
  25.             }
  26.         }
  27.         return false;
  28.     }

七丶[存在重复元素 III](220. 存在重复元素 III - 力扣（Leetcode）)

思路：

思路和六类似，但是问题在于，我们如何快速的判断是否存在一个数，它和窗口中的数满足abs(nums[i] - nums[j]) <= t，这时候我们应该想到TreeSet，基于红黑树进行如此的判断的速度是logN

代码：

  1. class Solution {
  2.     public boolean containsNearbyAlmostDuplicate(int[] nums, int indexDiff, int valueDiff) {
  3.         if (nums == null || nums.length == 0) {
  4.             return false;
  5.         }
  6.         if (indexDiff == 0) {
  7.             return false;
  8.         }
  10.         TreeSet<Integer> ts = new TreeSet<>();
  11.         int left = 0;
  12.         int right = 0;
  13.         while (right < indexDiff + 1 && right < nums.length) {
  14.             if (exist(ts,nums[right],valueDiff)){
  15.                 return true;
  16.             }
  17.             ts.add(nums[right]);
  18.             right++;
  19.         }
  21.         while (right < nums.length) {
  22.             ts.remove(nums[left++]);
  23.             if (exist(ts,nums[right],valueDiff)){
  24.                 return true;
  25.             }
  26.             ts.add(nums[right++]);
  27.         }
  29.         return false;
  30.     }
  32.     private boolean exist(TreeSet<Integer> ts, int value, int diff) {
  33.         //Set中是否 存在一个数A 满足 abs(A-value)<=diff
  34.         //A>=value 最小的数 min 是否满足 min - value <= diff
  35.         //A<=value 最大的数max 是否满足 value - max<= diff
  36.         Integer min = ts.ceiling(value);
  37.         if (min != null && min - value <= diff) {
  38.             return true;
  39.         }
  40.         Integer max = ts.floor(value);
  41.         if(max!=null&&value - max<=diff){
  42.             return true;
  43.         }
  44.         return false;
  45.     }
  47. }

八丶[滑动窗口最大值](239. 滑动窗口最大值 - 力扣（Leetcode）)

思路：

窗口大小恒定为k大小，从头移动到尾巴，我们需要一种数据结构记录窗口此时的最大值，第一反应使用优先队列，入队时right位置的值，出队是left位置的值，但是这存在一个问题，如1,3,-1,3,2,2,k=3.当前窗口运动到1,【3,-1,3】,2,2 优先队列记录了3，-1紧接着left位置元素删除的时候会导致队列中只有一个1，随后right位置入队，队列维护了-1，2导致结构少了一个3。我们需要转变思想，队列每一个元素记录两个内容——值和对应的下标，当我们发生堆顶元素下标不在窗口中的时候进行删除。

上面优先队列的使用是整个复杂度来到NLogN，其实还有另外一个数据结构可以实现这个功能，单调栈——我们维护一个单调递减的栈，当j<i,并且i位置值大于j位置值的时候，我们还有什么必要维护j下标的值昵，

代码：

1.优先队列

  1.  public int[] maxSlidingWindow(int[] nums, int k) {
  2.         //优先队列 维护滑动窗口中的最大值
  4.         if(nums == null || nums.length < k ){
  5.             return nums;
  6.         }
  8.         int[]res = new int[nums.length - k +1]; 
  10.         //优先使用值进行比较，值越大越在堆顶
  11.         //其次使用下标进行比较，下表越大越在堆顶，下标越大 活得越久
  12.         PriorityQueue<int[]> q = new PriorityQueue<>((i,j)->i[0]!=j[0]?j[0]-i[0]:j[1]-i[1]);
  13.         int right = 0;
  14.         while(right<k){
  15.             q.add(new int[]{nums[right],right});
  16.             right++;
  17.         }
  18.         res[0] = q.peek()[0];
  19.         int count = 1;
  20.         while(right<nums.length){
  21.             q.offer(new int[]{nums[right],right});
  23.             while(q.peek()[1] <= right - k){
  24.                 q.poll();
  25.             }
  26.             right++;
  27.             res[count++]=q.peek()[0];
  28.         }
  29.         return res;
  30.     }

2.单调栈

  1.  public int[] maxSlidingWindow(int[] nums, int k) {
  2.         if(nums == null ){
  3.             return nums;
  4.         }
  5.         int[]res = new int[nums.length - k +1];
  7.         //队列中的值是下标 但是必须保证这些下标值是单调递减的
  8.         //当前 i<j nums[j]>=nums[i] 这时候num[i]对应下标 不需要维护了
  9.      	//说是单调栈其实是双向队列，因为我们需要看栈底元素
  10.         LinkedList<Integer> ll = new LinkedList<Integer>();
  11.         int right = 0;
  12.      	//初始化双端队列
  13.         while(right < k){
  14. 			//nums[ll.getLast()] <= nums[right]
  15.             //对应 1，2，3，4 k =3 初始化的时候 【1，2，3】4 这时候我们只需要维护3即可
  16.             while(!ll.isEmpty() && nums[ll.getLast()] <= nums[right]){
  17.                ll.removeLast();
  18.             }
  19.             ll.addLast(right);
  20.             right++;
  21.         }
  23.         res[0] = nums[ll.getFirst()];
  24.         int count = 1;
  26.         while(right < nums.length){
  27.           //同上
  28.            while(!ll.isEmpty() && nums[ll.getLast()] <= nums[right]){
  29.                 ll.removeLast();
  30.            }
  32.            ll.addLast(right);
  33.            //如果队列头 也就是最大的值 将不处于窗口外
  34.            while(ll.getFirst() <= right-k){
  35.                ll.removeFirst();
  36.            }
  37.            res[count++] = nums[ll.getFirst()];
  38.            right++;
  39.         }
  41.         return res;
  42.     }

九丶[找到字符串中所有字母异位词](438. 找到字符串中所有字母异位词 - 力扣（Leetcode）)

思路：

滑动窗口大小为p长度，使用一个map记录窗口中字符和对应的数量，当每种字符数量和p相同是，记录下left的位置，left++的时候更新map，right++的时候更新map

代码：

  1. class Solution {
  2.     public List<Integer> findAnagrams(String s, String p) {
  3.         if(s == null || s.length()<p.length()){
  4.             return new ArrayList<>();
  5.         }
  6.         List<Integer> res = new ArrayList<>();
  7.         if(s.equals(p)){
  8.             res.add(0);
  9.             return res;
  10.         }
  12.         //记录p中的字符和对应的数量，因为都是小写字母，26长度的数组足以
  13.         int[] pCharCount = new int[26];
  14.         for(int i= 0; i<p.length();i++){
  15.             char c = p.charAt(i);
  16.             pCharCount[c-'a']++;
  17.         }
  19.         //记录窗口中字符和队友的数量
  20.         int[] windowCharCount  = new int[26];
  21.         int left = 0 ;
  22.         int right = 0;
  23.         while(right<s.length()){
  25.             //左边界++
  26.             while(right - left + 1 > p.length()){
  27.                 windowCharCount[s.charAt(left)-'a']--;
  28.                 left++;
  29.             }
  31.             //右边界++
  32.             windowCharCount[s.charAt(right)-'a']++;
  34.             //字符和数目 和p一样
  35.             if(meetRequire(pCharCount,windowCharCount)){
  36.                 res.add(left);
  37.             }
  38.             right++;
  39.         }
  40.        return res;
  41.     }
  43.     private boolean meetRequire(int[] pCharCount,int[] windowCharCount ){
  44.         for(int i =0;i<26;i++){
  45.             if(pCharCount[i]!=windowCharCount[i]){
  46.                 return false;
  47.             }
  48.         }
  49.         return true;
  50.     }
  51. }

十丶[替换后的最长重复字符](424. 替换后的最长重复字符 - 力扣（Leetcode）)

思路：

维护一个窗口，我们需要保证窗口中的字符替换k次之后，都是相同的字符——字符总数-最大字符出现次数<=k

如果不满足这个条件 那么左边界++，直到满足

代码：

  1. class Solution {
  2.     public int characterReplacement(String s, int k) {
  3.       if(s == null ){
  4.           return 0;
  5.       }
  7.     if(s.length() <=k){
  8.         return s.length();
  9.     }
  10.     int res = 0;
  11.     int left = 0;
  12.     int right = 0;
  13.     int[]charCount = new int[26];
  15.     while(right<s.length()){
  16.         charCount[s.charAt(right)-'A']++;
  17.         while(!meetRequire(charCount,k)){
  18.               charCount[s.charAt(left)-'A']--;
  19.             left++;
  21.         }
  22.         res  = Math.max(res,right - left+1);
  23.         right++;
  24.     }
  25.     return res;
  26.  }
  28.  private boolean meetRequire(int[]charCount,int k){
  29.      int max = -1;
  30.      int sum = 0;
  31.      for(int c : charCount){
  32.          sum+=c;
  33.          max = Math.max(max,c);
  34.      }
  35.      return sum-max<=k;
  36.  }
  37. }

WeetCode2滑动窗口系列的更多相关文章

  1. leetcode的Hot100系列--3. 无重复字符的最长子串--滑动窗口

    可以先想下这两个问题: 1.怎样使用滑动窗口? 2.如何快速的解决字符查重问题? 滑动窗口 可以想象一下有两个指针,一个叫begin,一个叫now 这两个指针就指定了当前正在比较无重复的字符串,当再往 ...

  2. 面试连环炮系列（二十）：TCP的滑动窗口协议是什么

    TCP的滑动窗口协议是什么 滑动窗口协议,用于网络数据传输时的流量控制,以避免拥塞的发生.该协议允许发送方在停止并等待确认前发送多个数据分组.由于发送方不必每发一个分组就停下来等待确认,因此该协议可以 ...

  3. [LeetCode]438. 找到字符串中所有字母异位词、76. 最小覆盖子串（滑动窗口解决子串问题系列）

    题目438. 找到字符串中所有字母异位词 给定一个字符串 s 和一个非空字符串 p,找到 s 中所有是 p 的字母异位词的子串,返回这些子串的起始索引. 说明: 字母异位词指字母相同,但排列不同的字符 ...

  4. 源码分析 Alibaba sentinel 滑动窗口实现原理(文末附原理图)

    要实现限流.熔断等功能,首先要解决的问题是如何实时采集服务(资源)调用信息.例如将某一个接口设置的限流阔值 1W/tps,那首先如何判断当前的 TPS 是多少?Alibaba Sentinel 采用滑 ...

  5. [LeetCode] Sliding Window Maximum 滑动窗口最大值

    Given an array nums, there is a sliding window of size k which is moving from the very left of the a ...

  6. TCP/IP 协议中的滑动窗口

    一个例子明白发送缓冲区.接受缓冲区.滑动窗口协议之间的关系. 在上面的几篇文章中简单介绍了上述几个概念在TCP网络编程中的关系,也对应了几个基本socket系统调用的几个行为,这里再列举一个例子,由于 ...

  7. Storm Windowing storm滑动窗口简介

    Storm Windowing 简介 Storm可同时处理窗口内的所有tuple.窗口可以从时间或数量上来划分,由如下两个因素决定: 窗口的长度,可以是时间间隔或Tuple数量: 滑动间隔(slidi ...

  8. lintcode 滑动窗口的最大值(双端队列)

    题目链接:http://www.lintcode.com/zh-cn/problem/sliding-window-maximum/# 滑动窗口的最大值 给出一个可能包含重复的整数数组,和一个大小为  ...

  9. TCP 三次握手四次挥手, ack 报文的大小.tcp和udp的不同之处、tcp如何保证可靠的、tcp滑动窗口解释

    一.TCP三次握手和四次挥手,ACK报文的大小 首先连接需要三次握手,释放连接需要四次挥手 然后看一下连接的具体请求: [注意]中断连接端可以是Client端,也可以是Server端. [注意] 在T ...

  10. tcp协议头窗口，滑动窗口，流控制，拥塞控制关系

    参考文章 TCP 的那些事儿(下) http://coolshell.cn/articles/11609.html tcp/ip详解--拥塞控制 & 慢启动 快恢复 拥塞避免 http://b ...

随机推荐

  1. 【Elasticsearch】ES选主流程分析

    Raft协议 Raft是分布式系统中的一种共识算法,用于在集群中选举Leader管理集群.Raft协议中有以下角色: Leader(领导者):集群中的领导者,负责管理集群. Candidate(候选者 ...

  2. IK分词器实现原理剖析 —— 一个小问题引发的思考

    前言: 网上很多的文章都建议在使用IK分词器的时候,建立索引的时候使用ik_max_word模式:搜索的时候使用ik_smart模式.理由是max_word模式分词的结果会包含smart分词的结果,这 ...

  3. 《Java基础——选择语句》

    Java基础--选择语句       1. if语句; 规则: 1. 首先计算表达式的值. 2. 若表达式为真,则执行对应语句,为假则不执行.   格式一: if(表达式) 语句;//多个语句可用{} ...

  4. python的三层架构

    项目目录规范 Foo/ |-- core/ # 存放业务逻辑相关代码 | |-- core.py | |-- api/ # 存放接口文件,接口主要用于为业务逻辑提供数据操作. | |-- api.py ...

  5. Portainer 基本功能介紹之升級映像檔並更新 Container

    文档地址:https://www.asustor.com/zh-tw/online/College_topic?topic=145#dpt7

  6. Python实现改进后的Bi-RRT算法实例

    Python实现改进后的Bi-RRT算法实例 1.背景说明 以下代码是参照上海交通大学海洋工程国家重点实验室<基于改进双向RRT的无人艇局部路径规划算法研究>的算法思想实现的. 2.算法流 ...

  7. day08-MySQL事务

    MySQL事务 先来看一个例子 有一张balance表: 需求:将tom的100块钱转到King账户中 执行的操作是: update balance set money = money -100 wh ...

  8. ASP.NET Core ：容器注入（二）：生命周期作用域与对象释放

    //瞬时生命周期 ServiceCollection services = new ServiceCollection(); services.AddTransient<TestServiceI ...

  9. DDD-领域驱动（二）-贫血模型与充血模型

    贫血模型 一般来说 贫血模型:**一个类中只有属性或者成员变量,没有方法 **!例如 DbFirst 从数据库同步实体过来, -- 对于一个系统刚开始的时候会觉得这时候是最舒服的,但是如果后期系统需要 ...

  10. k8s 中的 service 如何找到绑定的 Pod 以及如何实现 Pod 负载均衡

    k8s 中的 service 如何找到绑定的 Pod 以及如何实现 Pod 负载均衡 前言 endpoint kube-proxy userspace 模式 iptables ipvs kernels ...