public static double f0(int n) {
if (n == 0)
return 0;
if (n == 1)
return 1;
double a1 = 0;
double a2 = 1;
double temp;
for (int i = 0; i < n; i++) {
temp = a2;
a2 = a1 + a2;
a1 = temp;
}
return a1;
}
public static double f1(double a1, double a2, int n) {
if (n == 0)
return 0;
if (n == 1)
return a2;
return f1(a2, a1 + a2, n - 1);
}
public static double f2(int n) {
if (n == 0)
return 0;
if (n == 1)
return 1;
return f2(n - 1) + f2(n - 2);
}
public static void main(String[] arg) {
double result;
result = 0;
long start = System.currentTimeMillis();
for (int j = 0; j < 100000; j++) {
result = 0;
for (int i = 0; i < 20; i++) {
result += f0(i);
}
}
System.out.println(result + "/t " + (System.currentTimeMillis() - start));
result = 0;
start = System.currentTimeMillis();
for (int j = 0; j < 100000; j++) {
result = 0;
for (int i = 0; i < 20; i++) {
result += f1(0, 1, i);
}
}
System.out.println(result + "/t " + (System.currentTimeMillis() - start));
result = 0;
start = System.currentTimeMillis();
for (int j = 0; j < 1000; j++) {
result = 0;
for (int i = 0; i < 20; i++) {
result += f2(i);
}
}
System.out.println(result + "/t " + (System.currentTimeMillis() - start));
}
测试结果表明,进行同样的计算,三个算法的需要的时间为1:1.23:158.28。
算法一采用了线性循环,效率最高。
算法二采用了尾递归,基本达到了算法一的效率,但还有20%的差距。
算法三,就是书上经常看到了递归算法,性能差距达100多倍,而且还会导致堆栈溢出。
if (n == 0)
return 0;
if (n == 1)
return 1;
double a1 = 0;
double a2 = 1;
double temp;
for (int i = 0; i < n; i++) {
temp = a2;
a2 = a1 + a2;
a1 = temp;
}
return a1;
}
public static double f1(double a1, double a2, int n) {
if (n == 0)
return 0;
if (n == 1)
return a2;
return f1(a2, a1 + a2, n - 1);
}
public static double f2(int n) {
if (n == 0)
return 0;
if (n == 1)
return 1;
return f2(n - 1) + f2(n - 2);
}
public static void main(String[] arg) {
double result;
result = 0;
long start = System.currentTimeMillis();
for (int j = 0; j < 100000; j++) {
result = 0;
for (int i = 0; i < 20; i++) {
result += f0(i);
}
}
System.out.println(result + "/t " + (System.currentTimeMillis() - start));
result = 0;
start = System.currentTimeMillis();
for (int j = 0; j < 100000; j++) {
result = 0;
for (int i = 0; i < 20; i++) {
result += f1(0, 1, i);
}
}
System.out.println(result + "/t " + (System.currentTimeMillis() - start));
result = 0;
start = System.currentTimeMillis();
for (int j = 0; j < 1000; j++) {
result = 0;
for (int i = 0; i < 20; i++) {
result += f2(i);
}
}
System.out.println(result + "/t " + (System.currentTimeMillis() - start));
}
测试结果表明,进行同样的计算,三个算法的需要的时间为1:1.23:158.28。
算法一采用了线性循环,效率最高。
算法二采用了尾递归,基本达到了算法一的效率,但还有20%的差距。
算法三,就是书上经常看到了递归算法,性能差距达100多倍,而且还会导致堆栈溢出。