斐波那契数列 动态规划

Author: YuChengKai

Algorithm/algorithm-ch.md

@@ -18,6 +18,7 @@
   - [系统自带排序实现](#%E7%B3%BB%E7%BB%9F%E8%87%AA%E5%B8%A6%E6%8E%92%E5%BA%8F%E5%AE%9E%E7%8E%B0)
 - [链表](#%E9%93%BE%E8%A1%A8)
   - [反转单向链表](#%E5%8F%8D%E8%BD%AC%E5%8D%95%E5%90%91%E9%93%BE%E8%A1%A8)
+- [树](#%E6%A0%91)
   - [二叉树的先序，中序，后序遍历](#%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%85%88%E5%BA%8F%E4%B8%AD%E5%BA%8F%E5%90%8E%E5%BA%8F%E9%81%8D%E5%8E%86)
     - [递归实现](#%E9%80%92%E5%BD%92%E5%AE%9E%E7%8E%B0)
     - [非递归实现](#%E9%9D%9E%E9%80%92%E5%BD%92%E5%AE%9E%E7%8E%B0)
@@ -28,7 +29,7 @@
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
-### 时间复杂度
+# 时间复杂度
 
 通常使用最差的时间复杂度来衡量一个算法的好坏。
 
@@ -38,7 +39,7 @@
 
 当然可能会出现两个算法都是 O(N) 的时间复杂度，那么对比两个算法的好坏就要通过对比低阶项和常数项了。
 
-### 位运算
+# 位运算
 
 位运算在算法中很有用，速度可以比四则运算快很多。
 
@@ -47,15 +48,15 @@
 - 十进制 `33` 可以看成是 `32 + 1` ，并且 `33` 应该是六位二进制的（因为 `33` 近似 `32`，而 `32` 是 2 的五次方，所以是六位），那么 十进制 `33` 就是 `100001` ，只要是 2 的次方，那么就是 1否则都为 0
 - 那么二进制 `100001` 同理，首位是 `2^5` ，末位是 `2^0` ，相加得出 33
 
-#### 左移 <<
+## 左移 <<
 
 ```js
 10 << 1 // -> 20
 ```
 
 左移就是将二进制全部往左移动，`10` 在二进制中表示为 `1010` ，左移一位后变成 `10100` ，转换为十进制也就是 20，所以基本可以把左移看成以下公式 `a * (2 ^ b)`
 
-#### 算数右移 >>
+## 算数右移 >>
 
 ```js
 10 >> 1 // -> 5
@@ -69,7 +70,7 @@
 13 >> 1 // -> 6
 ```
 
-#### 按位操作
+## 按位操作
 
 **按位与**
 
@@ -116,7 +117,7 @@ function sum(a, b) {
 }
 ```
 
-### 排序
+# 排序
 
 以下两个函数是排序中会用到的通用函数，就不一一写了
 
@@ -131,7 +132,7 @@ function swap(array, left, right) {
 }
 ```
 
-#### 冒泡排序
+## 冒泡排序
 
 冒泡排序的原理如下，从第一个元素开始，把当前元素和下一个索引元素进行比较。如果当前元素大，那么就交换位置，重复操作直到比较到最后一个元素，那么此时最后一个元素就是该数组中最大的数。下一轮重复以上操作，但是此时最后一个元素已经是最大数了，所以不需要再比较最后一个元素，只需要比较到 `length - 1` 的位置。
 
@@ -156,7 +157,7 @@ function bubble(array) {
 
 该算法的操作次数是一个等差数列 `n + (n - 1) + (n - 2) + 1` ，去掉常数项以后得出时间复杂度是 O(n * n)
 
-#### 插入排序
+## 插入排序
 
 插入排序的原理如下。第一个元素默认是已排序元素，取出下一个元素和当前元素比较，如果当前元素大就交换位置。那么此时第一个元素就是当前的最小数，所以下次取出操作从第三个元素开始，向前对比，重复之前的操作。
 
@@ -177,7 +178,7 @@ function insertion(array) {
 
 该算法的操作次数是一个等差数列 `n + (n - 1) + (n - 2) + 1` ，去掉常数项以后得出时间复杂度是 O(n * n)
 
-#### 选择排序
+## 选择排序
 
 选择排序的原理如下。遍历数组，设置最小值的索引为 0，如果取出的值比当前最小值小，就替换最小值索引，遍历完成后，将第一个元素和最小值索引上的值交换。如上操作后，第一个元素就是数组中的最小值，下次遍历就可以从索引 1 开始重复上述操作。
 
@@ -201,7 +202,7 @@ function selection(array) {
 
 该算法的操作次数是一个等差数列 `n + (n - 1) + (n - 2) + 1` ，去掉常数项以后得出时间复杂度是 O(n * n)
 
-#### 归并排序
+## 归并排序
 
 归并排序的原理如下。递归的将数组两两分开直到最多包含两个元素，然后将数组排序合并，最终合并为排序好的数组。假设我有一组数组 `[3, 1, 2, 8, 9, 7, 6]`，中间数索引是 3，先排序数组 `[3, 1, 2, 8]` 。在这个左边数组上，继续拆分直到变成数组包含两个元素（如果数组长度是奇数的话，会有一个拆分数组只包含一个元素）。然后排序数组 `[3, 1]` 和 `[2, 8]` ，然后再排序数组 `[1, 3, 2, 8]` ，这样左边数组就排序完成，然后按照以上思路排序右边数组，最后将数组 `[1, 2, 3, 8]` 和 `[6, 7, 9]` 排序。
 
@@ -269,7 +270,7 @@ mergeSort(data, 0, 6) // mid = 3
 
 该算法的操作次数是可以这样计算：递归了两次，每次数据量是数组的一半，并且最后把整个数组迭代了一次，所以得出表达式 `2T(N / 2) + T(N)` （T 代表时间，N 代表数据量）。根据该表达式可以套用 [该公式](https://www.wikiwand.com/zh-hans/%E4%B8%BB%E5%AE%9A%E7%90%86) 得出时间复杂度为 `O(N * logN)`
 
-#### 快排
+## 快排
 
 快排的原理如下。随机选取一个数组中的值作为基准值，从左至右取值与基准值对比大小。比基准值小的放数组左边，大的放右边，对比完成后将基准值和第一个比基准值大的值交换位置。然后将数组以基准值的位置分为两部分，继续递归以上操作。
 
@@ -319,7 +320,7 @@ function part(array, left, right) {
 
 该算法的复杂度和归并排序是相同的，但是额外空间复杂度比归并排序少，只需 O(logN)，并且相比归并排序来说，所需的常数时间也更少。
 
-##### 面试题
+### 面试题
 
 **Sort Colors**：该题目来自 [LeetCode](https://leetcode.com/problems/sort-colors/description/)，题目需要我们将 `[2,0,2,1,1,0]` 排序成 `[0,0,1,1,2,2]` ，这个问题就可以使用三路快排的思想。
 
@@ -387,7 +388,7 @@ function part(array, left, right) {
 
 
 
-#### 堆排序
+## 堆排序
 
 堆排序利用了二叉堆的特性来做，二叉堆通常用数组表示，并且二叉堆是一颗完全二叉树（所有叶节点（最底层的节点）都是从左往右顺序排序，并且其他层的节点都是满的）。二叉堆又分为大根堆与小根堆。
 
@@ -451,7 +452,7 @@ function heapify(array, index, size) {
 
 该算法的复杂度是 O(logN)
 
-#### 系统自带排序实现
+## 系统自带排序实现
 
 每个语言的排序内部实现都是不同的。
 
@@ -461,9 +462,9 @@ function heapify(array, index, size) {
 
 <div align="center"><img src="https://user-gold-cdn.xitu.io/2018/4/18/162d7df247dcda00?w=440&h=727&f=png&s=38002" height=500 /></div>
 
-### 链表
+# 链表
 
-#### 反转单向链表
+## 反转单向链表
 
 该题目来自 [LeetCode](https://leetcode.com/problems/reverse-linked-list/description/)，题目需要将一个单向链表反转。思路很简单，使用三个变量分别表示当前节点和当前节点的前后节点，虽然这题很简单，但是却是一道面试常考题
 
@@ -491,17 +492,19 @@ var reverseList = function(head) {
 };
 ```
 
-###树
 
-#### 二叉树的先序，中序，后序遍历
+
+# 树
+
+## 二叉树的先序，中序，后序遍历
 
 先序遍历表示先访问根节点，然后访问左节点，最后访问右节点。
 
 中序遍历表示先访问左节点，然后访问根节点，最后访问右节点。
 
 后序遍历表示先访问左节点，然后访问右节点，最后访问根节点。
 
-##### 递归实现
+### 递归实现
 
 递归实现相当简单，代码如下
 
@@ -526,7 +529,7 @@ var traversal = function(root) {
 
 对于递归的实现来说，只需要理解每个节点都会被访问三次就明白为什么这样实现了。
 
-##### 非递归实现
+### 非递归实现
 
 非递归实现使用了栈的结构，通过栈的先进后出模拟递归实现。
 
@@ -609,15 +612,15 @@ function pos(root) {
 }
 ```
 
-#### 中序遍历的前驱后继节点
+## 中序遍历的前驱后继节点
 
 实现这个算法的前提是节点有一个 `parent` 的指针指向父节点，根节点指向 `null` 。
 
 <div align="center"><img src="https://user-gold-cdn.xitu.io/2018/4/24/162f61ad8e8588b7?w=682&h=486&f=png&s=41027" width=400 /></div>
 
 如图所示，该树的中序遍历结果是 `4, 2, 5, 1, 6, 3, 7`
 
-##### 前驱节点
+### 前驱节点
 
 对于节点 `2` 来说，他的前驱节点就是 `4` ，按照中序遍历原则，可以得出以下结论
 
@@ -651,7 +654,7 @@ function getRight(node) {
 }
 ```
 
-##### 后继节点
+### 后继节点
 
 对于节点 `2` 来说，他的后继节点就是 `5` ，按照中序遍历原则，可以得出以下结论
 
@@ -685,7 +688,7 @@ function getLeft(node) {
 }
 ```
 
-#### 树的深度
+## 树的深度
 
 **树的最大深度**：该题目来自 [Leetcode](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)，题目需要求出一颗二叉树的最大深度
 
@@ -700,3 +703,55 @@ var maxDepth = function(root) {
 
 对于该递归函数可以这样理解：一旦没有找到节点就会返回 0，每弹出一次递归函数就会加一，树有三层就会得到3。
 
+# 动态规划
+
+动态规划背后的基本思想非常简单。就是将一个问题拆分为子问题，一般来说这些子问题都是非常相似的，那么我们可以通过只解决一次每个子问题来达到减少计算量的目的。
+
+一旦得出每个子问题的解，就存储该结果以便下次使用。
+
+## 斐波那契数列
+
+斐波那契数列就是从 0 和 1 开始，后面的数都是前两个数之和
+
+0，1，1，2，3，5，8，13，21，34，55，89....
+
+那么显然易见，我们可以通过递归的方式来完成求解斐波那契数列
+
+```js
+function fib(n) {
+  if (n < 2 && n >= 0) return n
+  return fib(n - 1) + fib(n - 2)
+}
+fib(10)
+```
+
+以上代码已经可以完美的解决问题。但是以上解法却存在很严重的性能问题，当 n 越大的时候，需要的时间是指数增长的，这时候就可以通过动态规划来解决这个问题。
+
+动态规划的本质其实就是两点
+
+1. 自底向上分解子问题
+2. 通过变量存储已经计算过的解
+
+根据上面两点，我们的斐波那契数列的动态规划思路也就出来了
+
+1. 斐波那契数列从 0 和 1 开始，那么这就是这个子问题的最底层
+2. 通过数组来存储每一位所对应的斐波那契数列的值
+
+```js
+function fib(n) {
+  let array = new Array(n + 1).fill(null)
+  array[0] = 0
+  array[1] = 1
+  for (let i = 2; i <= n; i++) {
+    array[i] = array[i - 1] + array[i - 2]
+  }
+  return array[n]
+}
+fib(10)
+```
+
+
+
+343
+
+0-1背包