算法通关村--第十二关白银挑战

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--;
        }
    }
}

 

class Solution {
    public void reverse(char[] array,int start,int end){
        while(start<end){
            char temp=array[start];
            array[start]=array[end];
            array[end]=temp;
            start++;
            end--;
        }
    }
    public String reverseStr(String s, int k) {
        int len=s.length();
        char[] array=s.toCharArray();
        int i=k;
        while(i<=len){
            if(i%k==0&&(i/k)%2!=0){
                reverse(array,i-1-k+1,i-1);
            i+=2*k;
            }
        }
        int rear=len;
        int remain=len%k;
        if(remain!=0&&((len-remain)/k)%2==0)
            reverse(array,len-remain,len-1);
        return new String(array);
    }
}

 

class Solution {//还是两个指针从两边向中间逼近，只是现在碰到了非字母的字符就跳过
    public void reverse(char[] array,int start,int end){
        while(start<end){
            if(!(array[start]>=65&&array[start]<=90||array[start]>=97&&array[start]<=122&&array[start]>=65)){
                start++;
            }
            if(!(array[end]>=65&&array[end]<=90||array[end]>=97&&array[end]<=122)){
                end--;
            }
            if((array[start]>=65&&array[start]<=90||array[start]>=97&&array[start]<=122&&array[end]>=65)&&(array[end]>=65&&array[end]<=90||array[end]>=97&&array[end]<=122)){
                char temp=array[start];
                array[start]=array[end];
                array[end]=temp;
                start++;
                end--;
            }
        }
    }
    public String reverseOnlyLetters(String s) {
        char[] array=s.toCharArray();
        int start=0;
        int end=0;
        reverse(array,0,array.length-1);
        return new String(array);
    }
}

 

class Solution {//单词翻转和前面的思路不一样，要把单词看成一个单位，那就从字符串末尾开始找单词，每找到一个单词就拼接到ans字符串后面。
    public String reverseWords(String s) {
        s=s.trim();
        int word_start=s.length()-1;
        int word_end=s.length()-1;
        String ans=new String();
        while(word_start>=0){
            while(word_start>=0&&s.charAt(word_start)!=' ')
                word_start--;
            ans+=s.substring(word_start+1,word_end+1)+" ";
            word_end=word_start;
            while(word_end>=0&&s.charAt(word_end)==' ')
                word_end--;
            word_start=word_end;
        }
        return ans.trim();
    }
}

 

class Solution {
    public boolean isPalindrome(String s) {
        int left=0;
        int right=s.length()-1;
        while(left<right){
            while(!Character.isLetter(s.charAt(left))&&!Character.isDigit(s.charAt(left))&&left<right)
                left++;
            while(!Character.isLetter(s.charAt(right))&&!Character.isDigit(s.charAt(right))&&left<right)
                right--;  
            char chra1=s.charAt(left);
            char chra2=s.charAt(right);
            if(chra1!=chra2&&Character.isLetter(chra1)&&Character.isLetter(chra2)&&left<right){
                if((chra1+32)!=chra2){
                    if(chra1!=(chra2+32))
                        return false;
                }
            }
            else if((!Character.isLetter(chra1)||!Character.isLetter(chra2))&&left<right&&chra1!=chra2) 
                return false;
            left++;
            right--;            
        }
        return true;
    }
}

 

 

 

class Solution {//利用哈希
    public int firstUniqChar(String s) {
        HashMap<Character,Integer> map=new HashMap<Character,Integer>();
        for(int i=0;i<s.length();i++){
            char ch=s.charAt(i);
            if(map.containsKey(ch))
                map.replace(ch,map.get(ch)+1);
            else 
                map.put(ch,1);
        }
        for(int i=0;i<s.length();i++){
            char ch=s.charAt(i);
            if(map.get(ch)==1)
                return i;
        }
        return -1;
    }
}

 

class Solution {
    public boolean isAnagram(String s, String t) {
        char[] arr1=s.toCharArray();
        char[] arr2=t.toCharArray();
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        return new String (arr1).equals(new String(arr2));
    }
}