Leetcode(字符串)

---

---

字符串

1.如果你确实希望你的字符串是可变的，则可以使用 toCharArray 将其转换为字符数组。
2.如果你经常必须连接字符串，最好使用一些其他的数据结构，如 StringBuilder 。
3.当我们使用 == 时，它实际上会比较这两个对象是否是同一个对象。
4.字符串在java中创建就不可变。

14. 最长公共前缀

14. 最长公共前缀

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if(strs.length==0){
            return "";
        }
        String ans=strs[0];
        for(int i = 1; i < strs.length; i ++){
            int j = 0;
            for(; j < ans.length()&&j < strs[i].length(); j++){
                if(ans.charAt(j)!=strs[i].charAt(j)){
                    break;
                }
            }
            ans=ans.substring(0,j);
            if(ans.equals("")){
                return ans;
            }
        }
        return ans;
    }
}

总结

substring：
    substring(0,a)--->含头不含尾
    substring(a)--->删除前a个字符
数组.length
string.length()

5. 最长回文子串

5. 最长回文子串

暴力方法：
从len开始（每次往前移）{
	从第一个开始{
		方法
	}
}
方法{
	这段区间是否符合
}


因为每次都是从第一个到len，因此第一次得到的字串为最长


时间复杂度：
两层 for 循环 O(n²），for 循环里边判断是否为回文 O(n），所以时间复杂度为 O(n³）。
空间复杂度：O（1）

暴力代码

class Solution {
    public String longestPalindrome(String s) {
        for(int len = s.length(); len > 0; len --){
            for(int index = 0; index <= s.length()-len; index ++){
                if(isPalindrome(s,index,index+len-1)){
                    return s.substring(index,index+len);
                }
            }
        }
        return "";
    }

    private boolean isPalindrome(String s, int left , int right){
        while(left < right){
            if(s.charAt(left)!=s.charAt(right))return false;
            right--;
            left++;
        }
        return true;
    }
}

中心拓展法

中心拓展法就是从中间向外拓展，这道题目的中心就是回文子串的中心。用两个指针i和j，分别向前和向后遍历，如果两个指针的值不同，则停止遍历，如果相同，则代表一个回文字符串的诞生，继续遍历，直到边界。

知识点：
1.中心点确定
2.拓展

1.中心点:left和right指向的字符
中心点分为一个(aba)或两个(abba)
举例解释
总个数:2*len-1(len个单字符，len-1个双字符)
aba:[a,b,c,ab,ba]
[0,0],[1,1],[2,2],[0,1],[1,2]
abba:[a,b,b,a,ab,bb,ba]
[0,0],[1,1],[2,2],[3,3],[0,1],[1,2],[2,3]
这里的代码中的i和j是按照[0,0]、[0,1]、[1,1]、[1,2]、[2,2]交替前进的，那么它们就可以分别代表奇数长度的字符串和偶数长度的字符串的中心。可以给这种方法起个名字“奇偶中心法”。

思路

int n = s.length();
 
for(int k = 0; k < 2 * n - 1; k++)
{
    int i = k / 2；
    int j = k / 2 + k % 2;
 
    ·····
}

代码

class Solution {
    public int countSubstrings(String s) {
        int ant=0;
        for(int i = 0; i < 2*s.length()-1; i++){
            int l=i/2,r=l+i%2;
            while(l>=0&&r<s.length()&&s.charAt(l)==s.charAt(r)){
                --l;
                ++r;
                ++ant;
            }
        }
        return ant;
    }
}

剑指 Offer 58 - I. 翻转单词顺序

剑指 Offer 58 - I. 翻转单词顺序

总结

字符串数组
String[] str = new String[5]
trim()移除字符串两侧的空白字符或其他预定义字符
split("regex")将" "作为分隔符
当regex为①( ②[ ③{ ④/ ⑤^ ⑥- ⑦$ ⑧¦ ⑨} ⑩] ⑪ ) ⑫? ⑬* ⑭+ ⑮.等这些特殊字符时，需要在前面加上\\进行转义。
toString()将当前对象以字符串的形式返回

class Solution {
    public String reverseWords(String s) {
        String[] ss = s.trim().split(" ");
        StringBuilder result = new StringBuilder();
        for(int i = ss.length-1; i >= 0; i --){
            if(ss[i].equals(""))continue;
            result.append(ss[i]+" ");
        }
        return result.toString().trim();
    }
}

1078. Bigram 分词

1078. Bigram 分词

KMP

28. 实现 strStr()

28. 实现 strStr()

strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。

haystack.charAt(i).equals(needle.charAt(j))出错
原因：char为基本变量直接用==

BF算法(就是挨个比较)

class Solution {
    public int strStr(String haystack, String needle) {
        for(int n = 0; n <= haystack.length()-needle.length(); n ++){
            int i = n;
            for(int j = 0; j < needle.length(); j ++){
                if(haystack.charAt(i)==needle.charAt(j)){
                    i++;
                }
                else {
                    break;
                }
            }
            if(i==(n+needle.length())){
                return n;
            }
        }
        return -1;
    }
}

思路

int BF(char S[],char T[])
{
	int i=0,j=0;
	while(S[i]!='\0'&&T[j]!='\0')
	{
		if(S[i]==T[j])
		{
			i++;
			j++;
		}
		else
		{
			i=i-j+1;
			j=0;
		}
	}
	if(T[j]=='\0') return (i-j);      
	else return -1;     
}

KMP算法

每当从某个起始位置开始一趟比较后，在匹配过程中出现失配，不回溯i，而是利用已经得到的部分匹配结果，将一种假想的位置定位“指针”在模式上向右滑动尽可能远的一段距离到某个位置后，继续按规则进行下一次的比较。

明天补充