力扣2-3 无重复字符的最长子串

最新推荐文章于 2024-10-18 10:39:20 发布

郝同学今天有进步吗

最新推荐文章于 2024-10-18 10:39:20 发布

阅读量160

点赞数 1

分类专栏：力扣文章标签： leetcode 算法 java

本文链接：https://blog.csdn.net/haoyujie01/article/details/122278691

版权

力扣专栏收录该内容

12 篇文章 0 订阅

订阅专栏

本文探讨了四种不同的方法来解决寻找字符串中最长无重复字符子串的问题，包括暴力法、基本滑动窗口、优化后的滑动窗口以及使用数组的最优解。每种方法的时间复杂度和空间复杂度都有所不同，从O(n^3)到O(n)不等。优化后的滑动窗口和数组方法在效率上显著提高，尤其在处理大型字符串时更为适用。

摘要由CSDN通过智能技术生成

1.暴力法

遍历数组的所有的区间，然后找到最长没有重复字符的区间
将区间所有元素放入hashset，若有重复返回 false
在这里插入图片描述存在重复计算，同一个子串会进行多次判断是否存在重复字符。运行后直接超时。

class Solution {
    public int lengthOfLongestSubstring(String s) {
 		int n = s.length();
        if (n <= 1) return n;
        int maxLen = 1;

        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (allUnique(s, i, j)) {
                    maxLen = Math.max(maxLen, j - i + 1);
                }
            }
        }
        return maxLen;
    }

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

时间复杂度O（n^3);
空间复杂度O（n）。

2.滑动窗口

用left和right表示窗口的左边界和右边界，不断向右移动right，无重复则更新maxLength，有重复则left右移，直到没有重复元素，right再右移，right到最后一个元素则结束。
在这里插入图片描述

class Solution {
    public int lengthOfLongestSubstring(String s) {
  int n = s.length();
        if (n <= 1) return n;
        int maxLen = 1;

        int left = 0, right = 0;
        Set<Character> window = new HashSet<>();
        while (right < n) {
            char rightChar = s.charAt(right);
            while (window.contains(rightChar)) {
                window.remove(s.charAt(left));
                left++;
            }
            maxLen = Math.max(maxLen, right - left + 1);
            window.add(rightChar);
            right++;
        }

        return maxLen;
}
}

时间复杂度：O(2n) = O(n)，最坏的情况是 left 和 right 都遍历了一遍字符串
空间复杂度：O(n)

3.优化后的滑动窗口

用hashmap记住字符所在索引，通过记住每个字符在字符串中的索引，当遇到重复字符的时候，left就可以直接跳到重复字符的后面，而不用一直left++。

class Solution {
    public int lengthOfLongestSubstring(String s) {
    int n = s.length();
        if (n <= 1) return n;
        int maxLen = 1;

        int left = 0, right = 0;
        Map<Character, Integer> window = new HashMap<>();
        while (right < n) {
            char rightChar = s.charAt(right);
            int rightCharIndex = window.getOrDefault(rightChar, 0);
            left = Math.max(left, rightCharIndex);
            maxLen = Math.max(maxLen, right - left + 1);
            window.put(rightChar, right + 1);
            right++;
        }

        return maxLen;
}
}

时间复杂度：O(n)；
空间复杂度：O(n)。

4.用数组（最优）

s由英文字母、数字、符号和空格组成（共128个字符）

class Solution {
    public int lengthOfLongestSubstring(String s) {
         int n = s.length();
        if (n <= 1) return n;
        int maxLen = 1;

        int left = 0, right = 0;
        int[] window = new int[128];
        while (right < n) {
            char rightChar = s.charAt(right);
            int rightCharIndex = window[rightChar];
            left = Math.max(left, rightCharIndex);
            maxLen = Math.max(maxLen, right - left + 1);
            window[rightChar] = right + 1;
            right++;
        }
        return maxLen;
    }
}