总结的算法

1、题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？

public static List<Integer> makeNum(){
 List<Integer> list= new Vector<Integer>();
 for(int i=1;i<5;i++)
  for(int j=1;j<5;j++)
   for(int k=1;k<5;k++){
    if(i!=j&i!=k&j!=k){
     Integer temp=i*100+j*10+k;
     list.add(temp); 
    }
   }
 return list;
}

2、古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三

个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

月份  兔子数(对)   
第一个月   1
第二个月   1  
第三个月   2  该月新增一对兔子 
第四个月   3  该月新增一对兔子
第五个月   5  该月新增二对兔子
第六个月   8  该月新增三对兔子
第七个月   13  该月新增五对兔子
....  ...  ...
可以看出从第二个月开始，兔子数量(对)的规律是 前二个月的数量之和
求出来的是兔子的对数
public long f(int n){
 if(n==2|n==1)
  return 1;
 return f(n-1)+f(n-2); 
}
我算了一下，好多的兔子....⊙﹏⊙b汗

3、素数的判定 
 判断一个数是否为素数的方法是，用2到该数的(算术平方根+1)之间的数去除

这个数，如果能被整除，则说明这个数不是素数.
public boolean prime(int n) {
 if (n == 2) {
  return true;
 } else {
  for (int i = 2; i < Math.sqrt(n) + 1; i++) {
   if (n % i == 0) {
    return false;
   }
  }
 }
 return true;
}
4、判断一个数是否为完数
完数一个数如果恰好等于它的因子之和，因子不包括自身，这个数就称为"完数"。
public boolean perfectNum(int n) {
 boolean flag = false;
 int sum = 0;// 声明变量
 for (int i = 1; i < n / 2 + 1; i++) {// 求n的所有因子
  if (n % i == 0)// 如果能整除,说明i是n的因子
   sum += i;
 }
 if (sum == n)
  flag = true;
 return flag;
}
5、最大公倍数，最小公约数
这个求最大公约数的算法不是很明白,死记的
public void f3(int n, int m) {
 int temp;
 // 大数置前
 if (n < m) {
  temp = n;
  n = m;
  m = temp;
 }
 int a = n;
 int b = m;
 while (b != 0) {
  temp = a % b;
  a = b;
  b = temp;
 }
 System.out.println("最大公约数:" + a);
 System.out.println("最小公倍数:" + n * m / a);
}
6、求一个数的阶乘
public long f2(int n) {
 if (n == 1)
  return 1;
 return n * f2(n - 1);
}

明天继续

7、猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
思路：第10天看成第1天，第一天是第10天比较容易理解
public int f(int n){
 if(n==1)
  return 1;
 return 2*f(n)+2; 
}
8、输入字符 ，反序输出
private String str="";
private Scanner input = new Scanner(System.in);
 /**
  * 将输入的字符反序输出
  * @param n  要输入的字符次数
  * @return 返回反序字符串
  */
public String strSort(int n) {
 String temp = input.next();
 temp+=str;
 str=temp;
 if(n==1)
  return str;
 return strSort(n-1);
}

 /**
  * 对一个数进行质因数分解
  * @param n 待分解的数
  * @return 该数的质因数组
  */
 public List<Integer> primeFactor(int n) {
  List<Integer> list = new ArrayList<Integer>();
  for (Integer i = 2; i < n; i++) {
   while (n != i) {
    if (n % i == 0) {
     n = n / i;
     list.add(i);
    } else
     break;
   }
  }
  list.add(n);// 这里有个自动装箱,将n包装成Integer类型
  return list;
 }

 /**
  * 对一个数进行质因数分解
  * @param n 待分解的数
  * @return 该数的质因数组
  */
 public List<Integer> primeFactor(int n) {
  List<Integer> list = new ArrayList<Integer>();
  for (Integer i = 2; i < n; i++) {
   while (n != i) {
    if (n % i == 0) {
     n = n / i;
     list.add(i);
    } else
     break;
   }
  }
  list.add(n);// 这里有个自动装箱,将n包装成Integer类型
  return list;
 }

9、   /**
  * 对一个数进行质因数分解
  * @param n 待分解的数
  * @return 该数的质因数组
  */
 public List<Integer> primeFactor(int n) {
  List<Integer> list = new ArrayList<Integer>();
  for (Integer i = 2; i < n; i++) {
   while (n != i) {
    if (n % i == 0) {
     n = n / i;
     list.add(i);
    } else
     break;
   }
  }
  list.add(n);// 这里有个自动装箱,将n包装成Integer类型
  return list;
 }

10、关于哥德巴赫猜想
 /**
  * 哥德巴赫猜想,仅仅是实现了判断一个偶数是哪两个质数的和，并读出这两个数
  * @param n  待判断的数
  */
 public void guess(int n) {
  int i, j, m;
  for (i = 3; i <= n / 2; i += 2) {
   for (j = 2; j <= Math.sqrt(i); j++)
    if (i % j == 0)
     break;
   if (j > Math.sqrt(i))
    m = n - i;
   else
    break;
   for (j = 2; j <= Math.sqrt(m); j++)
    if (m % j == 0)
     break;
   if (j > Math.sqrt(m))
    System.out.println(n + "=" + i + "+" + m);
  }
 }

 把这些方法写了一遍，加深了对递归的理解：变量变化，函数不变量。碾转相除法：如果m%n =r   那么m、n的最大公约数和n、r的最大公约数相等(好像是高等数学，忘了什么时候学的了)。拓展了分析问题，设计方法解决问题的思路

还有一些算法以后再加