算法也屬於常見面試內容之一，但基本不會超過《劍指offer》的範圍，在此附上一篇簡書上整理的內容：
第二版java解法
常見的面試題包括以下幾類：字符串操作，文件輸入輸出流及統計，矩陣操作，單例模式等。
1.針對字符串的操作：如字符串反轉、字符串去重、含有左右括號的字符串匹配。
含有左右括號的字符串匹配的題目及代碼如下：
給定一個字符串，其中的字符只包含三種括號：花括號{ }、中括號[ ]、圓括號( )，即它僅由 “( ) [ ] { }” 這六個字符組成。設計算法，判斷該字符串是否有效，即字符串中括號是否匹配。括號匹配要求括號必須以正確的順序配對，如 “{ [ ] ( ) }” 或 “[ ( { } [ ] ) ]” 等爲正確的格式，而 “[ ( ] )” 或 “{ [ ( ) }” 或 “( { } ] )” 均爲不正確的格式。
/**
* 棧的先入後出，非常適合作爲括號匹配的對象 思路：將所有的左括號類型入棧，出現一個匹配的右括號即出棧
* 如果最後棧爲空則完全匹配；如果最後棧非空則不匹配
*/
public class MatchString {
public static boolean isMatchStr(String s){
if(s==null || s.length()<1) return false;
Stack<Character> stack=new Stack<>();
char c;
boolean flag=true;
int cnt=0;
for(int i=0;i<s.length();i++){
c=s.charAt(i);
// 入棧規則
if(c=='(' || c=='[' || c=='{'){
stack.push(c);
cnt++;
continue;
}
// 過濾非括號的無關字符串
if(c!='(' && c!='[' && c!='{' && c!=')' && c!=']' && c!='}') continue;
// 出棧規則
if(stack.isEmpty()||!isMatch(c,stack.peek())) return false;
if (!stack.isEmpty() && isMatch(c, stack.peek())) {
stack.pop();
cnt++;
continue;
}
}
if(!stack.isEmpty()) return false;
return flag;
}
private static boolean isMatch(char right, char left) {
if(right==')')
return left=='(';
if(right==']')
return left=='[';
if(right=='}')
return left=='{';
return false;
}
public static void main(String[] args) {
String s1="({{123}})";
String s2="}}}}}{{{{";
String s3="((111111({{}}})))";
System.out.println(isMatchStr(s1));
System.out.println(isMatchStr(s2));
System.out.println(isMatchStr(s3));
}
}字符串反轉在劍指offer上也能找到類似的題目，反轉單詞順序：
輸入一個英文句子，翻轉單詞順序，單詞內字符不翻轉，標點符號和普通字母一樣處理。例如輸入輸入“I am a student.”，則輸出“student. a am I”。
/**
* 先對所有字符串進行反轉，之後按照空格分隔開，再對單個單詞進行反轉。
*/
public class ReverseWordsInSentence {
public static String reverseStr(String str){
if(str==null || str.length()<=1) return str;
Stack<Character> stack=new Stack<>();
StringBuffer stringBuffer=new StringBuffer();
for(int i=0;i<str.length();i++){
stack.push(str.charAt(i));
}
for(int i=0;i<str.length();i++){
stringBuffer.append(stack.pop());
}
System.out.println(stringBuffer.toString());
String[] strings=stringBuffer.toString().split(" ");
stringBuffer.setLength(0);
for(int i=0;i<strings.length;i++){
stringBuffer.append(reverseWord(strings[i]));
stringBuffer.append(" ");
}
return stringBuffer.toString();
}
public static String reverseWord(String s){
StringBuffer stringBuffer=new StringBuffer();
if(s==null || s.length()<=1) return s;
Stack<Character> stack=new Stack<>();
for(int i=0;i<s.length();i++){
stack.push(s.charAt(i));
}
while(!stack.isEmpty()){
stringBuffer.append(stack.pop());
}
return stringBuffer.toString();
}
public static void main(String[] args) {
String str="I am a student.";
System.out.println(reverseStr(str));
}
}
查找字符串重複問題因爲會用到哈希也常被放在面試中。
找出給定字符串中第一個不重複的字母。例如：abcccaddd,第一個不重複的字母是b。
public class FirstNotRepeatingChar {
public static char firstNotRepeatChar(String str){
// 256個字母
char temp=str.charAt(0);
int[] hashTimes=new int[256];
for(int i=0;i<str.length();i++){
hashTimes[str.charAt(i)]++;
}
for (int i=0;i<str.length();i++){
if(hashTimes[str.charAt(i)]==1)
return str.charAt(i);
}
return '\77';
}
public static void main(String[] args) {
System.out.println(firstNotRepeatChar("aaaaaaaaaaaaaa"));
}
}2. 文件輸入流考察：文件讀入並統計某個字符的值。
3. 矩陣（二維數組）考察：矩陣的的順時針打印、順時針90度等。
4. 遞歸考察：其實遞歸是很容易考察到的一個點，我因爲這塊薄弱掛掉了某廠。把兩個典型的遞歸的方法在這裏寫一下，希望大家也能有所啓發。遞歸重要的點一定是去找結束條件以及對應的返回值，多做幾個題目就熟練了。
1.求1的階乘到n的階乘的和。
public class GetSumFactorial {
public static long getAddFactorial(long n){
if(n<=0) return -1;
long sum=0,start=1,end=n;
long mid;
while (start<=end){
sum+=getSingleFactorial(end);
end--;
}
return sum;
}
private static long getSingleFactorial(long i) {
if(i<1) return -1;
if(i==1) return 1;
return getSingleFactorial(i-1)*i;
}
public static void main(String[] args) {
System.out.println(getAddFactorial(4));
// 異常值 如果n比較大的時候，遞歸消耗內存就會導致程序啓動報棧溢出異常，這個時候可以通過設置jvm的參數-Xss512k來解決這個問題 （如果主動考慮到這個 可以作爲面試中的加分項哦） System.out.println(getAddFactorial(100000));
}
}2.給一個有序排列的整數數組a[n],整數數組有且僅有一個值缺失，求當前缺失的值。例子 a[10]={0,1,2,3,5,6,7,8,9,10}，返回缺失的值爲4.
其中，方法一和方法二都是遞歸的思路，只不過方法一是用了二分法求和的遞歸思路，方法二是利用數組的特點進行遞歸，遞歸仍然使用二分的思想。
public class QueryLackedInt {
// 方法一：根據數組特性即可求出缺失的值
public static int getNum1(int[] data) {
if (data == null || data.length == 0) return -1;
if (data[0] != 0) return 0;
int len = data.length;
int sum1 = getSum(data, 0, len - 1);
int sum2 = (len + 1) * (data[0] + data[len - 1]) / 2;
return sum2 - sum1;
}
public static int getSum(int[] data, int low, int high) {
if (data == null || data.length == 0) return -1;
if (low == high) {
return data[low];
} else {
int mi = (low + high) >> 1;
return getSum(data, low, mi) + getSum(data, mi + 1, high);
}
}
// 方法二：使用兩個指針進行遞歸
public static int getNum2(int[] data) {
if (data == null || data.length == 0) return -1;
if (data.length >= 1 && data[0] != 0) return 0;
return getRecursion(data, 0, data.length-1);
}
private static int getRecursion(int[] data, int left, int right) {
int mid = (left + right) / 2;
if (right == left && data[left] != left) return left;
if (data[mid] == mid) {
return getRecursion(data, mid+1, right);
} else {
return getRecursion(data, left, mid);
}
}
public static void main(String[] args) {
int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12,13, 14, 15};
int[] b = null;
int[] c = {1, 2};
System.out.println(getNum1(a));
System.out.println(getNum1(b));
System.out.println(getNum1(c));
System.out.println(getNum2(a));
System.out.println(getNum2(b));
System.out.println(getNum2(c));
}
}