java数据结构与算法（十一）——10种常用算法

一、非递归二分查找

package Algorithm;

public class BinarySearchNoRecursion {
   

	public static void main(String[] args) {
   
		int[] arr = {
    1, 3, 8, 10, 11, 67, 100 }; //升序排列
		
		int res = BinarySearch(arr, 11);
		System.out.println(res);
	}
	
	//二分查找的非递归实现
	/**
	 * 
	 * @param arr 待查找的数组
	 * @param target 待查找的值
	 * @return 返回对应的下标，没找到返回-1
	 */

	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;
			
	}
	

}

二、分治算法
汉诺塔问题

package Algorithm;

public class dacHanoitower {
   

	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);
		}
		
		if (num >= 2) {
   
			//如果有两个以上的盘，我们总是可以看做两个盘，最下面的盘1，上面的盘看做一个整体，作为盘2
			//先把上面的所有盘2从a->b,移动过程中会使用到c
			Hanoitower(num - 1, a, c, b);
			//把最下面的盘1从a->c
			System.out.println("第" + num + "个盘从 " + a + "->" + c);
			//把b塔的所有盘从b->c，移动过程中使用到a塔
			Hanoitower(num - 1, b, a, c);
		}
		
		
		
	}
	
	
}

三、动态规划
背包问题

package Algorithm;

public class DynamicKnapsackProblem {
   

	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]，表示在前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; //将第一列置为0
		}
		for (int j = 0; j < v[0].length; j++) {
   
			v[0][j] = 0; //将第一行置为0
		}
		
		
		//动态规划处理
		for (int i = 1; i < v.length; i++) {
    //不处理第一行，i从1开始
			for (int j = 1; j < v[0].length; j++) {
    //不处理第一列，j从1开始
				
				//公式
				if (w[i - 1] > j) {
    //因为i是从1开始的，但是公式中是从0开始的，所以要w[i - 1]
					v[i][j] = v[i - 1][j];
				}else {
   
					//因为i是从1开始的，但是公式中是从0开始的，所以要val[i - 1],w[i - 1]
//					v[i][j] = Math.max(v[i - 1][j], val[i - 1] + v[i - 1][j - w[i - 1]]);
					//为了记录放入商品的情况，不能简单的使用max的公式，用if-else语句处理
					if (v[i - 1][j] < val[i - 1] + v[i - 1][j - w[i - 1]]) {
   
						v[i][j] = val[i - 1] + v[i - 1][j - w[i - 1]];
						path[i][j] = 1; //说明新加入的商品放到了该格中
					}else {
   
						v[i][j] = v[i - 1][j];
					}
				}
	
			}
		}
		
		

		//输出最大价值表
		for (int i = 0; i < v.length; i++) {
   
			for (int j = 0; j < v[i].length; j++) {
   
				System.out.print(v[i][j] + " ");
			}
			System.out.println();
		}
		
		
		//输出最后放入的最大价值的商品
		int i = path.length - 1; //行的最大下标
		int j = path[0].length - 1; //列的最大下标
		
		while (i > 0 && j > 0) {
    //从path数组的最后开始找
			if (path[i][j] == 1) {
   
				System.out.printf("第%d个商品放入背包\n",i);
				j = j - w[i - 1]; //放入i商品后背包容量要减少w[i - 1]
			}
			i--;
		}
	
		
	}

}

四、KMP算法
字符串匹配问题
暴力匹配算法实现

package Algorithm;

public class ViolenceMatch {
   

	public static void main(String[] args) {
   
		String str1 = "BBC ABCDAB ABCDABCDABDE";
		String str2 = "ABCDABD";
		System.out.println(violenceMatch(str1, 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) {
    //说明j走到子串最后，匹配成功
			return i - j;
		}else {
   
			return -1;
		}
	
	}

}

KMP算法实现

package Algorithm;

import java.util.Arrays;

public class KMPAlgorithm {
   

	public static void main(String[] args) {
   
		String str1 = "BBC ABCDAB ABCDABCDABDE";
		String str2 = "ABCDABD";
		int[] next = KMPNext(str2);
		System.out.println(Arrays.toString(next));
		int res = KMPSearch(str1, str2, next);
		System.out.println(res);
	}

	//KMP算法实现字符串匹配
	//1.先创建子串的部分匹配表
	//传进来子串，返回子串对应的部分匹配值
	public static int[] KMPNext(String dest) {
   
		//创建一个next数组保存部分匹配值
		int[] next = new int[dest.length()];
		//如果只有一个字符的字符串,其部分匹配值必为0
		next[0] = 0;
		
		
		for (int i = 1, j = 0; i < dest.length(); i++) {
   
			//如果dest.charAt(i) != dest.charAt(j)，就一直循环找到找到匹配的位置
			while (j > 0 && dest.charAt(i) != dest.charAt(j)) {
   
				j = next[j - 1];
			}
			//如果相等说明匹配成功j所指的就是最大的公共字符的长度-1，因为数组下标从0开始，所以要j++
			if (dest.charAt(i) == dest.charAt(j)) {
   
				j++;
			}
			next[i] = j;
		}
		return next;
	}
	
	
	//2.KMP搜索算法
	/**
	 * 
	 * @param str1 源字符串
	 * @param str2 子串
	 * @param next 子串对应的部分匹配表
	 * @return 第一次出现的位置
	 */
	public static int KMPSearch(String str1, String str2, int[] next) {
   

		//遍历str1
		for (int i = 0,j = 0; i < str1.length(); i++) {
   
			//KMP算法核心
			while (j >0 && str1.charAt(i) != str2.charAt(j)) {
   
				j = next[j - 1];
			}

			//如果发现字符相同j后移继续比较
			if (str1.charAt(i) == str2.charAt(j)) {
   
				j++;
			}
			
			if (j == str2.length()) {
   
				return i - j + 1;
			}
		}
		
		return -1;
		
		
	}