经典算法问题的java实现 (二)

原文地址： http://liuqing-2010-07.iteye.com/blog/1403190
 
1.数值转换(System Conversion) 
1.1 r进制数 
  数N的r进制可以表示为： 
 

1.2 十进制转换为r进制 
  十进制数N和其他r进制数的转换是计算机实现计算的基本问题，基解决方案很多，其中一个简单算法基于下列原理： 
  N = (N div d) * r + N mod r (其中： div为整除运算，mod为求余运算) 
 
  问题：如何将非负十进制(Decimal)整数转化为八进制数(Octonary Number)？ 
  将十进制转化为r进制： 
Java代码  收藏代码
  1. /** 
  2.  * 非负十进制整数转换为r进制数 
  3.  * @param n 待转换的十进制数 
  4.  * @param r 进制数（基数） 
  5.  * @return 返回转换后对应r进制数各位数字。 
  6.  */  
  7. byte [] dec2RNumber(int n,byte r) {  
  8.     if(n < 0 || r < 0) {  
  9.         throw new IllegalArgumentException(" the parameter is valid!");  
  10.     }  
  11.     Stack<Byte> s = new Stack<Byte>();  
  12.     while( n != 0){  
  13.         s.push(Byte.valueOf((byte) (n%r)));//求余  
  14.         n = n/r;//求商  
  15.     }  
  16.     byte [] rr  = new byte[s.size()];  
  17.     for (int i = 0; i < rr.length; i++) {  
  18.         rr[i] = s.pop();  
  19.     }  
  20.     return rr;  
  21. }  

  十进制非负整数转换为八进制： 
Java代码  收藏代码
  1. dec2RNumber(1348,8)  

2.斐波那契数列(Fibonacci Sequence) 
2.1 斐波那契数列是以递归的方法来定义： 
 
  斐波那契数列是从第0项和第1项开始，之后的项等于其前面相邻两项之和。 
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946,...... 

2.2 兔子生育问题： 
  • 第一个月初有一对刚诞生的兔子
  • 第二个月之后(第三个月初)它们可以生育
  • 每月每对可生育的兔子会诞生下一对新兔子
  • 兔子永不死去
2.3 兔子问题的分析： 

  斐波那契数列的java非递归实现： 
Java代码  收藏代码
  1. int Fibs(int n) {  
  2.     if(n < 0) {  
  3.         throw new IllegalArgumentException(" the parameter is valid!");  
  4.     }  
  5.     int n1 = 0;//F(n-2)  
  6.     int n2 = 1;//F(n-1)  
  7.     int r = n1;//F(n)  
  8.     if(n == 1) {  
  9.         r = n2;  
  10.     }  
  11.     for (int i = 2; i <= n; i++) {  
  12.         r = n1 + n2 ;//F(n)=F(n-1)+F(n-2)  
  13.         n1 = n2;  
  14.         n2 = r;  
  15.     }  
  16.     return r;  
  17. }  


参照资料：http://zh.wikipedia.org/wiki/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97#.E6.87.89.E7.94.A8

3.秦九韶算法求一元n次多项式的值(Compute Polynomial's value) 
3.1 秦九韶算法介绍： 
  秦九韶算法是中国南宋时期的数学家秦九韶提出的一种多项式简化算法。在西方被称作霍纳算法。 
  秦九韶算法： 
   
  一般地，一元n次多项式的求值需要经过[n(n+2)]/2次乘法和n次加法，而从上面的演算可以看出秦九韶算法只需要n次乘法和n次加法。极大地降低了算法复杂度。 
  参照:http://zh.wikipedia.org/wiki/%E9%9C%8D%E7%B4%8D%E6%BC%94%E7%AE%97%E6%B3%95 

3.2 秦九韶算法实现： 
Java代码  收藏代码
  1. /** 
  2.  * 秦九绍算法求一元n次多项式的值 
  3.  * f(x) = a[0]*x^n + a[1]*x^(n-1) + ... + a[n] 
  4.  * @param a 系数 
  5.  * @param x 基数 
  6.  * @return 
  7.  */  
  8. double qinjiushao(double [] a ,double x) {  
  9.     double v = a[0];  
  10.     for (int i = 1; i < a.length; i++) {  
  11.         v = v * x + a[i];  
  12.     }  
  13.     return v;  
  14. }  


3.3 秦九韶算法应用： 
  在Java中字符串的hashcode计算中就用到了秦九韶算法。其中基数为31（质数），系数为字符串对应的ASCII值。 
Java代码  收藏代码
  1. public int hashCode() {  
  2. int h = hash;  
  3. if (h == 0) {  
  4.     int off = offset;  
  5.     char val[] = value;  
  6.     int len = count;  
  7.   
  8.         for (int i = 0; i < len; i++) {  
  9.             h = 31*h + val[off++];  
  10.         }  
  11.         hash = h;  
  12.     }  
  13.     return h;  
  14. }  

  测试： 
Java代码  收藏代码
  1. System.out.println("abc".hashCode());  
  2.  结果：96354 = ax^2 + bx +c //其中( [a,b,c]=[97,98,99];x =31)  
  3.             = 97 * 961 + 98 * 31 +99  

4.全排列(Full Permutation) 
  从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。当m＝n时所有的排列情况叫全排列。 
  问题：给定字符串S，生成该字符串的全排列。 
 
  以上全排列的算法采用了交换，回溯，递归的方法。 
  参照地址：http://www.haogongju.net/art/37504 
Java代码  收藏代码
  1. int count = 0;//统计字符串的全排列数目  
  2. int  len = 0;//字符串的长度  
  3. /** 
  4.  * 字符串的全排列算法。 
  5.  * @param c字符串对应的字符数组 
  6.  * @param start 起始位置 
  7.  */  
  8. void fullPermutation(char[] c, int start ) {  
  9.     if(start == len){  
  10.         count++;  
  11.         System.out.println(new String(c));//打印当前排列  
  12.     } else {  
  13.         char temp=' ';  
  14.         boolean bool = false;  
  15.         for(int i = start; i < c.length; i++){  
  16.             bool = (i != start); //i与start相等时不交换。  
  17.             //为避免生成重复排列，当不同位置的字符相同时不再交换    
  18.             if(bool && c[i] == c[start]) {  
  19.                 continue;  
  20.             }  
  21.             if(bool) {//交换  
  22.                 temp = c[start];  
  23.                 c[start] = c[i];  
  24.                 c[i] = temp;  
  25.             }                 
  26.             fullPermutation(c, start + 1);//递归            
  27.             if(bool) {//回溯  
  28.                 c[i] = c[start];  
  29.                 c[start] = temp;  
  30.             }  
  31.        }  
  32.     }  
  33. }  
  34.   
  35. /** 
  36.  * 测试全排列 
  37.  * @param s 
  38.  */  
  39. void testFullPermutation(String s) {  
  40.     count = 0;  
  41.     len = s.length() -1;  
  42.     long t1 = Calendar.getInstance().getTimeInMillis();  
  43.     fullPermutation(s.toCharArray(), 0);  
  44.     long t2 = Calendar.getInstance().getTimeInMillis();  
  45.     System.out.println("全排列数："+count);  
  46.     System.out.println("耗时："+(t2-t1)+"ms");  
  47. }  

5.八皇后问题(Eight Queens) 
  八皇后问题，是一个古老而著名的问题，是回溯算法的典型例题。该问题是十九世纪著名的数学家高斯1850年提出：在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法? 
   
  上图为八皇后问题的一个例子。 
  八皇后问题的java实现如下。该算法支持n皇后。当n>=16以后计算时间会很长。 
Java代码  收藏代码
  1. import java.util.Calendar;  
  2. public class EightQueens {  
  3.   
  4. //统计解的个数  
  5. int count ;  
  6. //皇后数  
  7. static int N = 8;  
  8. //记录皇后的位置,x[i]表示皇后i放在棋盘的第i行的第x[i]列  
  9. int [] X = new int[N];  
  10.   
  11. /** 
  12.  * 测试皇后k在第k行第x[k]列时是否与前面已放置好的皇后相攻击. 
  13.  * (X[j] == X[k]时，两皇后在同一列上， 
  14.  * k-j == Math.abs(X[j] - X[k])时，两皇后在同一斜线上。 
  15.  * @param k 
  16.  * @return 
  17.  */  
  18. boolean check(int k) {  
  19.     for (int row = 0; row < k; row ++) {  
  20.         if ((X[row] == X[k] || k-row == Math.abs(X[row] - X[k]))) {  
  21.             return false ;  
  22.         }  
  23.     }  
  24.     return true;  
  25. }  
  26.   
  27. /** 
  28.  * 回溯求皇后的放置方案。 
  29.  * 对于八皇后t的最大值为8. 
  30.  * @param row row -> [0,1,2,3,4,5,6,7,8] 
  31.  */  
  32. void backtrack(int row) {  
  33.     //row == N 时，算法搜索至叶结点，得到一个新的N皇后互不攻击的放置方案  
  34.     if(row == N) {  
  35.         count++;  
  36.         printQueen();  
  37.     } else {  
  38.         for (int col = 0; col < N; col++) {  
  39.             X[row] = col;//第row行的皇后放在col列上  
  40.             if(check(row)) {//放置成功再放row+1行的  
  41.                 backtrack(row+1);  
  42.             }  
  43.         }  
  44.     }  
  45. }  
  46.   
  47. /** 
  48.  * 打印皇后 
  49.  */  
  50. void printQueen() {  
  51.     System.out.println("==================第"+count+"种皇后图==================");  
  52.     for (int row = 0; row < N; row++) {  
  53.         for (int col = 0; col < N; col++) {  
  54.             if (col == X[row]) {  
  55.                 System.out.print("@ ");  
  56.             } else {  
  57.                 System.out.print("* ");  
  58.             }  
  59.         }  
  60.         System.out.println();  
  61.     }  
  62. }  
  63.   
  64. /** 
  65.  * @param args 
  66.  */  
  67. public static void main(String[] args) {  
  68.     EightQueens queen = new EightQueens();  
  69.     long t1 = Calendar.getInstance().getTimeInMillis();  
  70.     //从0开始回溯  
  71.     queen.backtrack(0);  
  72.     long t2 = Calendar.getInstance().getTimeInMillis();  
  73.     //打印花费的时间。  
  74.     System.out.println("花费："+(t2-t1)+"ms");  
  75.     //打印方案总数  
  76.     System.out.println(queen.count);  
  77. }  
  78.   
  79. }  

  有兴趣的读者可以参照以下连接，去研究八皇后算法。 
posted @ 2016-04-20 14:49  Heart_K  阅读(384)  评论(0)  编辑  收藏  举报