通过斐波那契数列学习时间复杂度

时间复杂度

首先我们通过递归和遍历求和两种方式来实现对斐波那契数列求和：

	/**
	 * 求斐波那契数列的和(每个数是前两个的和)
	 * 1 1 2 3 5 8 13 21 34 ....
	 */
	public static int fib1(int n) {
		if(n<=1) return n;	
		return fib1(n-1)+fib1(n-2);
	}
	
	public static int fib2(int n) {
		if(n<=1) return n;
		int first =0;
		int second =1;
		for (int i = 0; i < n-1; i++) {
			int sum = first + second;
			first = second;
			second = sum;
		}
		return second;
	}

时间复杂度：如何快速预估上面对斐波那契数列的两种求和方式那种效率更高呢，通过估算程序指令的执行次数（执行时间），也就是渐进时间复杂度。

时间复杂度的计算

public static void test1(int n) {
		//1
		if(n>10) {
			System.out.println("n>10");
		} else if (n>5) {
			System.out.println("n>5");
		} else {
			System.out.println("n<=5");
		}
		//1+4+4+4
		for (int i = 0; i < 4; i++) {
			System.out.println("test");
		}
	}

上面方法的程序指令执行了14次（看注释分析理解），用大O表示法就是 O(1)

public static void test2(int n) {
		//1+3n
		for(int i = 0; i < n; i++) {
			System.out.println("test");
		}
	}

上面方法的程序指令执行了1+3n次，用大O表示法就是 O(n)

public static void test3(int n) {
		//1 + 2n + n * (1 + 3n) == 3n^2 + 3n + 1
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				System.out.println("test");
			}
		}
	}

上面方法的程序指令执行了3n² + 3n + 1次，用大O表示法就是 O(n²)

public static void test4(int n) {
		//1 + 2n + n * (1 + 45) == 48n + 1
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < 15; j++) {
				System.out.println("test");
			}
		}
	}

上面方法的程序指令执行了48n + 1次，用大O表示法就是 O(n)

public static void test5(int n) {
		/**
		 * 8 = 2^3
		 * 16 = 2^4
		 * 
		 * 3 = log2(8)
		 * 4 = log2(16)
		 * 
		 * 其实是求2的n次方，执行次数 = log2(n)
		 */
		while ((n = n / 2) > 0) {
			System.out.println("test");
		}
	}

上面方法的程序指令执行了log2(n)次，用大O表示法就是 O(logn)

public static void test6(int n) {
		/**
		 * 其实是求5的n次方，执行次数 = log5(n)
		 */
		while ((n = n / 5) > 0) {
			System.out.println("test");
		}
	}

上面方法的程序指令执行了log5(n)次，用大O表示法就是 O(logn)

public static void test7(int n) {
		/**
		 * 关键点：i += i ==>  i = i * 2
		 * 分析： n < i * 2 * 2 * 2 ...  
		 * i乘以多少次2会大于n  ==> log2(n)
		 * 最终结果：1 + 3*log2(n) + 2 * nlog2(n)
		 */
		for (int i = 1; i < n; i += i) {
			for (int j = 0; j < n; j++) {
				System.out.println("test");
			}
		}
	}

上面方法的程序指令执行了1 + 3*log2(n) + 2 * nlog2(n)次，用大O表示法就是 O(nlogn)

大O表示法

通过上面的复杂度计算，感觉计算的结果看起来还是很复杂，那么我们可以用大O表示法来进行复杂度估算。

• 一般用大O表示法来描述复杂度，它表示的是数据规模n对应的复杂度
• 忽略常数、系数、低阶
  
  
  注意：大O表示法仅仅是一种粗略的分析模型，是一种估算，能帮助我们短时间内了解一个算法的效率。
  

斐波那契数列复杂度分析

用递归的方式，复杂度O(2ⁿ)

用遍历求和的方式，复杂度O(n)

于是可以很快的分析出第二种求和方式优于递归。