斐波那契数列（递归）&求100以内的素数

Java

5

添加了

java.util.Scanner

类，这是一个用于扫描输入文本的新的实用程序。它是以

前的

StringTokenizer

和

Matcher

类之间的某种结合。由于任何数据都必须通过同一模式的

捕获组检索或通过使用一个索引来检索文本的各个部分。于是可以结合使用正则表达式和从

输入流中检索特定类型数据项的方法。这样，除了能使用正则表达式之外，

Scann输入流中检索特定类型数据项的方法。这样，除了能使用正则表达式之外，

1.斐波那契数列

Java中Scanner类这是一个用于扫描输入文本的

可以使用该类创建一个对象

Scanner reader=new Scanner(System.in);

然后reader调用下面的方法，读取用户在命令行输入的各种类型的数据

int nextInt(); //将输入信息的下一个标记扫描为一个 int

double nextDouble(); //将输入信息的下一个标记扫描为一个double

...

String nextNext();  //查找并返回来自此扫描器的下一个完整标记(字符串）

String nextLine();  //此扫描器执行当前行，并返回跳过的输入信息

...

boolean hasNext();  //如果此扫描器的输入中有另一个标记，则返回true

boolean hasNext(Pattern pattern); //如果下一个完整标记与指定模式匹配，则

                                   返回true

boolean hasNext(String pattern); //如果下一个标记与从指定字符串构造的模式

                                   匹配，则返回true

boolean hasNextInt(); //如果通过使用nextInt()方法，此扫描器输入信息中的下

                   一个标记可以解释为指定基数中的一个int 值，则返回true。

注意：斐波那契数列返回值是long型

 

package mianshiti;
import java.util.*;
import java.io.*;
public class fibonacci {
	public static int k=0;
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);//Scanner类这是一个用于扫描输入文本的
		long a=cin.nextLong();//将输入信息的下一个标记扫描为一个long
		System.out.println(fibonacci(a));
		System.out.println("共调用了"+k+"次");
	}
	public static long fibonacci(long m){
		if(m==0|m==1){
			k++;
			return m;
		}else{
			return fibonacci(m-1)+fibonacci(m-2);
		}
	}

}

递归的缺点：

会造成调用栈的溢出，因为需要为每一次函数调用在内存栈中分配空间，而每个进程的栈的容量是有限的。当递归调用层级太多时，就会超出栈的容量，从而导致调用栈溢出。

更简洁的方法：

可以直接从下往上算，首先根据f(0)和f(1)算出f(2)，再根据f(1)和f(2)算出f(3)，依次类推可以算出第n项f(n)，时间复杂度是O(n)

public class Solution {
    public int Fibonacci(int n) {
		if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        int numfn1=0;
        int numfn2=1;
        int currentfn=0;
        for(int i=2;i<=n;i++){
            currentfn=numfn1+numfn2;
            numfn1=numfn2;
            numfn2=currentfn;
        }
        return currentfn;
    }
}

跳台阶：

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

 思路：当前台阶的跳法总数=当前台阶后退一阶的台阶的跳法总数+当前台阶后退二阶的台阶的跳法总数

public class Solution {
    public int JumpFloor(int target) {
		if(target==2||target==1){
            return target;
        }
        // 第一阶和第二阶考虑过了，初始当前台阶为第三阶，向后迭代

    // 思路：当前台阶的跳法总数=当前台阶后退一阶的台阶的跳法总数+当前台阶后退二阶的台阶的跳法总数

		int jumpSum=0;//当前台阶的跳法总数
        int jumpSumBackStep1=2;//当前台阶后退一阶的台阶的跳法总数
        int jumpSumBackStep2=1;//当前台阶后退二阶的台阶的跳法总数
        for(int i=3;i<=target;i++){
            jumpSum=jumpSumBackStep1+jumpSumBackStep2;
            jumpSumBackStep2=jumpSumBackStep1;// 后退一阶在下一次迭代变为后退两阶
            jumpSumBackStep1=jumpSum;// 当前台阶在下一次迭代变为后退一阶
        }
        return jumpSum;
    }
}

　　矩形覆盖

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

依旧是斐波那契数列

2*n的大矩形，和n个2*1的小矩形

其中target*2为大矩阵的大小

有以下几种情形：

(1) target <= 0 大矩形为<= 2*0,直接return 1；

(2) target = 1大矩形为2*1，只有一种摆放方法，return1；

(3) target = 2 大矩形为2*2，有两种摆放方法，return2；

(4) target = n 分为两步考虑：

        第一次摆放一块 2*1 的小矩阵，则摆放方法总共为f(target - 1)

 

√
√

 

 

　　第一次摆放一块1*2的小矩阵，则摆放方法总共为f(target-2)

　　因为，摆放了一块1*2的小矩阵（用√√表示），对应下方的1*2（用××表示）摆放方法就确定了，所以为f(targte-2)

√	√
×	×

public class Solution {
    public int RectCover(int target) {
        if (target < 1) {
            return 0;
        } else if (target == 1 || target == 2) {
            return target;
        } else {
            return RectCover(target-1) + RectCover(target-2);
        }
    }
}

2.求100以内的素数

　素数，是指在大于1的自然数中，除了1和它本身以外，不能被其他数整除的数。

　合数，比1大但不是素数的。

　1和0既非素数也非合数

如：2,3,5,7....　

package mianshiti;

public class primenumber {

	public static void main(String[] args) {
		int n=0;//用来计算当前是第几个素数
		for(int i=2;i<=100;i++){
			if(isPrime(i)){
				n++;
				System.out.print(i+"\t");
				if(n%10==0){//每10个数，换一次行
					System.out.print("\n");
				}
			}
		}

	}
	 static boolean isPrime(int number){
		for(int i=2;i<=Math.sqrt(number);i++){//用一个数除以其他数，只要除到这个数的根号Math.sqrt(number)就可以判断是否素数
			if(number%i==0){
				return false;
			}
		}
		return true;
	}
}