一、二分查找算法（非递归）

前面我们讲过了二分查找算法，是使用递归的方式，下面我们讲解二分查找算法的非递归方式
二分查找法只适用于从有序的数列中进行查找(比如数字和字母等)，将数列排序后再进行查找
二分查找法的运行时间为对数时间 $O(log_2n)$ ，即查找到需要的目标位置最多只需要 $log_2n$ 步，假设从[0,99]的队列(100个数，即n=100)中寻到目标数30，则需要查找步数为 $log_2100$ ,即最多需要查找7次(2^6<100<27)

public class BinarySearchNoRecur {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    0,1,3,5,7,9};
        int i = binarySearch(arr, -2);
        System.out.println(i);
    }

    public static int binarySearch(int[] arr, int target) {
    
    
        int min = 0;
        int max = arr.length - 1;
        int mid ;

        while (min <= max) {
    
    
            mid = (min + max) / 2;
            if (arr[mid] == target) {
    
    
                return mid;
            } else if (arr[mid] > target) {
    
    
                max = mid - 1;
            } else {
    
    
                min = mid + 1;
            }
        }
        return -1;
    }
}

二、分治算法

1. 介绍

分治法是一种很重要的算法。字面上的解释是"分而治之"，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题….….直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。

这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)…
分治算法可以求解的一些经典问题
- 二分搜索
- 大整数乘法
- 棋盘覆盖
- 合并排序
- 快速排序
- 线性时间选择
- 最接近点对问题
- 循环赛日程表
- 汉诺塔

2. 基本步骤

分解

将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题
解决

若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题
合并

将各个子问题的解合并为原问题的解。

3. 设计模式

分治(Divide-and-Conquer§)算法设计模式如下:

if |p| <= n0
  then return (ADHOC(P))
// 将p分解为较小的子问题 p1,p2,...,pk
for i <- 1 to k
do yi <- Divide-and-Conquer(Pi) 递归解决Pi
T <- MERGE(y1,y2,...,yk) 合并子问题
return (T);

其中|P|表示问题P的规模;n0为一阈值，表示当问题P的规模不超过n0时，问题已容易直接解出，不必再继续分解。

ADHOC§是该分治法中的基本子算法，用于直接解小规模的问题P。

因此，当P的规模不超过n0时直接用算法ADHOC§求解。

算法MERGE(y1,y2…yk)是该分治法中的合并子算法，用于将P的子问题P1,P2 .Pk的相应的解y1,y2,…,yk合并为P的解。

4. 汉诺塔问题

汉诺塔的传说

汉诺塔：汉诺塔(又称河内塔)问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。

大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

假如每秒钟一次，共需多长时间呢?移完这些金片需要5845.54亿年以上，太阳系的预期寿命据说也就是数百亿年。真的过了5845.54亿年，地球上的一切生命，连同梵塔、庙宇等，都早已经灰飞烟灭。

步骤

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

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("第1个盘 " + a + " -> " + c);
        } else {
    
    
            // n >= 2 ，可以总是看做有两个盘,最下面一个和上面所有的
            // 1. 把上面的所有盘 A -> B, 过程中使用C
            hanoitower(num - 1, a, c, b);
            // 2. 最下面的盘 A -> C
            System.out.println("第" + num + "个盘从" + a + " -> " + c);
            // 3. 把B的所有盘 B -> C ,移动中国使用到A
            hanoitower(num - 1, b, a, c);
        }
    }
}

三、动态规划

1. 介绍

动态规划(Dynamic Programming)算法的核心思想是：

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

2. 背包问题

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

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

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

3. 思路

背包问题主要是指一个给定容量的背包、若千具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最大。其中又分01背包和完全背包(完全背包指的是:每种物品都有无限件可用)
这里的问题属于01背包，即每个物品最多放一个。而无限背包可以转化为01背包。

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

v[i][0]=v[0][i]=0; // 表示填入表第一行和第一列是0
当w[i]>j时:：v[i][j]=v[i-1][j] // 当新增商品的容量大于当前背包容量，就直接使用上一个单元格的结果
当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]：表示当前商品的价值

4. 背包问题解决

物品	1磅	2磅	3磅	4磅
	0	0	0	0
吉他	1500	1500	1500	1500
音响	1500	1500	1500	3000
电脑	1500	1500	2000	3500

假如现在只有吉他，这时不管背包容量有多大，只能放一个吉他
假如有吉他和音响，

验证公式：

v[1][1] = 1500
1. i = 1,j = 1
2. w[i] =w[1] = 1
  
  v[i][j] = max{v[i-1][j], v[i]+v[i-1][j-w[i]]} = v[1][1] = max {0 ,1500 + 0} = 1500 ]
v[3][4]
1. i = 3 ,j = 4
2. w[3] = 3
3. v[3][4] = max{3000 ,2000+1500} = 3500

5. 代码

package B_常用算法.B03_动态规划;

public class Page1 {
    
    

    public static void main(String[] args) {
    
    
        int[] w = {
    
    1, 4, 3}; //物品重量
        int[] val = {
    
    1500, 3000, 2000}; // 物品的价值
        int m = 4;// 背包容量
        int n = val.length; // 物品的个数

        // 创建二维数组
        // v[i][j] =容量范围内最大价值
        int[][] v = new int[n + 1][m + 1];

        // 记录商品情况
        int[][] path = new int[n + 1][m + 1];

        // 初始化第一行和第一列
        for (int i = 0; i < v.length; i++) {
    
    
            v[i][0] = 0;
        }
        for (int i = 0; i < v[0].length; i++) {
    
    
            v[0][i] = 0;
        }

        // 动态规划处理

        for (int i = 1; i < v.length; i++) {
    
    
            for (int j = 1; j < v[0].length; j++) {
    
    
                // 套用公式
                if (w[i - 1] > j) {
    
     //
                    v[i][j] = v[i - 1][j];
                } else {
    
    
                    // yi因为我们的i从1开始的,所以公式需要进行调整
//                    v[i][j] = Math.max(v[i - 1][j], val[i-1] + v[i - 1][j - w[i - 1]]);

                    // 为了记录商品存放到背包的情况,我们不能简单的使用公式
                    if (v[i - 1][j] > val[i - 1] + v[i - 1][j - w[i - 1]]) {
    
    
                        v[i][j] = v[i - 1][j];
                    } else {
    
    
                        v[i][j] = val[i - 1] + v[i - 1][j - w[i - 1]];
                        path[i][j] = 1;
                    }

                }
            }
        }

        // 输出
        for (int i = 0; i < v.length; i++) {
    
    
            for (int j = 0; j < v[i].length; j++) {
    
    
                System.out.println(v[i][j] + " ");
            }
            System.out.println();
        }

        int i = path.length - 1;
        int j = path[0].length - 1;
        System.out.println(path[i][j]);
        while (i > 0 && j > 0) {
    
     // 从后往前遍历
            if (path[i][j] == 1) {
    
    
                System.out.printf("第%d个商品放入到背包\n", i);
                j = w[i - 1];
                i--;
            }
        }

    }


}

四、ＫＭＰ算法

1. 应用场景

字符串匹配问题：

有一个字符串str1=““硅硅谷尚硅谷你尚硅尚硅谷你尚硅谷你尚硅你好””，和一个子串str2=“尚硅谷你尚硅你”
现在要判断str1是否含有str2,如果存在，就返回第一次出现的位置,如果没有，则返回-1

2. 暴力匹配算法

如果用暴力匹配的思路，并假设现在str1选配包i位置，子串str2少配到j位置，则有:

如果当前字符匹配成功（即str1[i] == str2[ij])，则it+，j++，继续匹配下一个字符
如果失配（即str1[i]! = str2[j])，令i= i-(j-1)，j=0。相当于每次匹配失败时，i回溯，j被置为0。
用暴力方法解决的话就会有大量的回溯，每次只移动一位，若是不匹配，移动到下一位接着判断，浪费了大量的时间。(不可行!)
暴力匹配算法实现.

public class 暴力匹配 {
    
    
    public static void main(String[] args) {
    
    
        String str1 = "硅硅谷尚硅谷你尚硅尚硅谷你尚硅谷你尚硅你好";
        String str2 = "尚硅谷你尚硅你";
        System.out.println(violenceMatch(str1, str2));
        System.out.println(str1.indexOf(str2));
    }

    public static int violenceMatch(String str1, String str2) {
    
    
        char[] s1 = str1.toCharArray();
        char[] s2 = str2.toCharArray();

        int s1Len = s1.length;
        int s2Len = s2.length;

        int i = 0; // i 索引指向s1
        int j = 0; // j 索引指向s2
        while (i < s1Len && j < s2Len) {
    
    
            if (s1[i] == s2[j]) {
    
     // 匹配成功
                i++;
                j++;
            } else {
    
    

                i = i - (j - 1);
                j = 0;
            }
        }

        // 判断是否匹配成功
        if (j == s2Len) {
    
    
            return i - j;
        } else {
    
    
            return -1;
        }
    }
}

3. KMP算法

直接看这个博客就好，这里不想写了，

博客KMP算法
更推荐看这个知乎
KMP算法详解

1）简介

KMP 是一个解决模式串在文本串是否出现过，如果出现过，最早出现的位置的经典算法
Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP 算法”，常用于在一个文本串 S 内查找一个模式串 P 的出现位置，这个算法由 Donald Knuth、Vaughan Pratt、James H. Morris 三人于 1977 年联合发表，故取这 3 人的姓氏命名此算法.
KMP 方法算法就利用之前判断过信息，通过一个 next 数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过 next 数组找到，前面匹配过的位置，省去了大量的计算时间
参考资料：https://www.cnblogs.com/ZuoAndFutureGirl/p/9028287.html

2）应用

字符串匹配问题：：

有一个字符串 str1= “BBCABCDAB ABCDABCDABDE”，和一个子串 str2=“ABCDABD”
现在要判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1
要求：使用 KMP 算法完成判断，不能使用简单的暴力匹配算法.

3）代码

package B_常用算法.B04_KMP;
/*
    Date:2022/5/20
    author: Blue Friday
    describe: //todo
*/

public class KMP_test {
    
    
    public static void main(String[] args) {
    
    
        String str1 = "BBC ABCDAB ABCDABCDABDE";
        String str2 = "ABCDABD";
        System.out.println(kmpSearch(str1, str2, kmpNext(str2)));
        System.out.println(str1.indexOf(str2));

        KMP kmp = new KMP(str2);
        System.out.println(kmp.search(str1));


    }

    // 获取字符串部分匹配值
    public static int[] kmpNext(String dest) {
    
    
        // 创建next数组保存部分匹配值
        int[] next = new int[dest.length()];
        next[0] = 0; // 如果字符串长度为1,这部分匹配值永远是0;
        for (int i = 1, j = 0; i < dest.length(); i++) {
    
    

            // 从next[j-1]获取新的j
            // 直到 发现上面条件满足时退出
            while (j > 0 && dest.charAt(i) != dest.charAt(j)) {
    
    
                j = next[j - 1];
            }
            if (dest.charAt(i) == dest.charAt(j)) {
    
     // 满足时,部分匹配值就是 +1;
                j++;
            }
            next[i] = j;
        }
        return next;
    }

    // kmp 搜索算法
    public static int kmpSearch(String str1, String str2, int[] next) {
    
    
        // 遍历 str1
        for (int i = 0, j = 0; i < str1.length(); i++) {
    
    
            // kmp算法核心 调整 j 的大小
            while (j > 0 && str1.charAt(i) != str2.charAt(j)) {
    
    
                j = next[j - 1];
            }

            if (str1.charAt(i) == str2.charAt(j)) {
    
    
                j++;
            }
            if (j == str2.length()) {
    
    
                return i - j + 1;
            }
        }
        return -1;

    }
}

4）知乎版本

public class KMP {
    
    
    private int[][] dp;
    private String pat;

    public KMP(String pat) {
    
    
        this.pat = pat;
        int M = pat.length();
        // dp[状态][字符] = 下一个状态
        dp = new int[M][256];
        dp[0][pat.charAt(0)] = 1;
        // 影子状态 x 初始为 0
        int x = 0;
        // 当前状态 j 从 1开始
        for (int j = 1; j < M; j++) {
    
    
            for (int c = 0; c < 256; c++) {
    
    
                if (pat.charAt(j) == c) {
    
    
                    dp[j][c] = j + 1;
                } else {
    
    
                    dp[j][c] = dp[x][c];
                }
            }
            // 更新影子状态
            x = dp[x][pat.charAt(j)];
        }
        System.out.println(Arrays.deepToString(dp));


    }

    public int search(String txt) {
    
    
        int M = pat.length();
        int N = txt.length();
        // pat 的初始状态为 0
        int j = 0;
        for (int i = 0; i < N; i++) {
    
    
            // 当前状态 j ，遇到 txt[i]，变化状态
            j = dp[j][txt.charAt(i)];
            // 达到终止状态,返回开头匹配的索引
            if (j == M) return i - M + 1;
        }
        return -1;
    }
}

算法与数据结构-常用算法

文章目录

一、二分查找算法（非递归）

二、分治算法

1. 介绍

2. 基本步骤

3. 设计模式

4. 汉诺塔问题

三、动态规划

1. 介绍

2. 背包问题

3. 思路

4. 背包问题解决

5. 代码

四、ＫＭＰ算法

1. 应用场景

2. 暴力匹配算法

3. KMP算法

1）简介

2）应用

3）代码

4）知乎版本

猜你喜欢

算法与数据结构-常用算法

文章目录

一、二分查找算法（非递归）

二、分治算法

1. 介绍

2. 基本步骤

3. 设计模式

4. 汉诺塔问题

三、动态规划

1. 介绍

2. 背包问题

3. 思路

4. 背包问题解决

5. 代码

四、ＫＭＰ算法

1. 应用场景

2. 暴力匹配算法

3. KMP算法

1） 简介

2）应用

3）代码

4）知乎版本

猜你喜欢

1）简介