Movle

public static void rotate(int[][] matrix){

    int n =matrix.length;

    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            int tmp=matrix[i][j];
            matrix[i][j]=matrix[j][i];
            matrix[j][i]=tmp;
        }
    }
    int mid = n/2;

    for(int i=0;i<n;i++){
        for(int j=0;j<mid;j++){
            int tmp = matrix[i][j];
            matrix[i][j]=matrix[i][n-j-1];
            matrix[i][n-j-1]=tmp;
        }
    }
}

/**
* 解法一 双指针法
* 新建两个指针i，j
* 新建一个StringBuilder sb
* 利用while循环，i为下表=标，从0开始遍历字符串S
* 令j=i;
* 判定字符串的第j的元素是否与第i个元素是否相等
* 若相等，则j指向下一位
* 否则将S的第i个元素添加到sb中
* 再将j-i 即重复字符的个数添加到sb中，
* 再将i指针指向j，进行下一个循环
* 循环结束后，将sb转换为String类型的字符串result
* 比较result和S的长度，返回较短的字符串
* 结束
*/
public static String compressString(String S){
    int j;
    int i=0;
    int N = S.length();
    StringBuilder sb = new StringBuilder();

    while(i<N){
        j=i;
        while(j<N && S.charAt(i)==S.charAt(j)){
            j++;
        }

        sb.append(S.charAt(i));
        sb.append(j-i);
        i=j;
    }

    String result = sb.toString();

    if(result.length()<S.length()){
        return result;
    }else {
        return S;
    }
}

/**
* 解题思路
* 首先验证两个字符串字符个数是否相差小于等于1，否则返回false
* 判定first是否为长字符串，否则将first替换为长字符串，保障first为长字符串
* 利用循环，判定字符串字符是否一样，若判定不一样，则跳过不同的字符串，截取长字符串frist的i+1位后的字符串，
* 若frist字符串长度与second字符串的长度相同，则截取second的第i+1位后的字符串，否则截取second的第i为字符串
* 判定截取后的frist的与second字符串是否相同，相同则返回true，否则返回false
*/

public static boolean oneEditAway(String first,String second){

   int len1 = first.length()
   int len2 = second.length();

   if(Math.abs(len1-len2)>1){
       return false;
   }

   if(len2>len1){
       String tem = first;
       first=second;
       second=tem;
    }
    int l1=first.length();
    int l2= second.length();

    for(int i=0;i<l2;i++){
        if(first.charAt(i) != second.charAt(i)){
            return first.substring(i+1).equals(second.substring(l1==l2?i+1:i));
        }else {
            return true;
        }
    }
    return true;
}

/**
* 思路：
* 每个字符出现的次数为偶数, 或者有且只有一个字符出现的次数为奇数时, 是回文的排列; 否则不是
* 利用HashSet中的元素不重复性质来判定
* 将字符串s转换成字符数组c1
* 新建一个HashSet set
* 利用循环将c1中的元素添加进set中
* 若添加成功，则说明之前没有添加，即第一次添加
* 若添加失败，则证明该元素在之前就已经添加过，所以将该元素移除即可
* 循环结束后，若set的元素个数为0或者1，则证明该字符串符合条件
* 否则不符合
*/
public static boolean canPermutePalindrome(String s) {

    Set<Character> set = new HashSet<Character>();

    char[] c1 = s.toCharArray();

    for(char c:c1){
        if(!set.add(c)){
            set.remove(c);
        }
    }
    return set.size()<=1;
}

class Solution {
    public boolean isUnique(String astr) {
        for (int i = 0; i < astr.length() - 1; i++) {
			for (int j = i + 1; j < astr.length(); j++) {
				if (astr.charAt(i) == astr.charAt(j)) {
					return false;
				}
			}
		}
		return true;
    }
}

public static boolean isUnique2(String astr) {

        Set set = new HashSet();

        for (int i = 0; i < astr.length(); i++) {
            set.add(astr.charAt(i));
        }

        if (set.size() == astr.length()) {
            return true;
        } else {
            return false;
        }
}

public static String replaceSpaces(String S,int length){
    StringBuilder sb = new StringBuilder();

    for(int i=0;i<length;i++){
       if(S.charAt(i)==' '){
           sb.append("%20");
       }else {
           sb.append(S.charAt(i));
       }
    }
    return sb.toString();
}

public static String replaceSpaces2(String S,int length){
    String s1 = S.substring(0,length);
    String s2 = S.replaceAll(" ","%20");
    return s2;
}

public boolean CheckPermutation(String s1, String s2) {
        //1.将字符串转换成数组
        char[] charArray1 = s1.toCharArray();
        char[] charArray2 = s2.toCharArray();

        //若两个字符串的长度不同，则肯定不能重排
        if(s1.length() != s2.length()){
            return false;
        }

        //给数组排序
        Arrays.sort(charArray1);
        Arrays.sort(charArray2);

        //将数组重新转换为字符串
        String c1 = String.copyValueOf(charArray1);
        String c2 = String.copyValueOf(charArray2);

        //比较两个字符串是否相等
        if(c1.equals(c2)){
            return true;
        }else{
            return false;
        }
}