可變字串法

class Solution {
    public int lengthOfLongestSubstring(String s) {

        /**
         * 使用可變字串
         * 為了方便對子串進行增刪，建立一個StringBuilder物件
         * 但同時為了利用String類的indexOf()方法判斷子串中是否包含重複的元素，在每次迴圈前將其再轉換為字串
         */
        int right = 0;
        StringBuilder str = new StringBuilder();
        int max = 0;

        while (right < s.length()){

            String temp = str.toString();

            if (temp.indexOf(s.charAt(right)) < 0){

                str.append(s.charAt(right));
                max = Math.max(str.length(), max);
                right++;
            }

            /**
             * 如果出現了重複元素，刪除子串的第一個字元再去判斷
             */
            else {
                str.deleteCharAt(0);
            }
        }

        return max;
    }
}

/**
 * 時間複雜度 O(n)
 * 空間複雜度 O(1)
 */
 

優化1——減少排除重複元素區間的次數

class Solution {
    public int lengthOfLongestSubstring(String s) {

        /**
         * 使用可變字串
         * 為了方便對子串進行增刪，建立一個StringBuilder物件
         * 但同時為了利用String類的indexOf()方法判斷子串中是否包含重複的元素，在每次迴圈前將其再轉換為字串
         */
        int right = 0;
        StringBuilder str = new StringBuilder();
        int max = 0;

        while (right < s.length()){

            String temp = str.toString();
            int flag = temp.indexOf(s.charAt(right));

            if (flag < 0){

                str.append(s.charAt(right));
                max = Math.max(str.length(), max);
                right++;
            }

            /**
             * 如果出現了重複元素，用flag記錄下重複的位置，一次性刪去該重複元素之前的所有元素
             */
            else {
                str.delete(0, flag + 1);
            }
        }

        return max;
    }
}

/**
 * 時間複雜度 O(n)
 * 空間複雜度 O(1)
 */
 

滑動視窗

class Solution {
    public int lengthOfLongestSubstring(String s) {

        /**
         * 滑動視窗
         * 由於字串的長度可能為0，因此right初始值為-1
         * 因為每個字元等同於其ASCII碼對應的整型，所以可以定義一個256的陣列來儲存每個字元出現的次數
         */
        int left = 0;
        int right = -1;
        int[] count = new int[256];
        int max = 0;

        while (left < s.length()){

            /**
             * 因為right從-1開始，因此作為索引時要加1
             * 如果right + 1沒有越界且當前元素沒有重複，right就往後移動
             * 否則讓left的元素次數減1，並且left右移，直到將那個重複元素排除出當前區間
             */
            if (right + 1 < s.length() && count[s.charAt(right + 1)] == 0){

                right++;
                count[s.charAt(right)]++;
            }
            else {

                count[s.charAt(left)]--;
                left++;
            }

            max = Math.max(max, right - left + 1);
        }

        return max;
    }
}

/**
 * 時間複雜度 O(n)
 * 空間複雜度 O(1)
 */
 

https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/