本文來自http://blog.csdn.net/liuxian13183/ ，引用必須註明出處！
在日常的開發工作中，算法不會顯得那麼重要，然而在數據量達百萬級別的時候，差距會非常大，今天帶大家研究下常見的字符串反轉算法。
public class StringReverse {
public static String reverse1(String orig) {
char[] s = orig.toCharArray();
int n = s.length - 1;
int halfLength = n / 2;
for (int i = 0; i <= halfLength; i++) {// 2分法+替換算法
char temp = s[i];
s[i] = s[n - i];
s[n - i] = temp;
}
return new String(s);
}
public static String reverse2(String s) {// 2分法+異或算法
char[] str = s.toCharArray();
int begin = 0;
int end = s.length() - 1;
while (begin < end) {
str[begin] = (char) (str[begin] ^ str[end]);
str[end] = (char) (str[begin] ^ str[end]);
str[begin] = (char) (str[end] ^ str[begin]);
begin++;
end--;
}
return new String(str);
}
public static String reverse3(String s) {// jdk提供
return new StringBuffer(s).reverse().toString();
}
public static String reverse4(String s) {// 2分遞歸算法
int length = s.length();
if (length <= 1)
return s;
String left = s.substring(0, length / 2);
String right = s.substring(length / 2, length);
return reverse1(right) + reverse1(left);
}
public static String reverse5(String s) {// 傳統從後往前加
int length = s.length();
String reverse = "";
for (int i = 0; i < length; i++)
reverse = s.charAt(i) + reverse;
return reverse;
}
public static String reverse6(String s) {//傳統與5雷同
char[] array = s.toCharArray();
String reverse = "";
for (int i = array.length - 1; i >= 0; i--)
reverse += array[i];
return reverse;
}
public static String reverse7(String s) {// 利用棧先進後出的特性
char[] str = s.toCharArray();
Stack<Character> stack = new Stack<Character>();
for (int i = 0; i < str.length; i++)
stack.push(str[i]);
String reversed = "";
for (int i = 0; i < str.length; i++)
reversed += stack.pop();
return reversed;
}
public static void main(String[] args) {
String str = "hello world !";
int length = 10000000;
long curTime = System.currentTimeMillis();
for (int i = 0; i < length; i++) {
reverse1(str);
}
System.out.println("reverse1:" + (System.currentTimeMillis() - curTime));
curTime = System.currentTimeMillis();
for (int i = 0; i < length; i++) {
reverse2(str);
}
System.out.println("reverse2:" + (System.currentTimeMillis() - curTime));
curTime = System.currentTimeMillis();
for (int i = 0; i < length; i++) {
reverse3(str);
}
System.out.println("reverse3:" + (System.currentTimeMillis() - curTime));
curTime = System.currentTimeMillis();
for (int i = 0; i < length; i++) {
reverse4(str);
}
System.out.println("reverse4:" + (System.currentTimeMillis() - curTime));
curTime = System.currentTimeMillis();
for (int i = 0; i < length; i++) {
reverse5(str);
}
System.out.println("reverse5:" + (System.currentTimeMillis() - curTime));
curTime = System.currentTimeMillis();
for (int i = 0; i < length; i++) {
reverse6(str);
}
System.out.println("reverse6:" + (System.currentTimeMillis() - curTime));
curTime = System.currentTimeMillis();
for (int i = 0; i < length; i++) {
reverse7(str);
}
System.out.println("reverse7:" + (System.currentTimeMillis() - curTime));
}
}
其他有趣的算法：
如賽馬問題，25匹馬，5個賽道，如何在不用工具的情況下，找到最快的5匹。問題可以簡化爲3匹馬，3個賽道。
分A B C三組馬，各賽一場，結果如下：
A1 A2 A3
B1 B2 B3
C1 C2 C3
3場第1名賽一場，得出第1名
如果是A1，則A2跟B1和C1比1場，其他同理，找出第2名
如果是B1，則A2跟B2和C1比1場，其他同理，找出第3名
比賽結束，共需要6場。即n(賽道數量)+1（各組第一名數量）+（n-1）（上場第一名組的第二名，與剩餘組第一名比賽場數，可找出最快的n匹馬）=2n。
同理可算出，25匹馬需要10場。
如運煤問題，3000噸煤，用載重1000噸的火車，從原點運往終點，路程1000公里，每公里消耗1噸煤，到終點時煤剩幾何？
粗略一算，第一種方案：
第一輪，
第1次，先拉1000噸到A，卸下500噸，返回，行程250公里
第2次，再拉1000噸到A，卸下500噸，返回，行程250公里，同理第三次
第3次後，A地剩下1500噸煤，行程250公里
第二輪
繼續第4次，同上，到B地行程187.5公里，每次卸下375噸貨物
兩輪後，行程437.5公里，剩下貨物750噸
第三輪
一次性運到，共剩餘312.5噸
分析：由於第三輪每次只運750噸，運量未滿，導致最終運送較少。
粗略一算，第二種方案：
第1次，先拉1000噸到A，卸下500噸，行程250公里，返回
第2次，再拉1000噸到A，加上250噸滿載，剩下250噸；走250公里到B，卸下250噸，總行程250公里，返回
第3次，再拉1000噸到A，加上250噸滿載；再走250公里到B，加上前兩次剩下的共500噸，滿載1000噸繼續
直行到終點，共剩餘500噸
分析：似乎比較完美，每次都是滿載。
粗略一算，第三種方案：
注意：前提是，走更遠的路，剩下更多的煤！
變下思路，將此題變成n千噸煤，可以走多少公里（路程），即消耗多少（最後總是到終點）？
那麼1000噸走1000公里，2000噸運2次，向前3次向後2次，故向前只能多走1/3公里，即1000*（1+1/3)公里，
同理可得3000噸走1000*（1+1/3+1/5）公里，故向前5次向後3次，n千噸可走1000*（1+1/3+1/5+……+1/(2n-1)）公里
那麼3000公里剩餘多少呢？前兩句已經講了3000噸可走的公里，每公里1噸，多出多少公里即多出多少噸
即1000*（1+1/3+1/5）（走的所有路程）-1000（直線距離）=1600/3噸，即533.33噸。功夫不負有心人，這就是最終答案！