03无重复字符的最长子串

这个题目
首先来把字符串转换为数组
在Java里面将字符串转换为数组的方法
1.用tocharArray

char[] chars=s.tocharArray();

2.用split
假设[1,2,3,4,5]
char[] chars=s.split(',')
或者直接分割

String[] strArray = str.split("");

3.使用 Apache Commons Lang：
如果你可以使用外部库，Apache Commons Lang 的 StringUtils 类提供了一些方便的方法来处理字符串。

java

String[] strArray = StringUtils.splitByCharacterType(str);

第一遍

class Solution {

    public int lengthOfLongestSubstring(String s) {

        char[] chars=s.tocharArray();

        char[] compare=new char(chars.length);

        Arrays.fill(compare,"abc");

        int max=1,flag=1;

        if(chars.length==0)

        return 0;

        for(int i=0;i<chars.length;i++)

        {

            compare[0]=chars[i];

            int j=i+1;

            int temp=1;

            while(flag!=0)

            {

                for(int k=0;k<chars.length;k++)

                {

                    if(compare[k]==chars[j])

                    {

                        if(temp>max)

                        max=temp;

                        break;

                        break;

                    }

                }

                temp++;

                j++;

            }

        }

    }

}

第二遍

class Solution {

    public int lengthOfLongestSubstring(String s) {

        if (s == null || s.length() == 0) {

            return 0;

        }

        int max = 0;

        int start = 0; // 子串的起始索引

        HashMap<Character, Integer> map = new HashMap<>();

        for (int end = 0; end < s.length(); end++) {

            char currentChar = s.charAt(end);

            if (map.containsKey(currentChar)) {

                // 如果字符已存在，移动start到上一次出现的字符的下一个位置

                // 这里使用 Math.max 确保 start 不会向左移动

                //这里的更新位置是看那个字符串存在在hashmap中的位置去更新

                //滑动窗口和kmp算法

                start = Math.max(start, map.get(currentChar) + 1);

            }

            // 更新字符为最新的索引

            map.put(currentChar, end);

            // 更新最长子串的长度

            max = Math.max(max, end - start + 1);

        }

        return max;

    }

}

事实证明还是hashmap的contains好用

然后看二哥的代码是这样的

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int res = 0; // 用于存储最长子串的长度
        for (int i = 0; i < s.length(); i++) {
            boolean[] book = new boolean[256]; // 布尔数组，用于标记字符是否出现过
            
            // 内层循环，从当前字符向前遍历
            for (int j = i; j >= 0; j--) {
                // 如果字符已经在子串中出现过，则结束内层循环
                if (book[s.charAt(j)]) {
                    break;
                }
                // 标记当前字符为已出现过
                book[s.charAt(j)] = true;
                // 更新最长子串的长度
                res = Math.max(res, i - j + 1);
            }
        }
        return res; // 返回最长子串的长度
    }
}

这个代码比较厉害的点在于用boolean的数组标记去作为一个根据
也可以算的上用内存换时间的方法了

Math.abx(x)
Math.ceil(x)
Math.floor(x)
Math.round(x,y)
Math.min(x,y)
Math.pow(x,y)
Math.sqrt(x)
Math.sin(x)
Math.cos(x)
Math.tan(x)
Math.random()