数据结构与算法学习笔记十四--算法

1. 二分查找算法（非递归）

1. 二分查找法只适用于从有序的数列中进行查找（比如数字和字母等），将数列排序后再进行查找
2. 二分查找法的运行时间为对数时间 O(log2n),即查找到需要的目标位置最多只需要log2n步，假设从[0,99] 的队列（100个数，即n=100中寻到目标数30，则需要查找步数为log2100，即最多需要查找7次（2^6 < 100 < 2 ^7））

1.1 二分查找算法（非递归）代码实现

public class BinarySearchNoRecur {

    public static void main(String[] args) {
        // 测试
        int[] arr = {1,3,8,10,11,67,100};
        int index = binarySearch(arr, 67);
        System.out.println("index = " + index);
    }



    // 二分查找的非递归实现
    /**
     * 
     * @param arr 待查找的数组，arr是
     * @param target
     * @return
     */
    public static int binarySearch(int[] arr,int target) {
        int left = 0;
        int right = arr.length - 1;
        while(left <= right) {//说明继续查找
            int mid = (left + right) / 2;
            if(arr[mid] == target) {
                return mid;
            } else if (arr[mid] > target) {
                right = mid - 1;//需要向左查找
            } else {
                left = mid + 1;//需要向右边查找
            }
        } 
        return -1;  
    }
}

2. 分治算法

2.1 分治算法介绍

1. 分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题。。。直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法（快速排序，归并排序），傅里叶变换（快速傅里叶变换）。。。
2. 分治算法可以求解的一些经典问题

• 二分搜索
• 大整数乘法
• 棋盘覆盖
• 合并排序
• 快速排序
• 线性时间选择
• 最接近点对问题
• 循环赛日程表
• 汉诺塔

2.2 分治算法的基本步骤

分治法在每一层递归上都有三个步骤：

1. 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题
2. 解决：若子问题规模较小而容易被解决则直接解，否则递归的解各个子问题
3. 合并：将各个子问题的解合并为原问题的解。

2.3 分治算法最佳实践–汉诺塔

汉诺塔游戏的演示和思路分析：

1. 如果是有一个盘，A->C
2. 如果我们有 n>= 2的情况，我们总是可以看做是两个盘：1. 最下边的盘 2.上面的盘
   2.1）先把 最上面的盘 A->B
   2.2） 把最下边的盘 A-> C
   2.3) 把B塔的所有盘 从 B->C

2.4 汉诺塔代码实现

public class Hanoitower {

    public static void main(String[] args) {
        Hanoitower(5, 'A', 'B', 'C');
    }
    

    // 汉诺塔--分治算法
    public static void Hanoitower(int num, char a, char b, char c) {
        // 如果只有一个盘
        if(num == 1) {
            System.out.println("第一个盘从" + a + "->" + c);
        } else {
            // 如果我们有 n >= 2 情况，我们总是可以看作是两个盘 1.最下边的一个盘 2.上面的所有盘
            // 1.先把 最上面的所有盘 A->B，移动过程会使用到C
            Hanoitower(num - 1, a, c, b);
            // 2.把最下边的从A移到C
            System.out.println("第" + (num - 1) + "个盘从" + a + "->" + c);
            // 3.把B上面的盘移到C,移动过程会使用到a塔
            Hanoitower( num - 1, b, a, c);
        }
    }
}

3. 动态规划算法

3.1 应用场景–背包问题

背包问题：有一个背包，容量为4磅，现有如下物品

物品	重量	价格
吉他（G）	1	1500
音响（S）	4	3000
电脑（L）	3	2000

1. 要求达到的目标为装入的背包的总价值最大，并且重量不超出
2. 要求装入的物品不能重复

3.2 动态规划算法介绍

1. 动态规划（Dynamic Programming）算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法。
2. 动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
3. 与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）
4. 动态规划可以通过填表的方式来逐步推进，得到最优解。

3.3 背包问题的思路分析和图解

算法的主要思想，利用动态规划来解决。每次遍历到的第i个物品，根据w[i]和v[i]来确定是否需要将物品放入背包中。即对于给定的n个物品，设v[i],w[i]分别为第i个物品的价值和重量，c为背包的容量。再令v[i][j]表示在前i个物品中能够装入容量为j的背包中的最大价值。则我们有下面的结果：

1. v[i][0]=v[0][j]=0; //表示 填入表 第一行和第一列为0
2. 当w[i]>j时：v[i][j]=v[i-1][j]；//当准备加入新增的商品的容量大于 当前背包的容量时，就直接使用上一个单元格的装入策略。
3. 当j.=w[i]时：v[i][j]=max{v[i-1][j],v[i-1][j-w[i]]+v[i]}；//当准备加入的新增的商品的容量小于等于当前背包的容量，
   //装入的方式：
   v[i - 1][j]:就是上一个单元格的装入的最大值
   v[i]:表示当前商品的价值 v[i-1][j-w[i]]:装入i-1商品，到剩余空间j-w[i]

1. 如果装不下当前物品，那么前n个物品的最佳组合和前n-1个物品的最佳组合是一样的。
2. 如果装的下当前物品
   假设一：装当前物品，在给当前物品预留了相应空间的情况下，前n-1个物品的最佳组合加上当前物品的价值就是总价值。
   假设二：不装当前物品，那么前n个物品的最佳组合和前n-1个物品的最佳组合是一样的。
   选取假设1和假设2中较大的价值，为当前最佳组合的价值。

背包问题回溯
问题进阶：在使得背包内总价值最大的情况下，背包内装了哪些物品？

从表的右下角开始回溯，如果发现前n个物品最佳组合的价值和前n-1个物品最佳组合的价值一样，说明第n个物品没有被装入。否则，第n个物品被装入。

4. KMP算法

4.1 KMP算法介绍

1. Knuth-Morris-Pratt字符串查找算法，简称“KMP算法”，常用于在一个文本串S内查找一个模式串P的出现位置，这个算法由Donald Knuth、Vaughan Pratt、James H.Morris三人于1977年联合发表，故取这3人的姓氏命名此算法。
2. KMP算法利用之前判断过的信息，通过一个next数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过next数组找到前面匹配过的位置，省去了大量的计算时间。
3. 功能：快速的从主串中找到指定的子串
   
4. 比较指针左边上下两个子串是匹配的（红框内）
5. 模式串中有公共前后缀（白框内）【如果模式串中有多对公共前后缀，要取最长的那对】
   
   则将模式串移动到后缀匹配的位置