边写边更中
Day9花了我好长时间，由于一道题有好几种方法，感觉今天上午下午都在做Day9，心态有点崩，因为今天还没有时间科研。
我决定休息一下，先更到这里。
气死我了
151.翻转字符串里的单词
方法1_fff：
定义一个新的字符串str，遍历s，从后往前找到每个单词添加到str中
class Solution {
public String reverseWords(String s) {
// 方法1_fff
StringBuffer str = new StringBuffer();
int left = s.length() - 1;
int right = s.length() - 1;
while (left >= 0) {
if (s.charAt(left) == ' ' && s.charAt(right) == ' ') {
left--;
right--;
} else {
left--;
if (left == -1 || s.charAt(left) == ' ') {
str.append(s.substring(left + 1, right + 1)).append(' ');
right = left;
}
}
}
s = str.toString();
s = s.substring(0, s.length() - 1);
return s;
}
}方法2：
不使用辅助空间，空间复杂度要求为O(1)；不使用Java内置方法实现
思路：移除多余空格，将s整体反转，再将每个单词反转
（注意注释部分，为自己迷糊的内容，后续进行了学习。）
注意1：
//压缩字符串中间的多个连续空格为一个空格
//sb.charAt(sb.length() - 1) != ' ')：当前字符 c 是空格，但 sb 中最后一个字符不是空格。
注意2：
StringBuilder的函数：
// void setCharAt(int index, char ch)
// 将给定索引处的字符设置为 ch
class Solution {
public String reverseWords(String s) {
// 方法2：不使用辅助空间，空间复杂度要求为O(1)
/**
* 不使用Java内置方法实现
* 1.去除首尾以及中间多余空格
* 2.反转整个字符串
* 3.反转各个单词
*/
StringBuilder sb = removeSpace(s);
reverseString(sb, 0, sb.length() - 1);
reverseEachWorld(sb);
return sb.toString();
}
//去除首尾和中间多余空格
private StringBuilder removeSpace(String s) {
int start = 0;
int end = s.length() - 1;
//去掉字符串开头和结尾的空格
while (s.charAt(start) == ' ') {
start++;
}
while (s.charAt(end) == ' ') {
end--;
}
StringBuilder sb = new StringBuilder();
while (start <= end) {
char c = s.charAt(start);
//压缩字符串中间的多个连续空格为一个空格
//sb.charAt(sb.length() - 1) != ' ')：当前字符 c 是空格，但 sb 中最后一个字符不是空格。
if (c != ' ' || sb.charAt(sb.length() - 1) != ' ') {
sb.append(c);
}
start++;
}
return sb;
}
//反转字符串指定区间[start, end]的字符
public void reverseString(StringBuilder sb, int start, int end) {
while (start < end) {
char temp = sb.charAt(start);
// void setCharAt(int index, char ch)
// 将给定索引处的字符设置为 ch
sb.setCharAt(start, sb.charAt(end));
sb.setCharAt(end, temp);
start++;
end--;
}
}
//反转各个单词
private void reverseEachWorld(StringBuilder sb) {
int start = 0;
int end = 1;
int n = sb.length();
while (start < n) {
while (end < n && sb.charAt(end) != ' ') {
end++;
}
reverseString(sb, start, end - 1);
start = end + 1;
end = start + 1;
}
}
}方法3：
创建新字符数组填充。时间复杂度O(n)
class Solution {
public String reverseWords(String s) {
// 方法3：创建新字符数组填充。时间复杂度O(n)
//源字符数组
char[] initialArr = s.toCharArray();
//新字符数组
char[] newArr = new char[initialArr.length + 1];
int newArrPos = 0;
//i来进行整体对源字符数组从后往前遍历
int i = initialArr.length - 1;
while (i >= 0) {
while (i >= 0 && initialArr[i] == ' ') {
i--;
} //跳过空格
//此时i位置是边界或!=空格，先记录当前索引，之后的while用来确定单词的首字母的位置
int right = i;
while (i >= 0 && initialArr[i] != ' ') {
i--;
}
//指定区间单词取出(由于i为首字母的前一位，所以这里+1,)，取出的每组末尾都带有一个空格
for (int j = i + 1; j <= right; j++) {
newArr[newArrPos++] = initialArr[j];
if (j == right) {
newArr[newArrPos++] = ' ';//空格
}
}
}
//若是原始字符串没有单词，直接返回空字符串；若是有单词，返回0-末尾空格索引前范围的字符数组(转成String返回)
if (newArrPos == 0) {
return "";
} else {
return new String(newArr, 0, newArrPos - 1);
}
}
方法4：
与方法2思路类似。
System.arraycopy(chars, 0, newChars, 0, slow);
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
其中：src表示源数组，srcPos表示源数组要复制的起始位置，desc表示目标数组，length表示要复制的长度。
/*
* 方法4：时间复杂度 O(n)
* 参考之前的三步骤：先移除多余空格，再将整个字符串反转，最后把单词逐个反转
* 有别于方法2：没有用 StringBuilder 实现，而是对 String 的 char[] 数组操作来实现以上三个步骤
*/
class Solution {
//用 char[] 来实现 String 的 removeExtraSpaces，reverse 操作
public String reverseWords(String s) {
char[] chars = s.toCharArray();
//1.去除首尾以及中间多余空格
chars = removeExtraSpaces(chars);
//2.整个字符串反转
reverse(chars, 0, chars.length - 1);
//3.单词反转
reverseEachWord(chars);
return new String(chars);
}
//1.用 快慢指针 去除首尾以及中间多余空格，可参考数组元素移除的题解
public char[] removeExtraSpaces(char[] chars) {
int slow = 0;
for (int fast = 0; fast < chars.length; fast++) {
//先用 fast 移除所有空格
if (chars[fast] != ' ') {
//在用 slow 加空格。 除第一个单词外，单词末尾要加空格
if (slow != 0)
chars[slow++] = ' ';
//fast 遇到空格或遍历到字符串末尾，就证明遍历完一个单词了
while (fast < chars.length && chars[fast] != ' ')
chars[slow++] = chars[fast++];
}
}
//相当于 c++ 里的 resize()
char[] newChars = new char[slow];
System.arraycopy(chars, 0, newChars, 0, slow);
return newChars;
}
//双指针实现指定范围内字符串反转，可参考字符串反转题解
public void reverse(char[] chars, int left, int right) {
if (right >= chars.length) {
System.out.println("set a wrong right");
return;
}
while (left < right) {
chars[left] ^= chars[right];
chars[right] ^= chars[left];
chars[left] ^= chars[right];
left++;
right--;
}
}
//3.单词反转
public void reverseEachWord(char[] chars) {
int start = 0;
//end <= s.length() 这里的 = ，是为了让 end 永远指向单词末尾后一个位置，这样 reverse 的实参更好设置
for (int end = 0; end <= chars.length; end++) {
// end 每次到单词末尾后的空格或串尾,开始反转单词
if (end == chars.length || chars[end] == ' ') {
reverse(chars, start, end - 1);
start = end + 1;
}
}
}
}卡码网：55.右旋转字符串
方法1_fff：
通过StringBuffer开辟一个新的sb对象，直接拼接所需要的字符串。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int k = sc.nextInt();
String s = sc.next();
int n = s.length() - k;
StringBuffer sb = new StringBuffer();
sb.append(s.substring(n)).append(s.substring(0, n));
System.out.println(sb.toString());
}
}方法2：
不申请额外空间，只在本串上操作。 （这句话有点歧义，JAVA中不能修改String，因此还是会申请额外空间）
思路：通过 整体倒叙，把两段子串顺序颠倒，两个段子串里的的字符再倒叙一把，负负得正，这样就不影响子串里面字符的顺序了。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int k = sc.nextInt();
String s = sc.next();
int n = s.length();
char[] chars = s.toCharArray();
reverseString(chars, 0, n-1);
reverseString(chars, 0, k-1);
reverseString(chars, k, n-1);
System.out.println(chars);
}
public static void reverseString(char[] ch, int start, int end){
while(start < end){
char temp = ch[start];
ch[start] = ch[end];
ch[end] = temp;
start++;
end--;
}
}
}// 版本一：先反转整体，再分别反转子字符串
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = Integer.parseInt(in.nextLine());
String s = in.nextLine();
int len = s.length(); //获取字符串长度
char[] chars = s.toCharArray();
reverseString(chars, 0, len - 1); //反转整个字符串
reverseString(chars, 0, n - 1); //反转前一段字符串，此时的字符串首尾尾是0,n - 1
reverseString(chars, n, len - 1); //反转后一段字符串，此时的字符串首尾尾是n,len - 1
System.out.println(chars);
}
public static void reverseString(char[] ch, int start, int end) {
//异或法反转字符串，参照题目 344.反转字符串的解释
while (start < end) {
ch[start] ^= ch[end];
ch[end] ^= ch[start];
ch[start] ^= ch[end];
start++;
end--;
}
}
}
// 版本二：先分别反转子字符串，再反转整体。
// 注意：字符串首位会发生变化
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = Integer.parseInt(in.nextLine());
String s = in.nextLine();
int len = s.length(); //获取字符串长度
char[] chars = s.toCharArray();
reverseString(chars, 0, len - n - 1); //反转前一段字符串，此时的字符串首尾是0,len - n - 1
reverseString(chars, len - n, len - 1); //反转后一段字符串，此时的字符串首尾是len - n,len - 1
reverseString(chars, 0, len - 1); //反转整个字符串
System.out.println(chars);
}
public static void reverseString(char[] ch, int start, int end) {
//异或法反转字符串，参照题目 344.反转字符串的解释
while (start < end) {
ch[start] ^= ch[end];
ch[end] ^= ch[start];
ch[start] ^= ch[end];
start++;
end--;
}
}
}28. 实现 strStr()
1.KMP算法
KMP的经典思想就是：当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。KMP主要应用在字符串匹配上。
-
什么是KMP
KMP是由这三位学者发明的：Knuth，Morris和Pratt，所以取了三位学者名字的首字母。
-
什么是前缀表
next数组就是一个前缀表（prefix table）。
前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。
eg：要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。
前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，再重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。
那么什么是前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。
-
最长公共前后缀（最长相等前后缀）
字符串的前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。
字符串的后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。
前缀表要求的就是相同前后缀的长度。
eg：字符串a的最长相等前后缀为0。 字符串aa的最长相等前后缀为1。 字符串aaa的最长相等前后缀为2。
-
为什么一定要用前缀表
匹配的过程在下标5的地方遇到不匹配，模式串是指向f。然后就找到了下标2，指向b，继续匹配。
下标5之前这部分的字符串（也就是字符串aabaa）的最长相等的前缀 和 后缀字符串是 子字符串aa ，因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀的后面重新匹配就可以了。
-
如何计算前缀表
由下图可以看出模式串与前缀表对应位置的数字表示的就是：下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。
如何利用 前缀表找到 当字符不匹配的时候应该指针应该移动的位置？
要看前一位的前缀表的数值。（因为要找前面字符串的最长相同的前缀和后缀。）
eg中前一个字符的前缀表的数值是2， 所以把下标移动到下标2的位置b继续匹配。
最后就在文本串中找到了和模式串匹配的子串了。
-
前缀表与next数组
next数组既可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1），取决于具体实现。
-
时间复杂度分析
其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。
暴力的解法显而易见是O(n × m)，所以KMP在字符串匹配中极大地提高了搜索的效率。
使用KMP算法，一定要构造next数组。
-
构造next数组
定义一个函数getNext来构建next数组，函数参数为指向next数组的指针，和一个字符串。
void getNext(int* next, const string& s)构造next数组其实就是计算模式串 s 前缀表的过程。 主要有如下三步：
- 初始化
- 处理前后缀不相同的情况
- 处理前后缀相同的情况
详解如下：
1. 初始化：
定义两个指针 i 和 j，j 指向前缀末尾位置，i 指向后缀末尾位置。
然后还要对next数组进行初始化赋值，如下：
int j = -1;
next[0] = j;j 为什么要初始化为 -1呢，因为之前说过 前缀表要统一减一的操作仅仅是其中的一种实现，我们这里选择 j 初始化为-1，下文我还会给出 j 不初始化为-1的实现代码。
next[i] 表示 i（包括i）之前最长相等的前后缀长度（其实就是 j ）
所以初始化next[0] = j 。
2. 处理前后缀不相同的情况
因为 j 初始化为-1，那么 i 就从1开始，进行s[i] 与 s[j+1]的比较。
所以遍历模式串s的循环下标 i 要从 1 开始，代码如下：
for (int i = 1; i < s.size(); i++) {如果 s[i] 与 s[j+1]不相同，也就是遇到 前后缀末尾不相同的情况，就要向前回退。
next[j]就是记录着j（包括j）之前的子串的相同前后缀的长度。
那么 s[i] 与 s[j+1] 不相同，就要找 j+1前一个元素在next数组里的值（就是next[j]）。
所以，处理前后缀不相同的情况代码如下：
while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
j = next[j]; // 向前回退
}3. 处理前后缀相同的情况
如果 s[i] 与 s[j + 1] 相同，那么就同时向后移动 i 和 j 说明找到了相同的前后缀，同时还要将 j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。
if (s[i] == s[j + 1]) { // 找到相同的前后缀
j++;
}
next[i] = j;最后整体构建next数组的函数代码如下：
void getNext(int* next, const string& s){
int j = -1;
next[0] = j;
for(int i = 1; i < s.size(); i++) { // 注意i从1开始
while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
j = next[j]; // 向前回退
}
if (s[i] == s[j + 1]) { // 找到相同的前后缀
j++;
}
next[i] = j; // 将j（前缀的长度）赋给next[i]
}
}得到了next数组之后，就要用这个来做匹配了。
- 使用next数组来做匹配
在文本串s里找是否出现过模式串t。
本题要在文本串字符串中找出模式串出现的第一个位置 (从0开始)，所以返回当前在文本串匹配模式串的位置i 减去 模式串的长度，就是文本串字符串中出现模式串的第一个位置。
使用next数组，用模式串匹配文本串的整体代码如下：
int j = -1; // 因为next数组里记录的起始位置为-1
for (int i = 0; i < s.size(); i++) { // 注意i就从0开始
while(j >= 0 && s[i] != t[j + 1]) { // 不匹配
j = next[j]; // j 寻找之前匹配的位置
}
if (s[i] == t[j + 1]) { // 匹配，j和i同时向后移动
j++; // i的增加在for循环里
}
if (j == (t.size() - 1) ) { // 文本串s里出现了模式串t
return (i - t.size() + 1);
}
}2.Java实现
方法1：暴力解法
两层循环嵌套进行匹配查询。
class Solution {
public int strStr(String haystack, String needle) {
/**
方法1：暴力解
牺牲空间，换取最直白的暴力法
时间复杂度 O(n * m)
空间 O(n + m)
*/
// 获取 haystack 和 needle 的长度
int n = haystack.length(), m = needle.length();
// 将字符串转换为字符数组，方便索引操作
char[] s = haystack.toCharArray(), p = needle.toCharArray();
// 遍历 haystack 字符串
for (int i = 0; i < n-m+1; i++) {
// 初始化匹配的指针
int a = i, b = 0;
// 循环检查 needle 是否在当前位置开始匹配
while (b < m && s[a] == p[b]){
// 如果当前字符匹配，则移动指针
a++;
b++;
}
// 如果 b 等于 m，说明 needle 已经完全匹配，返回当前位置 i
if (b == m){
return i;
}
}
// 如果遍历完毕仍未找到匹配的子串，则返回 -1
return -1;
}
}