持续更新中..................
344. 反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例1：输入：s = ["h","e","l","l","o"] 输出：["o","l","l","e","h"]
class Solution {
public void reverseString(char[] s) {
int left = 0;
int right = s.length - 1;
while(left < right){
char temp = s[left];
s[left] = s[right];
s[right] = temp;
left++;
right--;
}
}
}541. 反转字符串II
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。如果剩余字符少于 k 个，则将剩余字符全部反转。如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例1：输入：s = "abcdefg", k = 2 输出："bacdfeg"
//执行用时：0 ms
class Solution {
public String reverseStr(String s, int k) {
char[] chars = s.toCharArray();
for(int i = 0; i < chars.length; i += 2 * k){
if(i + k <= chars.length){
reverse(chars, i, i + k - 1);
}else{
reverse(chars, i, chars.length-1);
}
}
return String.valueOf(chars);
}
public void reverse(char[] s, int left, int right) {
while(left < right){
char temp = s[left];
s[left] = s[right];
s[right] = temp;
left++;
right--;
}
}
}//执行用时：1 ms
class Solution {
public String reverseStr(String s, int k) {
char[] chars = s.toCharArray();
for(int i = 0; i < chars.length; i += 2 * k){
int start = i;
int end = Math.min(chars.length - 1, start + k - 1);
while(start < end){
char temp = chars[start];
chars[start] = chars[end];
chars[end] = temp;
start++;
end--;
}
}
return String.valueOf(chars);
}
}剑指Offer 05. 替换空格
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例1：输入：s = "We are happy." 输出："We%20are%20happy."
class Solution {
public String replaceSpace(String s) {
if(s == null && s.length() == 0){
return s;
}
StringBuilder str = new StringBuilder();
for(int i = 0; i < s.length(); i++){
if(s.charAt(i) == ' '){
str.append("%20");
}else{
str.append(s.charAt(i));
}
}
return str.toString();
}
}//双指针法
class Solution {
public String replaceSpace(String s) {
if(s == null && s.length() == 0){
return s;
}
//扩充空间的大小
int zeroLen = 0;
for(int i = 0; i < s.length(); i++){
if(s.charAt(i) == ' '){
zeroLen += 2;
}
}
int newLen = s.length() + zeroLen;
int left = s.length() - 1; //左指针：指向原始字符串最后一个位置
int right = newLen - 1; //右指针：指向扩展字符串的最后一个位置
char[] chars = new char[newLen];
//从后往前遍历
while(left >= 0){
if(s.charAt(left) == ' '){
chars[right--] = '0';
chars[right--] = '2';
chars[right] = '%';
}else{
chars[right] = s.charAt(left);
}
left--;
right--;
}
return String.valueOf(chars);
}
}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"
//执行用时：8 ms
class Solution {
public String reverseWords(String s) {
//1.去除首尾以及中间多余空格
StringBuilder sb = removeSpace(s);
//2.反转整个字符串
reverseString(sb, 0, sb.length() - 1);
// 3.反转各个单词
reverseEachWord(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);
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);
sb.setCharAt(start, sb.charAt(end));
sb.setCharAt(end, temp);
start++;
end--;
}
}
//反转各个单词
private void reverseEachWord(StringBuilder sb) {
int start = 0;
for(int end = 1; end <= sb.length(); end++) {
if(end == sb.length() || sb.charAt(end) == ' '){
reverseString(sb, start, end - 1);
start = end + 1;
}
}
}
}//执行用时：1 ms, 在所有 Java 提交中击败了100.00%的用户
class Solution {
public String reverseWords(String s) {
char[] chars = s.toCharArray();
char[] result = new char[chars.length + 1];
int index = chars.length - 1;
int newIndex = 0;
while(index >= 0){
//去除右侧空格
while(index >= 0 && chars[index] == ' '){
index--;
}
//单词结尾
int right = index;
//单词开始
while(index >= 0 && chars[index] != ' '){
index--;
}
int left = index + 1;
for(int i = left; i <= right; i++){
result[newIndex++] = chars[i];
if(i == right){
result[newIndex++] = ' ';
}
}
}
return new String(result, 0, newIndex - 1);
}
}剑指Offer58-II.左旋转字符串
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
示例1：输入: s = "abcdefg", k = 2 输出: "cdefgab"
class Solution {
public String reverseLeftWords(String s, int n) {
char[] chars = s.toCharArray();
reverse(chars, 0, chars.length - 1); //反转整个字符串
reverse(chars, 0, chars.length - 1 - n); //反转前n个
reverse(chars, chars.length -n, chars.length - 1); //反转剩余的
return String.valueOf(chars);
}
public void reverse(char[] s, int left, int right) {
while(left < right){
char temp = s[left];
s[left] = s[right];
s[right] = temp;
left++;
right--;
}
}
}189. 轮转数组
给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
示例1：输入: nums = [1,2,3,4,5,6,7], k = 3 输出: [5,6,7,1,2,3,4]
示例2：输入：nums = [-1,-100,3,99], k = 2 输出：[3,99,-1,-100]
class Solution {
public void rotate(int[] nums, int k) {
k = k % nums.length;
reverse(nums, 0, nums.length - 1);
reverse(nums, 0, k - 1);
reverse(nums, k, nums.length - 1);
}
public void reverse(int[] nums, int left, int right) {
while(left < right){
int temp = nums[left];
nums[left] = nums[right];
nums[right] = temp;
left++;
right--;
}
}
}925. 长按键入
你的朋友正在使用键盘输入他的名字 name。偶尔，在键入字符 c 时，按键可能会被长按，而字符可能被输入 1 次或多次。你将会检查键盘输入的字符 typed。如果它对应的可能是你的朋友的名字（其中一些字符可能被长按），那么就返回 True。
示例1：输入：name = "alex", typed = "aaleex" 输出：true
示例2：输入：name = "saeed", typed = "ssaaedd" 输出：false
class Solution {
public boolean isLongPressedName(String name, String typed) {
int i = 0;
int j = 0;
while(j < typed.length()){
if(i < name.length() && name.charAt(i) == typed.charAt(j)){
i++;
j++;
}else if(j > 0 && typed.charAt(j) == typed.charAt(j - 1)){
j++;
}else{
return false;
}
}
return i == name.length();
}
}3. 无重复字符的最长子串
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
示例：输入: s = "abcabcbb" 输出: 3
class Solution {
public int lengthOfLongestSubstring(String s) {
Map<Character, Integer> map = new HashMap<>();
int max = 0;
int left = 0;
for(int i = 0; i < s.length(); i ++){
char c = s.charAt(i);
if(map.containsKey(c)){
left = Math.max(left, map.get(c) + 1);
}
map.put(c, i);
max = Math.max(max, i - left + 1);
}
return max;
}
}class Solution {
public int lengthOfLongestSubstring(String s) {
Set<Character> set = new HashSet<>();
int left = 0;
int max = 0;
for(int i = 0; i < s.length(); i++){
char c = s.charAt(i);
while(set.contains(c)){
set.remove(s.charAt(left));
left++;
}
set.add(c);
max = Math.max(max, set.size());
}
return max;
}
}class Solution {
public int lengthOfLongestSubstring(String s) {
int maxLen = 0;
Deque<Character> deque = new LinkedList<>();
for(int i = 0; i < s.length(); i++){
char c = s.charAt(i);
while(deque.contains(c)){
deque.pollFirst();
}
deque.offerLast(c);
maxLen = Math.max(maxLen, deque.size());
}
return maxLen;
}
}402. 移掉K位数字
给你一个以字符串表示的非负整数 num 和一个整数 k ，移除这个数中的 k 位数字，使得剩下的数字最小。请你以字符串形式返回这个最小的数字。
示例：输入：num = "1432219", k = 3 输出："1219"
示例：输入：num = "10200", k = 1 输出："200"
示例：输入：num = "10", k = 2 输出："0"
class Solution {
public String removeKdigits(String num, int k) {
char[] stack = new char[num.length()];
int top = 0;
for(int i = 0; i < num.length(); i++){
char c = num.charAt(i);
while(k > 0 && top > 0 && stack[top - 1] > c){
k--;
top--;
}
stack[top++] = c;
}
top -= k;
int low = 0;
while(low < top && stack[low] == '0'){
low++;
}
return low == top ? "0" : new String(stack, low, top - low);
}
}class Solution {
public String removeKdigits(String num, int k) {
Deque<Character> deque = new LinkedList<>();
for(int i = 0; i < num.length(); i++){
char c = num.charAt(i);
while(k > 0 && !deque.isEmpty() && deque.peekLast() > c){
deque.pollLast();
k--;
}
deque.offerLast(c);
}
while(k > 0){
deque.pollLast();
k--;
}
while(!deque.isEmpty() && deque.peekFirst() == '0'){
deque.pollFirst();
}
String result = "";
while(!deque.isEmpty()){
result += deque.pollFirst();
}
return result == "" ? "0" : result;
}
}647. 回文子串
给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。
具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。
示例：输入：s = "aaa" 输出：6
class Solution {
public int countSubstrings(String s) {
int n = s.length();
int count = 0;
for(int i = 0; i < 2 * n - 1; i++){
int left = i / 2;
int right = left + i % 2;
while(left >= 0 && right < n && s.charAt(left) == s.charAt(right)){
left--;
right++;
count++;
}
}
return count;
}
}class Solution {
public int countSubstrings(String s) {
int result = 0;
for(int i = 0; i < s.length(); i++){
result += getCount(s, i, i);
result += getCount(s, i, i + 1);
}
return result;
}
public int getCount(String s, int left, int right){
int count = 0;
while(left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)){
left--;
right++;
count++;
}
return count;
}
}5. 最长回文子串
给你一个字符串 s，找到 s 中最长的回文子串。
示例：输入：s = "cbbd" 输出："bb"
class Solution {
public String longestPalindrome(String s) {
int start = 0;
int end = 0;
for(int i = 0; i < s.length(); i++){
int len1 = getLength(s, i, i);
int len2 = getLength(s, i, i + 1);
int len = Math.max(len1, len2);
if(len > end - start){
start = i - (len - 1) / 2;
end = i + len / 2;
}
}
return s.substring(start, end + 1);
}
public int getLength(String s, int left, int right){
while(left >=0 && right < s.length() && s.charAt(left) == s.charAt(right)){
left--;
right++;
}
return right - left - 1;
}
}28. 找出字符串中第一个匹配项的下标
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
示例1：输入：haystack = "sadbutsad", needle = "sad" 输出：0
示例2：输入：haystack = "leetcode", needle = "leeto" 输出：-1
//KMP算法
class Solution {
public int strStr(String haystack, String needle) {
int[] next = getNext(needle);
int j = 0;
for (int i = 0; i < haystack.length(); i++) {
while (j > 0 && needle.charAt(j) != haystack.charAt(i)){
j = next[j - 1];
}
if (needle.charAt(j) == haystack.charAt(i)){
j++;
}
if (j == needle.length()){
return i - needle.length() + 1;
}
}
return -1;
}
//生成前缀表
public int[] getNext(String s) {
int[] next = new int[s.length()];
next[0] = 0;
int j = 0;
for (int i = 1; i < s.length(); i++) {
while (j > 0 && s.charAt(j) != s.charAt(i)){
j = next[j - 1];
}
if (s.charAt(j) == s.charAt(i)){
j++;
}
next[i] = j;
}
return next;
}
}459. 重复的子字符串
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
示例1：输入: s = "abab" 输出: true
示例2：输入: s = "aba" 输出: false
数组长度减去最长相同前后缀的长度等于一个周期的长度，如果这个周期可以被整除，就说明整个数组就是这个周期的循环。
class Solution {
public boolean repeatedSubstringPattern(String s) {
int[] next = getNext(s);
int len = s.length();
if(next[len - 1] > 0 && len % (len - next[len - 1]) == 0){
return true;
}
return false;
}
public int[] getNext(String s){
int[] next = new int[s.length()];
next[0] = 0;
int j = 0;
for(int i = 1; i < next.length; i++){
while(j > 0 && s.charAt(j) != s.charAt(i)){
j = next[j - 1];
}
if(s.charAt(j) == s.charAt(i)){
j++;
}
next[i] = j;
}
return next;
}
}
503
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
