2021-03-08最长不含重复字符的子字符串

双指针：
利用哈希set，
哈希表中没有重复元素时，增加到哈希set中
哈希表中发现下一个放入的是重复元素时，从0索引开始一直到删除这个元素，重复操作
利用max保存每次循环时无重复长度的最大值
注意：i增加的条件是：HashSet中增加了新的元素，所以这个代码用while循环更容易理解

class Solution {
    public int lengthOfLongestSubstring(String s) {
        Set<Character> hash = new HashSet<Character>();
        int len = s.length();
        int j=0;
        int max = 0;
        for(int i=0; i<len;){
            if(!hash.contains(s.charAt(i))){
                hash.add(s.charAt(i));
                i++;
                
            }else{
                while(hash.contains(s.charAt(i))){
                    hash.remove(s.charAt(j));
                    j++;
                    
                }
            }
            
            max = Math.max(i-j,max);
        }
        return max;
    }
}

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length();
        Set<Character> set = new HashSet<>();

        int i = 0, j = 0;
        int max = 0;
        while(j < n) {
            // 当前滑动窗口内无重复元素，右边界j一直右移
            if(!set.contains(s.charAt(j))) {
                set.add(s.charAt(j));
                j++;
            } else { // 遇到窗口内已有的元素，左边界i一直右移直到重复元素不在Set内
                while(set.contains(s.charAt(j))) {
                    set.remove(s.charAt(i));
                    i++;
                }
            }
            max = Math.max(max, j - i);
        }
        
        return max;
    }
}

注意：二分查找的边界L<=R 改成L<R 输出就有问题

class Solution {
    public int missingNumber(int[] nums) {
        int l = 0;
        int r = nums.length-1;
        while(l<=r){
            int mid = l + (r-l)/2;
            if(nums[mid]==mid){
                l = mid+1;
            }
            else r = mid-1;
        }
        return l;
    }
}

trim 函数 只去除两端的空格，不去除中间空格
var str = ’ xiao ming ';
var str1 = str.trim();
console.log(str1)//xiao ming

class Solution {
    public int missingNumber(int[] nums) {
        int l = 0, r = nums.length - 1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (nums[mid] == mid) l = mid + 1;
            else r = mid - 1; //遇到符合nums[i] != i的数就缩小右边界
        }
        return l; //终止条件是l = r + 1, 因此最终r在左，l在右，而切割线右边的l即为左边界
    }
}

class Solution {
    public String reverseWords(String s) {
        s = s.trim(); // 删除首尾空格
        int j = s.length() - 1, i = j;
        StringBuilder res = new StringBuilder();
        while(i >= 0) {
            while(i >= 0 && s.charAt(i) != ' ') i--; // 搜索首个空格
            res.append(s.substring(i + 1, j + 1) + " "); // 添加单词
            while(i >= 0 && s.charAt(i) == ' ') i--; // 跳过单词间空格
            j = i; // j 指向下个单词的尾字符
        }
        return res.toString().trim(); // 转化为字符串并返回
    }
}

2、StringBuilder和StringBuffer的区别
String的值是不可变得，每次对String的操作会产生新的String变量，所以在可变操作情况下，一般不用String
StringBuffer速度快，线程不安全
StringBuffer线程安全，速度慢
二者的方法相同，都是可变的字符序列