【算法】从斐波那契问题看待数据结构和算法

题目回顾

求斐波那契数列的第n个数

1, 1, 2 , 3, 5，8，…

	/**
     * 递归算法
     * @param n 第n个数
     * @return  第n个数的值
     */
    private static long Fibonacci(int n) {
        if(n == 1 || n == 2) {
            return 1;
        } else {
            return Fibonacci(n - 1) + Fibonacci(n - 2);
        }
    }

优化题解

递归算法的不足

• 耗时

  测试：求斐波那契数列的第50个数
  

  耗时长的原因 ： 相同入参的f(n)被重复执行

  

• 占用较多系统栈空间

  相同入参的f(n)等待返回值，未找到递归出口会一直堆积在系统栈中

算法改良思路

1. 消除重复计算 —— 引入数据结构

处理方式：保存f(n)的运算结果

如 ： f(5) = f(4) + **f(3) **

​ f(4) = **f(3) ** + f(2)

​ f(3) = f(2) + f(1)

当f(3)完成计算后，存入公共容器，下次需要f(3)计算结果直接返回

选用数据结构 —— 数组arr

第1个数 = 1

第2个数 = 1

第3个数 = 2

…

第 n 个数 = （要求的数）

n 可以成为数组的下标

arr[n] 为返回值

    long[] result = new long[n + 1]; // n + 1 防止数组越界
    result[1] = 1;
    result[2] = 1;
	return result[n];

思考一个问题 :

​ 求100以内的所有素数能不能用数组优化？（可以，存储的是将要计算的值）代码

---

2.减少栈空间使用 —— 消除递归

原来递归的调用顺序顺序 n - > n-1 -> … -> 5 -> 3 -> 2 -> 1 其中

换个角度思考问题，使用循环可以同样取到目标值

将调用顺序改为 1 -> 2 -> 3 ->… -> n -1 -> n

	for(int i = 3; i <= n; i++) {
        // result[1] 和 result[2] 的值巧妙的结合在表达式里，并防止越界
		result[i] = result[i - 1] + result[i - 2];
	}

思考一个问题 :

​ 查找目录结构可以用循环取代递归吗？（可以，需要自己用Stack模拟系统栈，找到最大目录深度，代码待填坑）

---

3. 生成算法 —— 动态规划

    private static long FibonacciWithArray(int n) {
        // n + 1 防止数组越界
        long[] result = new long[n + 1]; 
        result[1] = 1;
        result[2] = 1;
        for(int i = 3; i <= n; i++) {
            result[i] = result[i - 1] + result[i - 2];
        }
        // 数组的第n个元素存放的是第n个斐波那契数列
        return result[n];
    }

动态规划算法

优势

​ 时间消耗从 39 秒优化到了 1 毫秒以内，减少系统栈空间使用

---

劣势

​ long[] result = new long[n + 1]; 增加堆内存的使用

总结

• 算法的实现

  • 从不同的角度思考问题：（存储、遍历…等）

• 斐波那契问题

  • 递归算法 -> 没有使用数据结构
  • 动态规划算法 -> 使用了数据结构：数组
  • 综上，算法和数据结构都可以独立存在，但是数据结构可以成为算法的组成部分。

• HashMap

  • HashMap 是 Java 提供的应用层数据结构
  • HashMap 的实现是借助 数组 + 链表（红黑树）+ 两个数据结构的协同算法
  • 综上，强大的数据结构往往结合了优秀的算法，优秀的算法又可能依赖数据结构。

• 斐波那契问题 + HashMap

  • 数据结构和算法的关系是可以独立存在，又能相辅相成