探索字符串不重复的最长子串长度

2024-01-19 19:29:48

字符串是计算机科学中最基本的数据结构之一。它由一组字符组成，可以表示文本、数字或其他信息。在许多应用中，我们需要找出字符串中不含重复字符的最长子串的长度。例如，在文本处理、数据压缩和密码学等领域，该算法都有着广泛的应用。

在本篇文章中，我们将探讨两种不同的算法来解决这个问题：暴力法和滑动窗口法。首先，我们介绍暴力法，它是一种最简单但效率最低的算法。然后，我们介绍滑动窗口法，它是一种更加高效的算法，可以显著减少计算时间。最后，我们提供Python、Java和C++的代码示例，帮助您轻松理解和实现这两种算法。

暴力法

暴力法是一种最简单但效率最低的算法。它的基本思想是：对于字符串中的每个字符，我们检查其后的所有字符是否都不同。如果都不同，则更新最长子串的长度。否则，继续检查下一个字符。重复该过程，直到遍历完整个字符串。

暴力法的伪代码如下：

def find_longest_substring(string):
  max_length = 0
  for i in range(len(string)):
    sub_string = ""
    for j in range(i, len(string)):
      if string[j] not in sub_string:
        sub_string += string[j]
      else:
        break
    max_length = max(max_length, len(sub_string))
  return max_length

滑动窗口法

滑动窗口法是一种更加高效的算法，可以显著减少计算时间。它的基本思想是：我们使用一个窗口来跟踪当前最长子串。然后，我们滑动窗口，每次将窗口向右移动一个字符。如果窗口中出现重复字符，则将窗口左端点向右移动，直到窗口中不再有重复字符为止。重复该过程，直到窗口滑动到字符串末尾。

滑动窗口法的伪代码如下：

def find_longest_substring(string):
  max_length = 0
  left = 0
  right = 0
  char_set = set()

  while right < len(string):
    if string[right] not in char_set:
      char_set.add(string[right])
      max_length = max(max_length, right - left + 1)
      right += 1
    else:
      char_set.remove(string[left])
      left += 1

  return max_length

效率比较

暴力法和滑动窗口法的效率差异很大。暴力法的时间复杂度为O(n^2)，而滑动窗口法的时间复杂度为O(n)，其中n为字符串的长度。这意味着对于长度为n的字符串，滑动窗口法比暴力法快n倍。

代码示例

下面是Python、Java和C++中这两种算法的代码示例：

Python

def find_longest_substring_brute_force(string):
  max_length = 0
  for i in range(len(string)):
    sub_string = ""
    for j in range(i, len(string)):
      if string[j] not in sub_string:
        sub_string += string[j]
      else:
        break
    max_length = max(max_length, len(sub_string))
  return max_length

def find_longest_substring_sliding_window(string):
  max_length = 0
  left = 0
  right = 0
  char_set = set()

  while right < len(string):
    if string[right] not in char_set:
      char_set.add(string[right])
      max_length = max(max_length, right - left + 1)
      right += 1
    else:
      char_set.remove(string[left])
      left += 1

  return max_length

if __name__ == "__main__":
  string = "abcabcbb"
  print(f"暴力法：{find_longest_substring_brute_force(string)}")
  print(f"滑动窗口法：{find_longest_substring_sliding_window(string)}")

Java

public class LongestSubstringWithoutRepeatingCharacters {

    public int findLongestSubstringBruteForce(String string) {
        int maxLength = 0;
        for (int i = 0; i < string.length(); i++) {
            String subString = "";
            for (int j = i; j < string.length(); j++) {
                if (!subString.contains(String.valueOf(string.charAt(j)))) {
                    subString += string.charAt(j);
                } else {
                    break;
                }
            }
            maxLength = Math.max(maxLength, subString.length());
        }
        return maxLength;
    }

    public int findLongestSubstringSlidingWindow(String string) {
        int maxLength = 0;
        int left = 0;
        int right = 0;
        Set<Character> charSet = new HashSet<>();

        while (right < string.length()) {
            if (!charSet.contains(string.charAt(right))) {
                charSet.add(string.charAt(right));
                maxLength = Math.max(maxLength, right - left + 1);
                right++;
            } else {
                charSet.remove(string.charAt(left));
                left++;
            }
        }

        return maxLength;
    }

    public static void main(String[] args) {
        String string = "abcabcbb";
        LongestSubstringWithoutRepeatingCharacters solution = new LongestSubstringWithoutRepeatingCharacters();
        System.out.println("暴力法：" + solution.findLongestSubstringBruteForce(string));
        System.out.println("滑动窗口法：" + solution.findLongestSubstringSlidingWindow(string));
    }
}

C++

#include <iostream>
#include <string>
#include <set>

using namespace std;

int findLongestSubstringBruteForce(string string) {
  int maxLength = 0;
  for (int i = 0; i < string.length(); i++) {
    string subString = "";
    for (int j = i; j < string.length(); j++) {
      if (subString.find(string[j]) == string::npos) {
        subString += string[j];
      } else {
        break;
      }
    }
    maxLength = max(maxLength, (int)subString.length());
  }
  return maxLength;
}

int findLongestSubstringSlidingWindow(string string) {
  int maxLength = 0;
  int left = 0;
  int right = 0;
  set<char> charSet;

  while (right < string.length()) {
    if (charSet.find(string[right]) == charSet.end()) {
      charSet.insert(string[right]);
      maxLength = max(maxLength, right - left + 1);
      right++;
    } else {
      charSet.erase(string[left]);
      left++;
    }
  }

  return maxLength;
}

int main() {
  string string = "abcabcbb";
  cout << "暴力法：" << findLongestSubstringBruteForce(string) << endl;
  cout << "滑动窗口法：" << findLongestSubstringSlidingWindow(string) << endl;
  return 0;
}