计算最大不重复子串

public class Solution {

    public static void main(String[] args) {
        System.out.println(lengthOfLongestSubstring1("abcaef"));
        System.out.println(lengthOfLongestSubstring2("abcaef"));
        System.out.println(lengthOfLongestSubstring3("abcbef"));
    }

    public static int lengthOfLongestSubstring1(String s)
    {
        int n = s.length();
        int ans = 0;
        for (int i = 0; i < n; i++)
        {
            for (int j = i + 1; j <= n; j++)
            {
                if (allUnique(s, i, j))
                {
                    ans = Math.max(ans, j - i);
                }
            }

        }

        return ans;
    }

    public static boolean allUnique(String s, int start, int end)
    {
        Set<Character> set = new HashSet<>();
        for (int i = start; i < end; i++)
        {
            Character ch = s.charAt(i);
            if (set.contains(ch))
            {
                return false;
            }

            set.add(ch);
        }
        return true;
    }


    public static int lengthOfLongestSubstring2(String s) {
        int n = s.length();
        Set<Character> set = new HashSet<>();
        int ans = 0, i = 0, j = 0;
        while (i < n && j < n) {
            // try to extend the range [i, j]
            if (!set.contains(s.charAt(j))){
                set.add(s.charAt(j++));
                ans = Math.max(ans, j - i);
            }
            else {
                set.remove(s.charAt(i++));
            }
        }
        return ans;
    }

    public static int lengthOfLongestSubstring3(String s) {
        int n = s.length(), ans = 0;
        Map<Character, Integer> map = new HashMap<>(); // current index of character
        // try to extend the range [i, j]
        for (int j = 0, i = 0; j < n; j++) {
            if (map.containsKey(s.charAt(j))) {
                i = Math.max(map.get(s.charAt(j))+1, i);
            }
            ans = Math.max(ans, j - i + 1);
            //这样设置键值是为了下次能做判断，如果从0开始，下次循环就不可以判断当前
            map.put(s.charAt(j), j );
        }
        return ans;
    }



//    public static Node reverse(Node head){
//        //如果是空链表或者尾结点
//        if (head==null||head.getNext()==null) {
//            return head;
//        }
//
//        //先反转后续结点
//        Node reversedHead=reverse(head.getNext());
//
//        //当前结点指针指向前一结点
//        head.getNext().setNext(head);
//
//        //令前一结点的指针域为null
//        head.setNext(null);
//        return reversedHead;
//    }
}