算法Algorithm

什么是数据结构？

　　数据结构就是指一组数据的存储结构

什么是算法？

　　算法就是操作数据的一组方法

 

　复杂度分析：

　　要衡量代码的执行效率，则需要用到时间、空间复杂度分析。一般使用（大O复杂度表示法）

　　

　　1、时间复杂度

　　所有代码的执行时间与每行代码的执行次数是成正比的，而每行代码的执行次数和数据规模n也是成正比的。

 　　大O时间复杂度表示实际上并不具体表示代码真正的执行事件，而是表示代码执行时间随数据规模增长的变化趋势，所以也叫做渐进时间复杂度，简称时间复杂度。

　　　时间复杂度分析：

　　　　1）只关注循环执行次数最多的一段代码

　　　　　大O复杂度表示法只是表示一种变化的趋势，通常可以忽略掉公式中的常量、低阶、系数，只需要记录一个最大阶的量级就可以了。所以在分析一个算法的事件复杂度的时候，循环执行次数最多的那段代码的执行次数与数据规模n的量级关系就是整个算法的时间复杂度

　　　　2）嵌套代码的复杂度等于嵌套内外代码复杂度的乘积

 

　　常见的几种时间复杂度：

　　　　

    O(1) < O(logN) < O(N) < O(NlogN) < O(N²) < O(2^N) < O(N!)

    

    

 　　O(1)：只要代码的执行时间不随着n的增大而增长，这样的代码的时间复杂度都是O(1)。一般情况下，只要算法中不存在循环语句、递归语句，不管有多少行代码，其时间复杂度都是O(1)。

　　 O(logn)：代码执行的次数是一个等比数列，随着n的增长，代码执行的次数 呈对数阶的增长

    对数阶与指数阶相反，指数阶为 『每轮分裂出两倍的情况』，而对数阶是『每轮排除一半的情况』，对数阶常出现于二分法、分治等算法中，体现着一分为2，或一分为多的算法思想。

    

   O(n)：循环运行次数与n 大小呈线性关系，时间复杂度为 O(N)

    

   O(nlogn)：两层循环相互独立，第一层和第二层时间复杂度分别为 O(logN) 和 O(N)，则总体时间复杂度为 O(N \log N)O(NlogN)

   O(n²)：两层循环相互独立，都与 N呈线性关系，因此总体与 N 呈平方关系

    

  O(2^N)：指数 

    生物学科中的 “细胞分裂” 即是指数级增长。初始状态为 1 个细胞，分裂一轮后为 2 个，分裂两轮后为 4 个，……，分裂 N 轮后有 2^N个细胞

    算法中，指数阶常出现于递归

  O(N!) ：阶乘

    阶乘阶对应数学上常见的 “全排列” 。即给定 NN 个互不重复的元素，求其所有可能的排列方案，则方案数量为：

    N * (N - 1) * (N - 2) * ⋯ * 2 * 1 = N!

    阶乘常使用递归实现，算法原理：第一层分裂出 N 个，第二层分裂出 N−1 个，…… ，直至到第 N 层时终止并回溯

 

    

 

　　2、空间复杂度 

　　空间复杂度的全称是渐进空间复杂度，表示算法的存储空间与数据规模之间的增长关系。

　　空间复杂度的分析要比时间复杂度分析简单。只需要关注代码执行时有没有申请额外的空间即可。

 

 

 

　　递归算法

　　　　递归分为两个过程，去的过程：递 ；回的过程：归。

　　　　

　　　　递归需要满足的三个条件：

　　　　①：一个问题的解可以分解为几个子问题（数据规模更小的问题）的解

　　　　②：这个问题和分解之后的子问题，除了数据规模不同外，求解思路完全一样

　　　　③：存在递归终止条件（递归出口）

 

　　　　写递归代码的关键：找到如何将大问题分解为小问题的规律，并基于此写出递推公式，找到终止条件，最后将递推公式和终止条件转化为代码。

 

　　　　二次递归调用执行过程：

　　　　　　和二叉树的前序遍历执行流程一致。根左右

　　　　　　左子节点不断入栈，直到没有左子节点，再回溯输出各个右子节点。

    /**
     * 前序遍历,根左右
     */
    public static void preTraversalTree(TreeNode node) {
        if (node == null) {
            return;
        }
        System.out.println(node.data);
        preTraversalTree(node.leftChild);// 递归I，左子节点不断入栈，直到没有左子节点，再挨个输出结果
        preTraversalTree(node.rightChild); // 递归II
    }

 　　　　　　执行流程如下所示：

　　　　

　　　　　　①：递归I，左子节点不断（1，2，3）入栈，直到达到出口条件（3出栈）

　　　　　　②：执行递归II，（4入栈），满足出口条件，4出栈

　　　　　　③：节点2的子节点3，4皆出栈，可计算出2的结果，因此2节点出栈

　　　　　　④：执行递归II，5进栈

　　　　　　⑤：执行递归I，6进栈，满足出口条件，6出栈

　　　　　　⑥：执行递归II，7进栈，满足出口条件，7出栈

　　　　　　⑦：节点5的子节点6，7皆出栈，可计算出5的结果，因此5节点出栈

　　　　　　⑧：节点1的子节点2，5皆出栈，可计算出1的结果，因此1出栈，递归结束

 

 

　　贪心算法

　　　　在对问题求解时，总是做出在当前看来是最好的选择。

　　　　也就是说不从整体最优上加以考虑，算法得到的是在某种意义上的局部最优解。

　　　　因此，贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择。选择的贪心策略必须具备无后效性（即某个状态以后的过程不会影响以前的状态，只与当前状态有关。）

　　　　贪心算法有很多经典的应用，比如霍夫曼编码（Huffman Coding）、Prim 和 Kruskal 最小生成树算法、还有 Dijkstra 单源最短路径算法。

　　　　

　　　　可以使用贪心算法的问题需要满足的条件：

　　　　　　① 最优子结构：规模较大的问题的解由规模较小的子问题的解组成，区别于「动态规划」，可以使用「贪心算法」的问题「规模较大的问题的解」只由其中一个「规模较小的子问题的解」决定

　　　　　　② 无后效性：后面阶段的求解不会修改前面阶段已经计算好的结果

　　　　　　③ 贪心选择性质：从局部最优解可以得到全局最优解

 

　　　　适用贪心算法的问题类型：

　　　　　　针对一组数据，我们定义了限制值和期望值，希望从中选出几个数据，在满足限制值的情况下，期望值最大。（如背包问题）

　　　　　　 

 

 

　　分治算法 

　　　　分治算法（divide and conquer）的核心思想：分而治之。

　　　　也就是将原问题划分成n个规模较小，并且结构与原问题相似的子问题，递归地解决这些子问题，然后再合并其结果，就得到原问题的解。

　　　　分治算法一般都比较适合用递归来实现。分治算法的递归实现中，每一层递归都会涉及以下三个操作：

　　　　　　① 分解：将原问题分解成一系列子问题

　　　　　　② 解决：递归地求解各个子问题，若子问题足够小，则直接求解

　　　　　　③ 合并：将子问题的结果合并得到原问题的解

　　　　分治算法能解决的问题，一般需要满足下面这几个条件：

　　　　　　① 原问题与分解成的小问题具有相同的模式

　　　　　　② 原问题分解成的子问题可以独立求解，子问题之间没有相关性（这也是分治和动态规划的明显区别）

　　　　　　③ 具有分解终止条件，也就是说，当问题足够小时，可以直接求解

　　　　　　④ 可以将子问题合并成原问题，而这个合并操作的复杂度不能太高，否则就起不到减小算法总体复杂度的效果了　　　　

 

 

　　回溯算法

 　　　　回溯的处理思想，有点类似枚举搜索。我们枚举所有的解，找到满足期望的解。为了有规律地枚举所有可能的解，避免遗漏和重复，我们把问题求解的过程分为多个阶段。每个阶段，我们都会面对一个岔路口，我们先随意选一条路走，当发现这条路走不通的时候（不符合期望的解），就回退到上一个岔路口，另选一种走法继续走。

　　　　深度优先搜索算法利用的是回溯算法思想。除此之外，很多经典的数学问题都可以用回溯算法解决，比如数独、八皇后、0-1 背包、图的着色、旅行商问题、全排列等等

　　　　回溯算法非常适合用递归代码实现

　　　　

 

 

 

　　动态规划

　　　　动态规划（Dynamic Programming，简称DP），通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。

　　　　简单来说动态规划就是：给定一个问题，我们将它拆成一个个子问题，直到子问题可以直接解决。然后呢，把子问题答案保存起来，以减少重复计算。再根据子问题自底向上一步一步动态递推，最终得到复杂问题的最优解。

　　即，把问题分解为多个阶段，每个阶段对应一个决策，我们记录每一个阶段可达的状态集合（去掉重复的），然后通过当前阶段的状态集合，来推导下一个阶段的状态集合，动态地往前推进。

　　　　动态规划核心思想：拆分子问题，记住过往，减少重复计算

 

　　　　动态规划适合解决的问题：

　　　　　　问题模型：多阶段决策最优解模型

　　　　　　　我们一般用动态规划来解决最优问题。而解决问题的过程，需要经历多个决策阶段。每个决策阶段都对应着一组状态，且下一组决策的状态是在上一组决策状态的基础上生成。所有决策阶段完毕之后，我们寻找一组决策序列，获取能够产生最终期望求解的最优值。

　　　　　　问题特征：

　　　　　　　　①：最优子结构

　　　　　　　　　　最优子结构指的是，问题的最优解包含子问题的最优解。反过来说就是，我们可以通过子问题的最优解，推导出问题的最优解。如果我们把最优子结构，对应到我们前面定义的动态规划问题模型上，那我们也可以理解为，后面阶段的状态可以通过前面阶段的状态推导出来

　　　　　　　　②：重复子问题

　　　　　　　　　　不同的决策序列，到达某个相同的阶段时，可能会产生重复的状态。

　　　　　　

　　　　

　　　　动态规划和递归的解法基本思想是一致的，区别在于

　　　　　　递归是从栈顶自上而下延伸求解的，所以也称为自顶向下的解法

　　　　　　动态规划从较小问题的解，由交叠性质，逐步决策出较大问题的解。是自底向上，推导求解，所以称为自底向上的解法。

　　　　

　　　　动态规划有几个典型特征：最优子结构、状态转移方程、边界（初始状态）、重复子问题

　　　　如斐波那契数列中：

　　　　　　①：f(n-1)和f(n-2)　　称为f(n)的最优子结构

　　　　　　②：f(n)=f(n-1)+f(n-2) 　　就称为状态转移方程，即最优解和最优子结构之间的关系

　　　　　　③：f(0)=0，f(1)=1　　就是边界

　　　　　　④：比如 f(10)= f(9)+f(8)，f(9) = f(8) + f(7) ，f(8) 就是重复子问题 

    /**
     * 状态定义：设 dp 为一维数组，其中 dp[i] 的值代表 斐波那契数列第 i 个数字
     * 转移方程：dp[i+1]=dp[i]+dp[i−1] ，即对应数列定义 f(n+1)=f(n)+f(n−1)
     * 边界：dp[0]=0, dp[1] = 1 ，即初始化前两个数字
     * 返回值：dp[n] ，即斐波那契数列的第 n 个数字
     */
    public int fib(int n) {
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007;
        }
        return dp[n];
    }

　　　　

 

　　　　什么样的问题可以使用动态规划来解决呢？

　　　　　　如果一个问题，可以把所有可能的答案穷举出来，并且穷举出来后，发现存在重叠子问题，就可以考虑使用动态规划。

　　　　　　比如一些求最值的场景，如最长递增子序列、最小编辑距离、背包问题、凑零钱问题等，都是动态规划的经典应用场景。

 

　　　　动态规划的解题思路：

　　　　　　动态规划的核心思想就是拆分子问题，记住过往，减少重复计算。并且动态规划一般都是自底向上的。

　　　　　　①：穷举分析

　　　　　　②：确定边界

　　　　　　③：找出规律，确定最优子结构（子问题的最优决策可导出原问题的最优决策）

　　　　　　④：写出状态转移方程 

 

　　　　动态规划解题框架：

　　　　　　若确定给定问题具有重叠子问题和最优子结构，那么就可以使用动态规划求解。总体上来看，求解可分为四步：

　　　　　　① 状态定义：构建问题最优解模型，包括问题最优解的定义、有哪些计算解的自变量

　　　　　　② 初始状态：确定基础子问题的解（即已知解），原问题和子问题的解都是以基础子问题的解为起点，在迭代计算中得到的

　　　　　　③ 状态转移方程：确定原问题的解与子问题的解之间的关系是什么，以及使用何种选择规则从子问题最优解组合中选出原问题最优解

　　　　　　④ 返回值：确定应返回的问题的解是什么，即动态规划在何处停止迭代

　　

 

　　　　动态规划代码框架：

dp[0][0][...] = 边界值
for(状态1 ：所有状态1的值){
    for(状态2 ：所有状态2的值){
        for(...){
          //状态转移方程
          dp[状态1][状态2][...] = 求最值
        }
    }
}

 

　　　　动态规划示例：背包问题

　　　　把求解过程分为n个阶段，每个阶段会决策一个物品是否放入背包中。每个物品决策（放入或不放入背包）之后，背包中的物品会有多种情况，即会达到多种不同的状态。

　　　　把每一层重复的（节点）合并，只记录不同的状态，然后基于上一层的状态集合，来推导下层的状态集合。我们可以通过合并每一层重复的状态，这样就保证每一层不同状态的个数都不会超过 w 个（w 表示背包的承载重量）

　　　　使用二维数组 states[n][w+1] 来记录每层可以达到的不同状态，n是物品的数量，w是背包的承载重量。如n=5，w=9，物品的重量分别为2,2,4,6,3时：

　　　　　　

 　　　　第0个（下标从0开始）的物品重量为2，要么装入背包，要么不装入背包，决策完之后，会对应背包的两种状态，背包中物品的总重量是0或2，用dp[0][0]=true,dp[0,2]=true;来表示这两种状态

　　　　 第1个物品的重量也是2，基于之前物品1的状态，因此在决策完之后，有0,2(0+2 or 2+0),4(2+2)三种状态，分别用dp[1][0]=true,dp[1][2]=true,dp[1][4]=true来表示。

　　　　以此类推，直到决策完所有物品后，整个dp二维数组就计算好了。这时候只需要在最后一层，找一个值为true，且最接近 w(9) 的值，就是背包中物品总重量的最大值。

    /**
     * 动态规划求解01背包问题
     *
     * @param weight 物品重量
     * @param n      物品个数
     * @param w      背包可承载重量
     * @return
     */
    public int knapsack(int[] weight, int n, int w) {
        // 定义状态数组，默认值false
        boolean[][] dp = new boolean[n][w + 1];
        // 特殊处理第一行的数据，作为初始状态
        // 第一个物品不放入背包
        dp[0][0] = true;
        // 第一个物品放入背包
        if (weight[0] <= w) {
            dp[0][weight[0]] = true;
        }

        // 循环决策每个物品
        for (int i = 1; i < n; ++i) {
            // 动态规划状态转移方程，根据上一层的决策，生成当前层的决策
            for (int j = 0; j <= w; ++j) {
                // 不把第i个物品放入背包，下一层的值和上一层相同
                if (dp[i - 1][j] == true) {
                    dp[i][j] = dp[i - 1][j];
                }
            }
            for (int j = 0; j <= w - weight[i]; ++j) {
                // 把第i个物品放入背包，下一层的值为上一层的值+当前物品的重量
                if (dp[i - 1][j] == true) {
                    dp[i][j + weight[i]] = true;
                }
            }
        }
        // 输出结果
        for (int i = w; i >= 0; --i) {
            if (dp[n - 1][i] == true) {
                return i;
            }
        }
        return 0;
    }

 

　　　　

 

 

 

 

　　　　

 

　　　　贪心算法与回溯算法、动态规划的区别:

　　　　「解决一个问题需要多个步骤，每一个步骤有多种选择」这样的描述我们在「回溯算法」「动态规划」算法中都会看到。它们的区别如下：

　　　　　　「回溯算法」需要记录每一个步骤、每一个选择，用于回答所有具体解的问题；（有多次回溯重新选择的机会）

　　　　　　「动态规划」需要记录的是每一个步骤、所有选择的汇总值（最大、最小或者计数）；

　　　　　　「贪心算法」由于适用的问题，每一个步骤只有一种选择，一般而言只需要记录与当前步骤相关的变量的值。（一条路走到底，每次做出最优选择）

　　

 

 

 

 

　　 

END.