LeetCode刷题之滑动窗口以及小小的优化，很直白（滑稽）（c++）

LeetCode刷题之滑动窗口（C++）

第一次写这种博客，目的是对已学习的知识进行整理和总结！（滑稽）

原题 - -无重复字符的最长子串

提交结果:

。。。。 这操蛋的百分比，不亏是自己写的

我的思路:

使用deque 这个双向队列，请忽略cunzai这个变量（掩面），提交的时候太激动忘记删了hh
题目的意思是假如字符串是"ahsduoaho" 这个的最长子串是ahsduo或者hsduoa或者sduoah，答案虽然不唯一，但是长度是唯一的，最长就是6，然后这个子串一定要是连续的
那么就是逐个对字符串进行遍历，然后从后面压入队列，压的时候要判断当前字符是否已经出现，如果出现的话，从前面逐个弹出队列，（注意！压出的弹出的方向不一样），弹到队列里没有相同字符为止！
然后要压入新的元素，然后判断长度是否大于当前长度，如果大于则覆盖。

附上源码！

class Solution {
public:
    bool isExist(deque<char> a,char b)
    {
        for(auto it  = a.begin();it!=a.end();it++)
        {
            if(*it == b)
                return true;
        }
        return false;
    }
    int lengthOfLongestSubstring(string s) {
        deque<char> d;
        int length = 0;
        bool cunzai = false;
            
            for(int j=0;j<s.length();j++)
            {          
                while(isExist(d,s[j]))
                {
                    d.pop_front();
                }
                d.push_back(s[j]);
                if(d.size()>length)
                    length = d.size();
            }
            return length;
    }
};

看完别人写的，我的内心是复杂的。。

大概的原理是

start是子串的开头，end是子串的结尾+1。然后那根最粗的就是原字符串
随着end没到尽头，end不停的往前跑

end每跑一格都要跟前面的子串（棕色的那条）进行比较，假如棕色的那条里面有同样的，就会发生下面的事

假如在问号处有个元素跟end一样，那start就得跑到问号前面，这样就变成了新的子串，因为是子串不是子序列，所以start要跳，
然后length也发生了变化，是end-start，然后随着end的往前移动，length要++，end也要++，每次所有工作做完，都要更新result，也就是长度的最大值，然后就等end到尽头，就结束啦

源码

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int start = 0;
        int end = 0;
        int result = 0;
        int length = 0;
        int size = s.size();
        while(end<size)
        {
            char temp = s[end];
            for(int i = start ;i<end;i++)
            {
                if(temp == s[i])
                {
                    start = i + 1;
                    length = end - start;
                    break;
                }
            }
            end++;
            length++;
            result = max(length,result);
        }
        return result;
    }
};

还有一种是使用哈希表，记录每个元素的所在下标

源码

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int start = 0;
        int end = 0;
        int result = 0;
        int length = 0;
        unordered_map<char,int> m;
        int size = s.size();
        while(end<size)
        {
            if(m.find(s[end])!=m.end()&&m[s[end]]>=start)
            {
                
                start = m[s[end]]+1;
                length = end - start;
            }
            m[s[end]] = end;
            end++;
            length++;
            result = max(length,result);
        }
        return result;
    }
};

之前的查找换成了map中的find，每次出现新的end，都要覆盖或者写入map中，如果是覆盖的，并且下标大于start，说明有重复字符出现了！那就要更新start和length，start只能往前，不能后退，因为start后退了的话，之前的重复字符又会出现。然后效率居然比用for循环的低，鬼知道map的find函数是怎么实现的。。（掩面）

以上就是我这道题的学习内容总结（滑稽）
本人纯萌新，如果有大佬发现了我内容的错误，务必指出！！！！我一定会虚心接受并改正