经典算法问题的java实现 （一）

原文链接： http://liuqing-2010-07.iteye.com/blog/1396859
 
1.如何计算闰年(Leap Year)？ 
  四年一闰；百年不闰；四百年再闰。 
  具体参照：http://baike.baidu.com/view/3085625.htm 
Java代码  收藏代码
  1. boolean isLeapYear(int year) {  
  2.     return (year%4 == 0 && year%100 !=0) || (year%400 == 0);  
  3. }  


2.如何判断一个数是否是质数(Prime Number)？ 
  质数又称素数。指在一个大于1的自然数中，除了1和此整数自身外，没法被其他自然数整除的数。 
  具体参照：http://baike.baidu.com/view/1767.htm 
Java代码  收藏代码
  1. boolean isPrimeNumber(int n) {  
  2.     int n1 = (int) Math.sqrt(n);  
  3.     for (int i = 2; i <= n1; i++) {  
  4.         if(n%i == 0) {  
  5.             return false;  
  6.         }  
  7.     }  
  8.     return true;  
  9. }  

  注：这里n必须大于1。 

3.分解质因数(Decomposition of prime factors)。 
  每个合数都可以写成几个质数相乘的形式。其中每个质数都是这个合数的因数，叫做这个合数的分解质因数。 分解质因数只针对合数。 
  求一个数分解质因数，要从最小的质数除起，一直除到结果为质数为止。短除法求质因数： 
 
具体参照：http://baike.baidu.com/view/832102.htm#1 
Java代码  收藏代码
  1. //返回质因数数组  
  2. Integer[] decPrime(int n) {  
  3.     List<Integer> list = new ArrayList<Integer>();  
  4.     for (int i=2;i <= n;i++){  
  5.         while(n != i){  
  6.             if(n%i != 0){  
  7.                 break;//不能整除肯定不是因数，能够整除在这里一定是质数。因为所有的2，3,5,7  
  8.                       //都被除完之后。剩下的因数只能是奇数，且是质数。  
  9.             }  
  10.             list.add(Integer.valueOf(i));  
  11.             n = n/i;  
  12.         }  
  13.     }  
  14.     list.add(Integer.valueOf(n));  
  15.     return list.toArray(new Integer[list.size()]);  
  16. }  


4.求两个数的最大公约数(Greatest Common Divisor)。 
  如果有一个自然数a能被自然数b整除，则称a为b的倍数，b为a的约数。几个自然数公有的约数，叫做这几个自然数的公约数。公约数中最大的一个公约数，称为这几个自然数的最大公约数。 
  早在公元前300年左右，欧几里得就在他的著作《几何原本》中给出了高效的解法——辗转相除法。辗转相除法使用到的原理很聪明也很简单，假设用f（x, y）表示x，y的最大公约数，取k = x/y，b = x%y，则x = ky + b，如果一个数能够同时整除x和y，则必能同时整除b和y；而能够同时整除b和y的数也必能同时整除x和y，即x和y的公约数与b和y的公约数是相同的，其最大公约数也是相同的，则有f（x, y）= f（y, x%y）（y > 0），如此便可把原问题转化为求两个更小数的最大公约数，直到其中一个数为0，剩下的另外一个数就是两者最大的公约数。 
  具体参照：http://baike.baidu.com/view/47637.htm 
Java代码  收藏代码
  1. long gcd(long x,long y) {  
  2.     if(x < y) {  
  3.         long m = x;  
  4.         x = y;//x存储较大的一个数  
  5.         y = m;  
  6.     }  
  7.     long k = 0;  
  8.     while(y != 0) {  
  9.         k = x%y;  
  10.         x = y;  
  11.         y = k;  
  12.     }  
  13.     return  x;  
  14. }  


5.求两个数的最小公倍数数(Least Common Multiple)。 
  几个数公有的倍数叫做这几个数的公倍数，其中最小的一个公倍数，叫做这几个数的最小公倍数。自然数a、b的最小公倍数可以记作[a,b]，自然数a、b的最大公因数可以记作(a,b），当(a,b)=1时，[a,b]= a×b。 
  两个数的最大公因数和最小公倍数有着下列关系： 
  最大公因数×最小公倍数=两数的乘积 
  即(a,b)×[a,b]= a×b 。 
  证明：设 a = x*(a,b),b = y*(a,b) 其中x,y不存在公约数。 
        a * b = [x * (a,b)] * [y * (a,b)] 
                 = [x * y * (a,b)] * (a,b) 
                 = [a,b] * (a,b) 
  具体参照：http://baike.baidu.com/view/341375.htm#2 
Java代码  收藏代码
  1. long lcm(long x,long y) {  
  2.     return x*y/gcd(x,y);  
  3. }  


6.求完数(Perfect Number)。 
  完数，即完美数，一个数如果恰好等于除它本身外的因子之和，这个数就称为完数。例如6=1＋2＋3.(6的因子是1,2,3) 
  具体参照：http://baike.baidu.com/view/640632.htm 
  http://zjtys-2006.blog.sohu.com/164964518.html 
Java代码  收藏代码
  1. boolean isPerfectNumber(long n) {  
  2.     int s = 0 ;  
  3.     //迭代求出所有因子之和  
  4.     for (int i = 1; i < n; i++) {  
  5.         if(n%i == 0) {  
  6.             s +=i;  
  7.         }  
  8.     }  
  9.     //判断该数是否等于它的因子之和，是则是完数。  
  10.     if( s == n) {  
  11.         return true;  
  12.     }  
  13.     return false;  
  14. }  


7.水仙花数(Daffodils Number)。 
  水仙花数是指一个 n 位数 ( n≥3 )，它的每个位上的数字的 n 次幂之和等于它本身。（例如：1^3 + 5^3 + 3^3 = 153） 
具体参照：http://baike.baidu.com/view/152077.htm 
Java代码  收藏代码
  1. //该算法使用的是基本数据类型，只能计算出少量“水仙花数”。建议感兴趣的读者用BigInteger来求“水仙花数”。  
  2. boolean isDaffodilsNumber(long l) {  
  3.     char [] c = String.valueOf(l).toCharArray();  
  4.     int d = 0,n = c.length;  
  5.     long sum = 0;  
  6.     for (int i = 0; i < c.length; i++) {  
  7.         d = c[i]-'0';  
  8.         sum += Math.pow(d, n);//可能存在精度丢失现象  
  9.     }  
  10.     if(sum == l) {  
  11.         return true;  
  12.     }  
  13.     return false;  
  14. }  


8.回文数字(Palindrome Number)。 
  若一个数（首位不为零）从左向右读与从右向左读都一样，我们就将其称之为回文数。 
例如：121,323..... 
   判断一个数字是否是回文的方法如下： 
Java代码  收藏代码
  1. boolean isPalindromeNumber(long l) {  
  2.     char [] c = String.valueOf(l).toCharArray();  
  3.     int len = c.length/2;  
  4.     for (int i = 0; i < len; i++) {  
  5.         if(c[i] != c[c.length-1-i]) {  
  6.             return false;  
  7.         }  
  8.     }  
  9.     return true;  
  10. }  


9.牛顿迭代法求平方根（Newton's Method）。 
  计算机本身不能开平方，开平方运算是用程序实现的。 
  具体参照：http://baike.baidu.com/view/643093.htm#2 
  http://wenku.baidu.com/view/6b74c622bcd126fff7050bfe.html 
Java代码  收藏代码
  1. /** 
  2.  * 求平方根 
  3.  * @param d 待开方数 
  4.  * @param precision 算术平方根的精度 
  5.  * @return 
  6.  */  
  7. double sqrt(double d,double precision) {  
  8.     double x1 = d/2, x2 =(x1 + d/x1)/2;  
  9.     while(Math.abs(x2 -x1)>precision) {  
  10.         x1 = x2;  
  11.         x2 =(x1 + d/x1)/2;  
  12.     }  
  13.     return x1;  
  14. }  


10.奇偶数快速判断(odd even)。 
  判断奇数和偶数的方法，一般是除以2或者对2取模运算，结果为0则是偶数反之则是奇数。 
在计算机内部数都是用二进制表示的，奇数最低位上一定是1，偶数为0。基于这个特点可以 
利用按位与运算进行奇偶数判断。 
Java代码  收藏代码
  1. //如果是奇数返回true，否则是偶数 则返回false。  
  2. boolean isOdd(long l) {  
  3.     if((l & 0x01) == 0) {  
  4.         return false;  
  5.     }  
  6.     return true;  
  7. }  

  注：在计算机中 除法运算速度 < 模运算速度 < 按位与运算速度
posted @ 2016-04-20 14:45  Heart_K  阅读(506)  评论(0)  编辑  收藏  举报