跟孙哥学java
反转的问题
反转字符串
反转字符串 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。 不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 1： 输入：s = ["h","e","l","l","o"] 输出：["o","l","l","e","h"] 示例 2： 输入：s = ["H","a","n","n","a","h"] 输出：["h","a","n","n","a","H"]
class Solution {
public void reverseString(char[] s) {
int len = s.length-1;
for (int i = 0; i < s.length/2; i++) {
char temp=s[i];
s[i]=s[len-i];
s[len-i]=temp;
}
}
}
K个一组反转
K个一组反转 给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
- 如果剩余字符少于 k 个，则将剩余字符全部反转。
- 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例 1： 输入：s = "abcdefg", k = 2 输出："bacdfeg" 示例 2： 输入：s = "abcd", k = 2 输出："bacd"
class Solution {
public static void main(String[] args) {
String str="abcdefg";
System.out.println(reverseStr(str, 2));
}
public static String reverseStr(String s, int k) {
char[] chars = s.toCharArray();
int len = chars.length;
int l=0;
while (len>=2*k){
reverse(chars,l,l+k-1);
l=l+2*k;
len=len-2*k;
}
if(len>=k){
reverse(chars,l,l+k-1);
}else {
reverse(chars,l,s.length()-1);
}
return new String(chars);
}
public static void reverse(char[] chars,int l,int r){
while (l<r){
char temp=chars[l];
chars[l]=chars[r];
chars[r]=temp;
l++;
r--;
}
}
}
仅仅反转字母
双指针
class Solution {
public String reverseOnlyLetters(String s) {
char[] chars = s.toCharArray();
int l=0;
int r=s.length()-1;
while (l<r){
while (l<r&&!Character.isLetter(chars[l])){
l++;
}
while (l<r&&!Character.isLetter(chars[r])){
r--;
}
if(Character.isLetter(chars[l])&&Character.isLetter(chars[r])&&l<r){
char temp=chars[l];
chars[l]=chars[r];
chars[r]=temp;
l++;
r--;
}
}
return new String(chars);
}
}
反转字符串里的单词
class Solution {
public String reverseWords(String s) {
StringBuilder sb=new StringBuilder();
int r=s.length();
for(int i=r-1;i>=0;i--){
if(s.charAt(i)==' '){
if(i!=r-1){
String str=s.substring(i+1,r);
sb.append(str);
sb.append(' ');
}
r=i;
}
}
if(s.charAt(0)!=' '){
String str=s.substring(0,r);
sb.append(str);
}else {
sb= new StringBuilder(sb.substring(0, sb.length() - 1));
}
return sb.toString();
}
}
验证回文串
验证回文串 LeetCode.125.给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小 写。说明：本题中，我们将空字符串定义为有效的回文串。
class Solution {
public static void main(String[] args) {
System.out.println(isPalindrome("A man, a plan, a canal: Panama"));
}
public static boolean isPalindrome(String s) {
StringBuilder sb=new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if(Character.isDigit(s.charAt(i))){
sb.append(s.charAt(i));
}
if(Character.isLetter(s.charAt(i))){
sb.append(Character.toLowerCase(s.charAt(i)));
}
}
s=sb.toString();
sb.reverse();
return sb.toString().equals(s);
}
}
class Solution {
public static void main(String[] args) {
System.out.println(isPalindrome("A man, a plan, a canal: Panama"));
}
public static boolean isPalindrome(String s) {
char[] chars = s.toCharArray();
int l=0;
int r=chars.length-1;
while (l<r){
while (l<r&&!isValid(chars[l])){
l++;
}
while (l<r&&!isValid(chars[r])){
r--;
}
if(l<r&&isValid(chars[l])&&isValid(chars[r])){
if(Character.toLowerCase(chars[l])!=Character.toLowerCase(chars[r])){
return false;
}
}
l++;
r--;
}
return true;
}
private static boolean isValid(char c) {
return Character.isLetter(c)||Character.isDigit(c);
// Character.toLowerCase()
}
}
字符串中第一个唯一字符
class Solution {
public int firstUniqChar(String s) {
char[] chars = s.toCharArray();
int l=0;
HashMap<Character,Integer> hashMap=new HashMap<>();
for (int i = 0; i < chars.length; i++) {
hashMap.put(chars[i],hashMap.getOrDefault(chars[i],0)+1);
}
for (int i = 0; i < chars.length; i++) {
Integer integer = hashMap.get(chars[i]);
if(integer==1){
return i;
}
}
return -1;
}
}
判断是否互为字符重排
class Solution {
public boolean isAnagram(String s, String t) {
char[] sCharArray = s.toCharArray();
char[] tCharArray = t.toCharArray();
Arrays.sort(sCharArray);
Arrays.sort(tCharArray);
return new String(tCharArray).equals(new String(sCharArray));
}
}
