常见算法-查找算法
查找算法：
基本查找、二分查找、分块查找、插值查找、斐波那契查找、树表查找、哈希查找
1.基本查找
public class BasicSearchDemo1 {
public static void main(String[] args) {
//基本查找/顺序查找
//核心：从0索引开始挨个往后查找
//需求：定义方法利用基本查找查询某个元素是否存在
//数据如下：{23,45,64,29,125,54,98,76,89}
int[] arr = {23,45,64,29,125,54,98,76,89};
int number = 64;
boolean flag = basicSearch(arr, number);
System.out.println(flag);
}
public static boolean basicSearch(int[] arr,int number){
for (int i = 0; i < arr.length; i++) {
if(arr[i] == number){
return true;
}
}
return false;
}
}import java.util.ArrayList;
public class BasicSearchDemo2 {
public static void main(String[] args) {
//定义方法利用基本查找查询某个元素在数组中的索引
//数据如下：{23,45,64,29,125,54,98,76,89,29}
//要考虑元素的重复性
int[] arr = {23,45,64,29,125,54,98,76,89,29};
int number = 29;
ArrayList list = basicSearch(arr, number);
if(list.size() == 0){
System.out.println("数组中没有该元素");
}else{
for (int i = 0; i < list.size(); i++) {
int num = list.get(i);
System.out.println(num);
}
}
}
//心得：如果我们要返回多个数据，可以把这些数据放到数组或者集合中
public static ArrayList basicSearch(int[] arr,int number){
ArrayList list = new ArrayList<>();
for (int i = 0; i < arr.length; i++) {
if(arr[i] == number){
list.add(i);
}
}
return list;
}
}
2.二分查找/折半查找
前提条件：元素必须是有序的，从小到大，或者从大到小都可以
核心逻辑：每次排除一半的查找范围
基本思想：
- 定义min和max表示当前要查找的范围
- mid表示min和max中间的
- 如果要查找的元素在mid的左边，缩小范围时，min不变，max等于mid减1
- 如果要查找的元素在mid的右边，缩小范围时，max不变，min等于mid加1
二分查找也称折半查找，属于有序查找算法。用给定值先与中间结点mid比较。比较完之后有三种情况：
*相等：说明找到了
*要查找的数据比中间节点小：说明要查找的数字在中间节点左边
*要查找的数据比中间节点大：说明要查找的数字在中间节点右边
public class BinarySearchDemo1 {
public static void main(String[] args) {
//二分查找
//核心：每次排除一半范围
//需求：定义一个方法利用二分查找，查询某个元素在数组中的索引
//数据如下：{7,23,78,89,112,131,145,156}
int[] arr = {7,23,78,89,112,131,145,156};
int number = 145;
int i = binarySearch(arr, number);
System.out.println(i);
}
public static int binarySearch(int[] arr,int number){
//定义变量记录要查找的范围
int max = arr.length - 1;
int min = 0;
int mid = 0;
//利用循环不断去查找要找的数据
while(true){
//数据不存在
if(min > max){
return -1;
}
//确定中间位置
mid = (min + max) / 2;
//中间值就是要找的元素
if(arr[mid] == number){
return mid;
}
//要找的元素在中间值右边
if(arr[mid] < number){
min = mid + 1;
}
//要找的元素在中间值左边
if(arr[mid] > number){
max = mid - 1;
}
}
}
}3.插值查找
插值查找是在二分查找的基础上，让中间的mid点，尽可能靠近想要查找的元素，从而更高的提高查找效率
基本思想：基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，插值查找也属于有序查找。
前提条件：对于数据较多，并且数据分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。简单理解就是插值查找算法不光要满足二分查找有序的前提条件，还要数据均匀分布，即数据的间隔大小必须相等。
理解：
二分查找中间点计算如下：
我们可以将查找的点改进为如下：
key：表示要查找的元素
![mid=min+(key-a[min])/(a[max]-a[min])*(max-min)](http://img.e-com-net.com/image/info8/1732528c7ead4308ad9fafbe724aa259.png){kind=small}
public class InterpolationSearchDemo1 {
public static void main(String[] args) {
//插值查找
//核心：基于二分查找的基础上数据均匀分布
//需求：定义一个方法利用插值查找，查询某个元素在数组中的索引
//数据如下：{1,2,3,4,5,6,7,8,9,10}
int[] arr = {1,2,3,4,5,6,7,8,9,10};
int[] arr2 = {2,4,6,8,10,12,14,16,18,20};
int number = 8;
int i = interpolationSearch(arr2, number);
System.out.println(i);
}
public static int interpolationSearch(int[] arr,int number){
int max = arr.length - 1;
int min = 0;
//mid = min + (number - arr[min])/(arr[max] - arr[min])*(max - min)
int x = (number - arr[min]) * (max - min);
int y = arr[max] - arr[min];
int mid = min + x / y;
if(arr[mid] == number){
return mid;
}else{
return -1;
}
}
}4.斐波那契查找
斐波那契查找也是在二分查找的基础上进行了优化，利用黄金分割点优化中间点mid的计算方式
基本思想：也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法。
黄金分割点：1:0.618
斐波那契数列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89…….（从第三个数开始，后边每一个数都是前两个数的和）
我们会发现，随着斐波那契数列的递增，前后两个数的比值会越来越接近0.618，利用这个特性，我们就可以将黄金比例运用到查找技术中。
import java.util.Arrays;
public class FeiBoSearchDemo1 {
//定义静态变量表示数组长度
public static int maxSize = 20;
public static void main(String[] args) {
int[] arr = {1, 8, 10, 89, 1000, 1234};
System.out.println(search(arr, 1234));
}
//获取斐波那契数列
public static int[] getFeiBo() {
int[] arr = new int[maxSize];
arr[0] = 1;
arr[1] = 1;
for (int i = 2; i < maxSize; i++) {
arr[i] = arr[i - 1] + arr[i - 2];
}
return arr;
}
public static int search(int[] arr, int key) {
int min = 0;
int max = arr.length - 1;
//表示斐波那契数分割数的下标值
int index = 0;
int mid = 0;
//调用斐波那契数列
int[] f = getFeiBo();
//获取斐波那契分割数值的下标
while (max > (f[index] - 1)) {
index++;
}
//因为f[k]值可能大于a的长度，因此需要使用Arrays工具类，构造一个新法数组，并指向temp[],不足的部分会使用0补齐
int[] temp = Arrays.copyOf(arr, f[index]);
//实际需要使用arr数组的最后一个数来填充不足的部分
for (int i = max + 1; i < temp.length; i++) {
temp[i] = arr[max];
}
//使用while循环处理，找到key值
while (min <= max) {
mid = min + f[index - 1] - 1;
if (key < temp[mid]) {//向数组的前面部分进行查找
max = mid - 1;
/*
对k--进行理解
1.全部元素=前面的元素+后面的元素
2.f[k]=k[k-1]+f[k-2]
因为前面有k-1个元素没所以可以继续分为f[k-1]=f[k-2]+f[k-3]
即在f[k-1]的前面继续查找k--
即下次循环,mid=f[k-1-1]-1
*/
index--;
} else if (key > temp[mid]) {//向数组的后面的部分进行查找
min = mid + 1;
index -= 2;
} else {//找到了
//需要确定返回的是哪个下标
if (mid <= max) {
return mid;
} else {
return max;
}
}
}
return -1;
}
}二分查找、插值查找、斐波那契查找总结：
相同点：都是通过不断缩小范围来查找数据的
不同点：计算mid的方式不一样
| mid计算方式 | |
| 二分查找 | mid每次都是指向范围的中间位置 |
| 插值查找 | mid尽可能靠近要查找的数据，但是数据要均匀分布 |
| 斐波那契查找 | 根据黄金分割点来计算mid指向位置 |
5.分块查找
分块查找适用于数据较多，但是数据不会发生变化的情况，如果需要一边添加一边查找，建议使用哈希查找
核心思想：块内无序，块间有序
分块原则：
*前一块中的最大数据，小于后一块中的所有数据(块内无序，块间有序)
*分块数量一般等于数字的个数开根号。比如：16个数字一般分为4块左右
核心思路：先确定要查找的元素在哪一块，然后在块内挨个查找
class Block{//块
int max;//块中最大值
int startIndex;//起始索引
int endIndex;//结束索引
}- 分块查找的过程：
- *需要把数据分成N多小块，块与块之间不能有数据重复的交集。
- *给每一块创建对象单独存储到数组当中
- *查找数据的时候，先在数组查，确定当前数据属于哪一块
- *再到这一块中顺序查找
//定义Block类来表示分块的具体信息
public class Block {
private int max;//最大值
private int startIndex;//起始索引
private int endIndex;//结束索引
public Block() {
}
public Block(int max, int startIndex, int endIndex) {
this.max = max;
this.startIndex = startIndex;
this.endIndex = endIndex;
}
/**
* 获取
* @return max
*/
public int getMax() {
return max;
}
/**
* 设置
* @param max
*/
public void setMax(int max) {
this.max = max;
}
/**
* 获取
* @return startIndex
*/
public int getStartIndex() {
return startIndex;
}
/**
* 设置
* @param startIndex
*/
public void setStartIndex(int startIndex) {
this.startIndex = startIndex;
}
/**
* 获取
* @return endIndex
*/
public int getEndIndex() {
return endIndex;
}
/**
* 设置
* @param endIndex
*/
public void setEndIndex(int endIndex) {
this.endIndex = endIndex;
}
public String toString() {
return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
}
}public class BlockSearchDemo {
public static void main(String[] args) {
/*
分块查找
核心思想：
块内无序，块间有序(前一块中最大元素比后一块中最小元素还小)
实现步骤：
1.创建数组blockArr存放每一个块对象的信息
2.先查找blockArr确定要查找的数据属于哪一块
3.再单独遍历这一块数据即可
*/
int[] arr = {16, 5, 9, 12,21, 18,
32, 23, 37, 26, 45, 34,
50, 48, 61, 52, 73, 66};
//创建三个块的对象
Block b1 = new Block(21,0,5);
Block b2 = new Block(45,6,11);
Block b3 = new Block(73,12,17);
//定义数组用来管理三个块的对象（索引表）
Block[] blockArr = {b1,b2,b3};
//定义一个变量用来记录要查找的元素
int number = 37;
//调用方法，传递索引表，数组，要查找的元素
int index = getIndex(blockArr,arr,number);
//打印一下
System.out.println(index);
}
//利用分块查找的原理，查询number的索引
private static int getIndex(Block[] blockArr, int[] arr, int number) {
//1.确定number是在那一块当中
int indexBlock = findIndexBlock(blockArr, number);
if(indexBlock == -1){
//表示number不在数组当中
return -1;
}
//2.获取这一块的起始索引和结束索引 --- 30
// Block b1 = new Block(21,0,5); ---- 0
// Block b2 = new Block(45,6,11); ---- 1
// Block b3 = new Block(73,12,17); ---- 2
int startIndex = blockArr[indexBlock].getStartIndex();
int endIndex = blockArr[indexBlock].getEndIndex();
//3.遍历
for (int i = startIndex; i <= endIndex; i++) {
if(arr[i] == number){
return i;
}
}
return -1;
}
//定义一个方法，用来确定number在哪一块当中
public static int findIndexBlock(Block[] blockArr, int number){ //100
//从0索引开始遍历blockArr，如果number小于max，那么就表示number是在这一块当中的
for (int i = 0; i < blockArr.length; i++) {
if(number <= blockArr[i].getMax()){
return i;
}
}
return -1;
}
}分块查找扩展(无规律的数据)
前提：块与块之间的数据不能有交集
class Block{
int min;
int max;
int startIndex;
int endIndex;
}6.哈希查找
哈希查找是分块查找的优化，适用于数据一边添加一边查找的情况。
一般是数组 + 链表的结合体或者是数组+链表+红黑树的结合体
数组的0索引处存储1~100
数组的1索引处存储101~200
数组的2索引处存储201~300
以此类推
以0索引处为例，第一个数20会存储到数组0索引处，第二个数40会以链表的形式挂在0索引后面进行存储
当数据进行添加或查找操作的时候，首先会判断数据在哪一块区域，然后再进行添加或查找操作，从而提高效率
在实际中，我们一般不会采取这种均匀划分的方式，因为这种方式容易导致一块区域添加的元素过多，导致效率偏低。
实际中更多的是先计算出当前数据的哈希值，用哈希值跟数组的长度进行计算，计算出应存入的位置，再挂在数组的后面形成链表，如果挂的元素太多而且数组长度过长时，我们也会把链表转化为红黑树，进一步提高效率。
7.树表查找
本知识点涉及到数据结构：树。
基本思想：二叉查找树先对待查找的数据进行生成树，确保树的左分支的值小于右分支的值，然后将要查找的数据和每个节点的父节点依次比较大小，如果大于父节点上的数据，继续与父节点右子树比较大小，如果小于父节点上的数据，则继续与父节点左子树比较大小，直到查找结束为止。 这个算法的查找效率很高，但是如果使用这种查找方法要首先创建树。
二叉查找树也叫二叉搜索树，或称二叉排序树，具有下列性质：
*任意节点左子树上所有的数据，均小于该节点本身；
*任意节点右子树上所有的数据，均大于该节点本身；
二叉查找树性质：对二叉查找树进行中序遍历，即可得到有序的数列。
基于二叉查找树进行优化，进而可以得到其他的树表查找算法，如平衡树、红黑树等高效算法。
不管是二叉查找树，还是平衡二叉树，还是红黑树，查找的性能都比较高