程序员面试金典（java版）

一、字符串

1.1、确定字符互异

题目描述
请实现一个算法，确定一个字符串的所有字符是否全都不同。这里我们要求不允许使用额外的存储结构。
给定一个string iniString，请返回一个bool值,True代表所有字符全都不同，False代表存在相同的字符。保证字符串中的字符为ASCII字符。字符串的长度小于等于3000。

思路：Parition基于快速排序的partition，可以边排序边找重复，也即是每次partition之后，判断中间key元素与两边元素是否相同，相同则返回false，不同再进行下一轮partition.时间复杂度也是O(nlogn)，但要比排序速度快。

import java.util.*;

public class Different {
    public boolean checkDifferent(String iniString) {
        char[] str = iniString.toCharArray();
        return quick_check(str, 0, str.length - 1);
    }

    public boolean quick_check(char[] str, int low, int high) {
        if (low >= high)
            return true;
        int first = low, last = high;
        char key = str[first];

        while (first < last) {
            while (first < last && str[last] > key)
                last--;
            if (first < last && str[last] == key) {
                return false;
            }
            str[first] = str[last];
            while (first < last && str[first] < key)
                first++;
            if (first < last && str[first] == key) {
                return false;
            }
            str[last] = str[first];
        }
        str[first] = key;

        return quick_check(str, low, first - 1)
                && quick_check(str, first + 1, high);
    }

}

1.2、原串翻转

题目描述
请实现一个算法，在不使用额外数据结构和储存空间的情况下，翻转一个给定的字符串(可以使用单个过程变量)。
给定一个string iniString，请返回一个string，为翻转后的字符串。保证字符串的长度小于等于5000。
测试样例：
“This is nowcoder”
返回：”redocwon si sihT”

import java.util.*;

public class Reverse {
   
    public String reverseString(String iniString) {
        // write code here
        char[] str = iniString.toCharArray();
        int first = 0;
        int end = str.length - 1;
        char temp;
        while(first < end){
            temp = str[first];
            str[first] = str[end];
            str[end] = temp;
            first++;
            end --;
        }
        return new String(str);
    }
}

1.3、原串翻转

题目描述
给定两个字符串，请编写程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。这里规定大小写为不同字符，且考虑字符串重点空格。
给定一个string stringA和一个string stringB，请返回一个bool，代表两串是否重新排列后可相同。保证两串的长度都小于等于5000。
测试样例：
“This is nowcoder”,”is This nowcoder”
返回：true
“Here you are”,”Are you here”
返回：false

import java.util.*;

public class Same {
   
    public boolean checkSam(String stringA, String stringB) {
        // write code here
        char[] A = new char[256];
        char[] B = new char[256];

        for(int i = 0;i < stringA.length();i++){
            A[stringA.charAt(i)]++;
        }
        for(int i = 0;i < stringB.length();i++){
            B[stringB.charAt(i)]++;
        }

        for(int i = 0;i<256;i++){
            if(A[i] != B[i]){
                return false;
            }
        }

        return true;
    }


}

1.4、原串翻转

题目描述
请编写一个方法，将字符串中的空格全部替换为“%20”。假定该字符串有足够的空间存放新增的字符，并且知道字符串的真实长度(小于等于1000)，同时保证字符串由大小写的英文字母组成。
给定一个string iniString 为原始的串，以及串的长度 int len, 返回替换后的string。
测试样例：
“Mr John Smith”,13
返回：”Mr%20John%20Smith”
”Hello World”,12
返回：”Hello%20%20World”

import java.util.*;

public class Replacement {
   
    public String replaceSpace(String iniString, int length) {
        // write code here
        int spaceCount = 0; 
        char[] str = iniString.toCharArray();
        for(int i = 0; i< str.length;i++){
            if(str[i] ==  ' ')
                spaceCount++;
        }
        char[] newStr = new char[length + 2*spaceCount];
        int newStrEnd = newStr.length-1;
        for(int i = str.length-1;i>=0;i--){
            if(str[i] == ' '){
                newStr[newStrEnd--] = '0';
                newStr[newStrEnd--] = '2';
                newStr[newStrEnd--] = '%';
            }else{
                newStr[newStrEnd--] = str[i];
            }
        }

        return new String(newStr);
    }
}

1.5、基本字符串压缩

题目描述
利用字符重复出现的次数，编写一个方法，实现基本的字符串压缩功能。比如，字符串“aabcccccaaa”经压缩会变成“a2b1c5a3”。若压缩后的字符串没有变短，则返回原先的字符串。
给定一个string iniString为待压缩的串(长度小于等于3000)，保证串内字符均由大小写英文字母组成，返回一个string，为所求的压缩后或未变化的串。
测试样例
“aabcccccaaa”
返回：”a2b1c5a3”
“welcometonowcoderrrrr”
返回：”welcometonowcoderrrrr”

import java.util.*;

public class Zipper {
   
    public String zipString(String iniString) {
            // write code here

            char[] str = iniString.toCharArray();
            int length = str.length;
            char[] newStr = new char[length];

            int newStrPtr = 0;
            int strPtr = 0;

           //注意边界条件
            while(strPtr<length && newStrPtr<length-1){
                int count = 1;
                newStr[newStrPtr++] = str[strPtr];
                while(strPtr<length -1 && str[strPtr] == str[strPtr+1]){
                   strPtr++;
                    count++;
                }
                strPtr++;
                String count1 = count+"";//如果是10的话，加两个
                for(int i = 0;i<count1.length();i++){
                    newStr[newStrPtr++] = count1.charAt(i);
                }

                if(strPtr == length){
                    return new String(newStr);
                }
            }

            return iniString;
        }
}

方法二：

import java.util.*;

public class Zipper {
   
    public String zipString(String iniString) {
        // write code here
        // 测试用例welcometonowcoderrrrr,若按所给方法压缩则结果为：
        // w1e1l1c1o1m1e1t1o1n1o1w1c1o1d1e1r5,长度比所给的字符串要长，
        // 所以需要返回原来的字符串。
       if (iniString == null
                || iniString.length() == 0
                || iniString.isEmpty()) {
            return "";
        }
        StringBuilder zipStr = new StringBuilder();
        int count = 1;
        for (int i = 0, j = 1; i < iniString.length()
                && j < iniString.length(); i++) {
            if (iniString.charAt(i) == iniString.charAt(j++)) {
                count++;
            } else {
                zipStr.append(iniString.charAt(i));
                zipStr.append(count);
                count = 1;
            }
            if (j == iniString.length()) {
                zipStr.append(iniString.charAt(j - 1));
                zipStr.append(count);
            }
        }
        return zipStr.toString().length() > iniString.length() ?
                iniString : zipStr.toString();
    }
}

1.6、像素翻转(好好看看)

题目描述
有一副由NxN矩阵表示的图像，这里每个像素用一个int表示，请编写一个算法，在不占用额外内存空间的情况下(即不使用缓存矩阵)，将图像顺时针旋转90度。
给定一个NxN的矩阵，和矩阵的阶数N,请返回旋转后的NxN矩阵,保证N小于等于500，图像元素小于等于256。
测试样例：
[[1,2,3],[4,5,6],[7,8,9]],3
返回：[[7,4,1],[8,5,2],[9,6,3]]

思路：分层处理