一. 顺序查找
- 顺序查找也叫线性查找
- 问题：有一个数列：{1，8，10，89，1000，1234}，判断数列中是否包含某个数据，要求：如果找到了就提示找到了，并返回下标。
- 代码：
public class OrderSearch {
public static void main(String[] args){
int[] arr = {1,8,10,89,1000,1234};
int res = orderSearch(arr, 0);
if(res != -1){
System.out.println("找到了，下标=" + res);
}else{
System.out.println("没找着");
}
}
private static int orderSearch(int[] arr, int val){
for(int i = 0; i < arr.length; i++){
if(arr[i] == val){
return i;
}
}
return -1;
}
}
- 如果一个数组中含有多个相同的值，要查找这个值
public class OrderSearch {
public static void main(String[] args){
int[] arr = {1,8,10,89,1000,1234,1000};
List<Integer> res = orderSearch(arr, 1000);
if(res.size() != 0){
System.out.println("找到了，下标=" + res);
}else{
System.out.println("没找着");
}
}
private static List<Integer> orderSearch(int[] arr, int val){
List<Integer> res = new ArrayList<>();
for(int i = 0; i < arr.length; i++){
if(arr[i] == val){
res.add(i);
}
}
return res;
}
}
二. 二分查找
- 二分查找的数组必须是有序数组
- 问题：请对一个有序数组进行二分查找{1，8，10，89，1234}，输入一个数，看数组中是否存在此数，并且求出下标，如果没有就提示“没有这个数”。
- 思路
- 首先确定该数组的中间下标 mid = (left + right) / 2;
- 然后用要查找的数与数组的中间的数进行比较
- findVal > arr[mid]，继续往数组的右边递归
- findVal < arr[mid]，继续往数组的左边递归
- findVal == arr[mid]，找到返回下标即可
- 我们用到了递归，就必须明确递归出口
- 找到下标就结束递归
- 当递归完整个数组没有找到该数，此时的递归出口是 left > right
- 代码：
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1,8,10,89,1000,1234};
int res = binarySearch(arr, 0, arr.length - 1, 1000);
if(res == -1){
System.out.println("没有找着~");
}else{
System.out.println("找到啦，res = " + res);
}
}
/**
* 二分查找
* @param arr 要查找的数组
* @param left 数组的左边界
* @param right 数组的右边界
* @param findVal // 要查找的值
* @return 如果找到返回下标，没有找到返回 -1 即可
*/
private static int binarySearch(int[] arr, int left, int right, int findVal){
if(left > right){ // 没有找到数据时的递归出口
return -1;
}
int midIndex = (left + right) / 2;
int mid = arr[midIndex];
if(findVal > mid){
return binarySearch(arr, midIndex + 1, right, findVal);
}else if(findVal < mid){
return binarySearch(arr, left, midIndex - 1,findVal);
}else{
return midIndex;
}
}
}
- 当一个数组中要查找的数有多个时
import java.util.ArrayList;
import java.util.List;
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1,8,10,89,1000,1000,1000,1234};
List<Integer> res = binarySearch2(arr, 0, arr.length - 1, 1000);
if(res.size() == 0){
System.out.println("没有找到");
}else{
System.out.println("找着啦，res = " + res);
}
}
private static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal){
if(left > right){
return new ArrayList<>();
}
int midIndex = (left + right) / 2;
int mid = arr[midIndex];
if(findVal > mid){
return binarySearch2(arr, midIndex + 1, right, findVal);
}else if(findVal < mid){
return binarySearch2(arr, left, midIndex - 1,findVal);
}else{
// 1. 在找到 mid 索引值时，不要立马返回，要对比索引值的左右两边的值
// 2. 向 mid 索引值 的左边扫描，将所有等于 要查找的值的下标，加入到 res 中
// 2. 向 mid 索引值 的右边扫描，将所有等于 要查找的值的下标，加入到 res 中
List<Integer> res = new ArrayList<>();
// 先向左边走了
int tmp = midIndex - 1;
while(tmp > 0 && arr[tmp] == mid){
res.add(tmp);
tmp--;
}
res.add(midIndex); // midIndex 的值
// 再向右边遍历
tmp = midIndex + 1;
while((tmp < arr.length - 1) && arr[tmp] == mid){
res.add(tmp);
tmp++;
}
return res;
}
}
}
三. 插值查找
- 数组数据分布较平均的情况下建议使用该方法，而且查找数组两边的数据是真的快
- 插值查找算法类似于二分查找，不同的是插值查找每次从自适应 mid处开始查找
- 将折半查找中的求mid索引的公式改一下就可以了，mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left])
- 对于数据量较大，关键字分布比较均匀的数据采用插值查找比较快
- 关键字分布不均匀的情况下，该方法不一定比折半查找要好。
- 代码：
public class InsertValueSearch {
public static void main(String[] args) {
int[] arr = new int[100];
for(int i = 0; i < 100; i++){
arr[i] = i + 1;
}
int res = insertValueSearch(arr, 0, arr.length - 1, 45);
System.out.println("res = " + res);
}
private static int insertValueSearch(int[] arr, int left, int right, int findVal){
System.out.println("姜姜~");
if(left > right){
return -1;
}
int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
int midVal = arr[mid];
if(findVal > midVal){
return insertValueSearch(arr, mid + 1, right, findVal);
} else if(findVal < midVal){
return insertValueSearch(arr, left,mid - 1,findVal);
}else{
return mid;
}
}
}
对于插值查找同样的数
四. 斐波那契（黄金分割）查找
- 还是二分查找算法对 mid 中间数取值的优化，在查找过程中没有用递归
- 思路：mid 不再是中间或者插值得到，而是位于黄健分割点附近，即 mid = low + F(k - 1) - 1，F代表斐波那契数列
- 对 F(k - 1) - 1 的理解：
- 由于斐波那契的性质可以得到 ( F[k - 1] - 1 ) + ( F[k - 2] - 1 ) + 1 = F[k] - 1，所以可以将表分为长度为 F[k - 1] 和 F[k - 2] 的两段。
- 类似在之后的每一段，也按照相同的方式分割
- 斐波那契数组的每个值相当于原始数组的长度
- 顺序表长度不一定刚好等于 F[k] - 1，所以需要将原来的数组长度增加至 F[k] - 1。这里的 k 的值只要能使（下标为k 的斐波那契数组中值 - 1 的大小） F[k] - 1 的值恰好大于或等于 n 即可（可以理解为假如我现在要在长度为 5 的数组中查找某个值，我在斐波那契数列中的下标，即k的值应该为6）。
- 若是不满足，可以新建立一个临时的数组，临时数组的长度为 斐波那契数组中下标为 k 的值，新增的位置（从 n + 1 到 F[k] - 1 位置），都赋为 n 位置的值即可。
- 代码：
import java.util.Arrays;
public class FibonacciSearch {
public static void main(String[] args) {
int[] arr = {1,8,10,89,1000,1234};
int res = fibSearch(arr,1234);
System.out.println("res = " + res);
}
private static int[] fib(){
int[] f = new int[20]; // 20 的值是自己随便给的，给的太小怕不够用
f[0] = 1;
f[1] = 1;
for(int i = 2; i < f.length; i++){
f[i] = f[i - 1] + f[i - 2];
}
return f;
}
private static int fibSearch(int[] arr, int key){
int low = 0;
int high = arr.length - 1;
int[] f = fib();
int k = 0; // 斐波那契数组的下标
int mid = 0;
// 根据arr 数组的长度，确定斐波那契数组 k 的值应该是多少（比如 arr 数组的长度是 10，斐波那契数组的长度（k）应该是7）
while(high > f[k] - 1){
k++;
}
// 要是 arr 数组的长度不够 斐波那契数组下标为 k 的值，因此我们需要构造一个新的数组
int[] tmp = Arrays.copyOf(arr, f[k]);
// 还要用原始数组的最后一个值，填充多出来部分
for(int i = arr.length; i < tmp.length; i++){
tmp[i] = arr[high];
}
// 用 while 循环，查找指定的值
while(low <= high){
mid = low + f[k - 1] - 1;
if(key < tmp[mid]){
high = mid - 1;
k--;
} else if(key > tmp[mid]){
low = mid + 1;
k -= 2;
}else{
if(mid <= high){
return mid;
}else{
return high;
}
}
}
return -1;
}
}
