查找算法的逐步深入

一、线性查找

• 思想：从头到尾依次查找

线性查找又称顺序查找，是一种最简单的查找方法，它的基本思想是从第一个记录开始，逐个比较记录的关键字，直到和给定的K值相等，则查找成功；若比较结果与文件中n个记录的关键字都不等，则查找失败

• 代码

	private static int seqSearch01(int[] arrs, int i) {
		// 线性查找是逐一比较，发现发现相同值就放回下标
		for (int j = 0; j < arrs.length; j++) {
			if(arrs[j] == i) {
				return j;
			}
		}
		return -1;
	}

二、二分查找

• 思想： 二分查找也称折半查找，它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

• 代码

		private static int seqSearch02(int[] arrs, int i) {
		if(arrs[0]>i||arrs[arrs.length-1]<i) {
			return -1;
		}
		int start = 0;
		int end = arrs.length-1;
		int mid = (start+end)/2;
		while(start <= end) {
			if(arrs[mid] == i) {
				return mid;
			} else if (arrs[mid]<i) {
				start = mid+1;
			} else if (arrs[mid]>i) {
				end = mid-1;
			}
			mid = (start+end)/2;
		}
		return -1;
	}

三、插值查找

• 思想： 插值查找，有序表的一种查找方式。插值查找是根据查找关键字与查找表中最大最小记录关键字比较后的查找方法。插值查找基于二分查找，将查找点的选择改进为自适应选择，提高查找效率。

• 代码

	private static int seqSearch03(int[] arrs, int i) {
		if(arrs[0]>i||arrs[arrs.length-1]<i) {
			return -1;
		}
		int start = 0;
		int end = arrs.length-1;
		int mid = start + (end-start)*(i-arrs[start])/(arrs[end]-arrs[start]);
		while(start <= end) {
			if(arrs[mid] == i) {
				return mid;
			} else if (arrs[mid]<i) {
				start = mid+1;
			} else if (arrs[mid]>i) {
				end = mid-1;
			}
			mid = start + (end-start)*(i-arrs[start])/(arrs[end]-arrs[start]);
		}
		return -1;
	}

四、斐波那契查找（黄金分割法）了解原理

• 思想：根据斐波那契数列来实现查找黄金分割点mid即mid=low+F(k-1)-1（F代表斐波那契数列）

• • 斐波那契数列的性质为F[k]=F[k-1]+F[k-2],可以得到F[k]-1=（F[k-1]-1）+（F[k-2]-1）说明只要顺序表的长度为F[k-1]-1,则可以将该表分成长度为F[k-1]-1和F[k-2]-1的两端，即如上图所示，mid=low+F(k-1)-1

  • 每一字段也可以用相同的方式分割

  • 但是顺序表长度不一定刚好等于F[k-1]-1，所以需要将原来的顺序表长度增加至F[k-1]-1。这里的k值只能使得F[k-1]-1恰好大于或等于n即可，由下面代码得到，顺序表长度增加后，新增的位置（从n+1到F[k-1]-1的位置）都赋为n位置的值

  • while(n>F(k)-1) k++;
    

• 代码

	private static int seqSearch04(int[] arrs, int key) {
		int low = 0;
		int hight = arrs.length-1;
		// 表示斐波那契数值的下标
		int k = 0;
		int mid = 0;
		// 获取斐波那契数列
		int F[] = fib();
		// 获取到斐波那契分割数值的下标
		while(hight>F[k]-1) k++;
		// 因为F[k]值可能大于a的长度，需要构造一个新的数值
		int[] temp = Arrays.copyOf(arrs, F[k]);
		for (int j = hight+1; j < temp.length; j++) {
			temp[j] = arrs[hight];
		}
		
		// 使用while来循环处理，找到我们的数key
		while(low<=hight) {
			mid = low + F[k-1]-1;
			// 如果小于key值我们就应该向数值的前面查找
			if(key<temp[mid]) {
				hight = mid -1;
				// 说明 全部元素 = 前面的元素 + 后边的元素
				// F[k] = F[k-1] + F[k-2]
				// 因为前面由F[k-1]个元素可以继续拆分为：F[k-1] = F[k-2] + F[k-3]
				// 即再F[k-1]的前面继续查找
				// 下次循环为 mid = F[k-1-1] -1
				k--;
			
			}
			else if (key>temp[mid]) {
				
				low = mid + 1;
				// 全部元素 = 前面的元素 + 后边的元素
				// F[k] = F[k-1] + F[k-2]
				// 因为前面由F[k-2]个元素可以继续拆分为：F[k-2] = F[k-3] + F[k-4]
				// 即再F[k-2]的前面继续查找
				// 下次循环为 mid = F[k-1-2] -1
				k-=2;
			} else {
				// 需要确定返回的是哪个下标
				if(mid <= hight) {
					return mid;
				}else {
					return hight;
				}
			}
		}
		
		
		return -1;
	}