leetcode-3-无重复字符的最长子串

题目：

暴力解法：枚举出所有的子字符串，再根据子字符串来判断，使用枚举用了三层循环，时间复杂度为O(N2)

package com.example.demo;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class TestLeetCode {
    /**
     * 查找给定字符串中长度最长的子字符串的长度（本题不需要给出具体的字符串）
     *
     * @param args
     */
    public static void main(String[] args) {
        int abcabcbb = lengthOfLongestSubstring("abcabcbb");
        System.out.println(abcabcbb);
    }

    /**
     * 暴力解法，枚举出所有的子字符串，并且子字符串无重复字符，找到长度最长的子字符串
     *
     * @param s
     * @return
     */
    public static int lengthOfLongestSubstring(String s) {
        int maxRes = 0;
        int len = s.length();
        for (int i = 0; i < len; i++) {
            for (int j = i + 1; j <= len; j++) {
                System.out.println(s.substring(i, j));
　　　　　　　　　//如果子字符串没有重复字符，则重新计算maxRes　　
                if (allUnique(s, i, j)) {
                    maxRes = Math.max(maxRes, j - i);
                }
            }
        }
        return maxRes;
    }

    /**
     * 判断i-j之间的字符串是否是没有重复的字符
     */
    private static boolean allUnique(String s, int start, int end) {
        Set<Character> contains = new HashSet<>();
        for (int i = start; i < end; i++) {
            char c = s.charAt(i);
            if (contains.contains(c)) {
                return false;
            }
            contains.add(c);
        }
        return true;
    }

    /**
     * 枚举出的所有子字符串
     * a
     * ab
     * abc
     * abca
     * abcab
     * abcabc
     * abcabcb
     * abcabcbb
     * b
     * bc
     * bca
     * bcab
     * bcabc
     * bcabcb
     * bcabcbb
     * c
     * ca
     * cab
     * cabc
     * cabcb
     * cabcbb
     * a
     * ab
     * abc
     * abcb
     * abcbb
     * b
     * bc
     * bcb
     * bcbb
     * c
     * cb
     * cbb
     * b
     * bb
     * b
     */
}      

滑动窗口法：

package com.example.demo;

import java.util.HashSet;
import java.util.Set;

public class TestLeetCode {
    /**
     * 查找给定字符串中长度最长的子字符串的长度（本题不需要给出具体的字符串）
     *
     * @param args
     */
    public static void main(String[] args) {
        int abcabcbb = lengthOfLongestSubstring("abcabcbb");
        System.out.println(abcabcbb);
    }

    /**
     * 滑动窗口法，通常情况下在数组和字符串中经常用到
     * 该方式会定义两个索引，left = 0; right = 0; 开始时，left = right,此时left到right之间没有重复的字符，
     * 此时right++，然后在判断left到right之间是否有重复字符，没有则right++，重复该过程，
     * 如果存在重复字符是，则left++，
     * 然后继续走之前的循环，知道right==length时结束
     */
    public static int lengthOfLongestSubstring(String s) {
        int maxRes = 0;
        int left = 0, right = 0;
        Set<Character> contains = new HashSet<>();
　　　　　//当left和right小于s.length是，继续循环
        while (left < s.length() && right < s.length()) {
　　　　　　　//获取right索引出的字符
            char c = s.charAt(right);
　　　　　　　//判断right索引处的字符是否在left和right-1中出现过（这个借助的一个hashset结构来实现）
            if (contains.contains(c)) {
　　　　　　　　　　//出现过，则左索引自增，同事移除hashset中的c
                left++;
                contains.remove(c);
            } else {
　　　　　　　　　　//没有出现过，则将当前字符添加到hashset中，同事right向后移位，并更新maxRes的值
                contains.add(c);
                right++;
                maxRes = Math.max(maxRes, right - left);
            }
        }

        return maxRes;
    }

}