Java算法——字符串
344. 反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 1：
输入：s = ["h","e","l","l","o"] 输出：["o","l","l","e","h"]
class Solution {
public void reverseString(char[] s) {
int len = s.length;
for(int left = 0,right = len-1;left < right;left++,right--) {
char tmp = s[left];
s[left] = s[right];
s[right] = tmp;
}
}
}
541. 反转字符串 II
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
- 如果剩余字符少于
k个，则将剩余字符全部反转。 - 如果剩余字符小于
2k但大于或等于k个，则反转前k个字符，其余字符保持原样。
示例 1：
输入：s = "abcdefg", k = 2 输出："bacdfeg"
class Solution {
public String reverseStr(String s, int k) {
int len = s.length();
char[] arr = s.toCharArray();
for (int i = 0;i < len; i += 2*k) {
reverse(arr,i,Math.min(i+k,len)-1);
}
return new String(arr);
}
public void reverse(char[] arr, int left, int right) {
while(left < right) {
char tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
left++;
right--;
}
}
}
class Solution {
public String reverseStr(String s, int k) {
StringBuilder sb = new StringBuilder();
int len = s.length();
int idx = 0;
while (idx < len) {
// 设置这次循环的尾索引
int end = Math.min(idx+k,len);
StringBuilder tmp = new StringBuilder(s.substring(idx,end));
// 只反转2k中的前k个
if ((idx/k) % 2 == 0) sb.append(tmp.reverse());
else sb.append(tmp);
idx = end;
}
return sb.toString();
}
}
443. 压缩字符串
给你一个字符数组 chars ，请使用下述算法压缩：
从一个空字符串 s 开始。对于 chars 中的每组 连续重复字符 ：
- 如果这一组长度为
1，则将字符追加到s中。 - 否则，需要向
s追加字符，后跟这一组的长度。
压缩后得到的字符串 s 不应该直接返回 ，需要转储到字符数组 chars 中。需要注意的是，如果组长度为 10 或 10 以上，则在 chars 数组中会被拆分为多个字符。
请在 修改完输入数组后 ，返回该数组的新长度。
你必须设计并实现一个只使用常量额外空间的算法来解决此问题。
示例 1：
输入：chars = ["a","a","b","b","c","c","c"] 输出：返回 6 ，输入数组的前 6 个字符应该是：["a","2","b","2","c","3"] 解释："aa" 被 "a2" 替代。"bb" 被 "b2" 替代。"ccc" 被 "c3" 替代。
示例 2：
输入：chars = ["a"] 输出：返回 1 ，输入数组的前 1 个字符应该是：["a"] 解释：唯一的组是“a”，它保持未压缩，因为它是一个字符。
示例 3：
输入：chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"] 输出：返回 4 ，输入数组的前 4 个字符应该是：["a","b","1","2"]。 解释：由于字符 "a" 不重复，所以不会被压缩。"bbbbbbbbbbbb" 被 “b12” 替代。
class Solution {
public int compress(char[] chars) {
int p = 0,q = 0,n = chars.length;
while(q < n) {
char cur = chars[q];
int cnt = 0;
while (q < n && cur == chars[q]) {
q++;
cnt++;
}
// 如果是单个字母也需要加数字‘1’的话，就在chars[p++] = cur;下加chars[p++] = ‘1’;
chars[p++] = cur;
if (cnt != 1) {
String s = String.valueOf(cnt);
char[] counter = s.toCharArray();
for (char c : counter) {
chars[p++] = c;
}
}
}
return p;
}
}
剑指 Offer 05. 替换空格
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1：
输入：s = "We are happy." 输出："We%20are%20happy."
class Solution {
public static String replaceSpace(String s) {
if (s == null) return s;
StringBuilder sb = new StringBuilder();
for(int i = 0;i < s.length();i++) {
if (s.charAt(i) == ' '){
sb.append("%20");
} else {
sb.append(s.charAt(i));
}
}
return sb.toString();
}
}
151. 反转字符串中的单词
给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
示例 1：
输入：s = "the sky is blue" 输出："blue is sky the"
示例 2：
输入：s = " hello world " 输出："world hello" 解释：反转后的字符串中不能存在前导空格和尾随空格。
示例 3：
输入：s = "a good example" 输出："example good a" 解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。
提示：
1 <= s.length <= 104s包含英文大小写字母、数字和空格' 's中 至少存在一个 单词
class Solution {
public String reverseWords(String s) {
if(s==null) return s;
char[] ch=s.toCharArray();//原
StringBuilder sb = new StringBuilder();//新
int i = ch.length-1;
while(i>=0){
while(i>=0&&ch[i]==' '){//跳过空格
i--;
}
int right=i;//记录单词结束位置
while(i>=0&&ch[i]!=' '){
i--;//找到单词起始位置
}
for(int j=i+1;j<=right;j++){//j从单词起始位置到结束位置
sb.append(ch[j]);
if(j == right){
sb.append(" ");//空格
}
}
}
return sb.substring(0,sb.length()-1);
}
}
剑指 Offer 58 - II. 左旋转字符串
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
示例 1：
输入: s = "abcdefg", k = 2 输出: "cdefgab"
示例 2：
输入: s = "lrloseumgh", k = 6 输出: "umghlrlose"
限制：
1 <= k < s.length <= 10000
class Solution { // 终极暴力，空间复杂度稍低
public String reverseLeftWords(String s, int n) {
StringBuilder sb = new StringBuilder();
char[] chars = s.toCharArray();
for (int i = n ;i < s.length();i++) {
sb.append(chars[i]);
}
for (int i = 0;i < n;i++) {
sb.append(chars[i]);
}
return sb.toString();
}
}
class Solution { // 两段拼接，时间复杂度低
public String reverseLeftWords(String s, int n) {
StringBuilder sb1 = new StringBuilder(s.substring(n,s.length()));
StringBuilder sb2 = new StringBuilder(s.substring(0,n));
String ans = sb1.append(sb2).toString();
return ans;
}
}
28. 找出字符串中第一个匹配项的下标
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1。
示例 1：
输入：haystack = "sadbutsad", needle = "sad" 输出：0 解释："sad" 在下标 0 和 6 处匹配。 第一个匹配项的下标是 0 ，所以返回 0 。
示例 2：
输入：haystack = "leetcode", needle = "leeto" 输出：-1 解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。
提示：
1 <= haystack.length, needle.length <= 104haystack和needle仅由小写英文字符组成
class Solution {
public int strStr(String ss, String pp) {
int n = ss.length(), m = pp.length();
char[] s = ss.toCharArray(), p = pp.toCharArray();
// 枚举原串的「发起点」
for (int i = 0; i <= n - m; i++) {
int a = i,b = 0;
// 从原串的「发起点」和匹配串的「首位」开始，尝试匹配
while (b < m && s[a] == p[b]) {
a++;
b++;
}
// 如果能够完全匹配，返回原串的「发起点」下标
if (b == m) return i;
}
return -1;
}
}
459. 重复的子字符串
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
示例 1:
输入: s = "abab" 输出: true 解释: 可由子串 "ab" 重复两次构成。
示例 2:
输入: s = "aba" 输出: false
示例 3:
输入: s = "abcabcabcabc" 输出: true 解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)
提示：
1 <= s.length <= 104s由小写英文字母组成
class Solution {
public boolean repeatedSubstringPattern(String s) {
int n = s.length();
for (int i = 1; i <= n/2;i++) {
if (n % i == 0) {
boolean match = true;
for (int j = i;j < n;j++) {
if (s.charAt(j) != s.charAt(j-i)) {
match = false;
break;
}
}
if (match) return true;
}
}
return false;
}
}
