一，查找算法
1，简介：
查找算法：常分为四种；
- 顺序查找（线性查找）；
- 二分查找/折半查找；
- 插值查找；
- 斐波那契查找；
2，顺序查找：
按照原来顺序查找值，找到即返回下标，找不到返回-1，即不存在；
public static int search(int[] arr, int val) {
for (int i = 0; i < arr.length; i++) {
if (val == arr[i]) {
return i;
}
}
return -1;
}
3，二分查找：
分析：
- 顾名思义先确定中间值的下标mid=(left+right)/2；
- 让需要查找的val与arr[mid]比较；
- val<arr[mid]则向左递归查找，反之右递归查找；
- 查找过程中，等于时直接退出，或当left>right时如果找不到就退出递归，说明不存在；
- 过程中每次都有left、right两个指针在递归段的两端向mid逼近；
package com.search;
import java.util.ArrayList;
/**
* @param
* @Author: AaNeei
* @Date: 2019/6/17 22:26
* @Description: 游学网
* @throws:
*/
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1, 5, 8, 9, 10, 10, 10, 10, 11, 15, 20};
int val = 10;
int search = search(arr, 0, arr.length - 1, val);
ArrayList<Integer> arrayList = searchAll(arr, 0, arr.length - 1, val);
System.out.println("查找的值" + val + "下标为" + search);
System.out.println("查找的值" + val + "下标为" + arrayList);
}
/**
* @param arr 查找的原数组
* @param left 左指针
* @param right 右指针
* @param val 要找的值
* @return 找不到就返回-1
*/
public static ArrayList<Integer> searchAll(int[] arr, int left, int right, int val) {
int mid = (left + right) / 2;
int midVal = arr[mid];
if (left > right || val < arr[left] || val > arr[right]) {
return new ArrayList<>();
}
if (val < midVal) {
//向左递归,right移至递归段的最右端即mid-1
return searchAll(arr, left, mid - 1, val);
} else if (val > midVal) {
//向右递归,left移至递归段的最右端即mid+1
return searchAll(arr, mid + 1, right, val);
} else {
ArrayList<Integer> arrayList = new ArrayList<>(arr.length);
arrayList.add(mid);
int temp = mid - 1;
//向左扫描是否有相同值，并记录
while (true) {
if (temp < 0 || arr[temp] != val) {
break;
}
arrayList.add(temp--);
}
temp = mid + 1;
//向右扫描是否有相同值，并记录
while (true) {
if (temp > arr.length - 1 || arr[temp] != val) {
break;
}
arrayList.add(temp++);
}
return arrayList;
}
}
public static int search(int[] arr, int left, int right, int val) {
int mid = (left + right) / 2;
int midVal = arr[mid];
//因为是有序的，所以不在最小值最大值范围的直接不存在
if (left > right || val < arr[left] || val > arr[right]) {
return -1;
}
if (val < midVal) {
//向左递归,right移至递归段的最右端即mid-1
return search(arr, left, mid - 1, val);
} else if (val > midVal) {
//向右递归,left移至递归段的最右端即mid+1
return search(arr, mid + 1, right, val);
} else {
return mid;
}
}
}
注： 二分查找必须是有顺序的数组，如果没有顺序需要先排序；
发现问题： 对于有序排列的数组，查找首尾利用二分会较慢，怎么解决？自适应算法（插值查找）；
4，插值查找：
分析：
- 类似于二分查找，不同的是插值查找每次从自适应mid处开始查找；
- 将二分查找中的mid公式调整为：int mid=left+(right-left)*(val-arr[left])/(arr[right]-arr[left]);
package com.search;
import java.util.ArrayList;
/**
* @param
* @Author: AaNeei
* @Date: 2019/6/18 21:35
* @Description: 游学网
* @throws:
*/
public class InterpolationSearch {
public static void main(String[] args) {
int num = 100;
int[] arr = init(num);
ArrayList<Integer> arrayList = searchAll(arr, 0, num - 1, 80);
int search = search(arr, 0, num - 1, 99);
System.out.println(arrayList + "：-----：" + search);
}
public static ArrayList<Integer> searchAll(int[] arr, int left, int right, int val) {
if (left > right || val < arr[left] || val > arr[right]) {
return new ArrayList<>();
}
int mid = left + (right - left) * (val - arr[left]) / (arr[right] - arr[left]);
int midVal = arr[mid];
if (val < midVal) {
//向左递归,right移至递归段的最右端即mid-1
return searchAll(arr, left, mid - 1, val);
} else if (val > midVal) {
//向右递归,left移至递归段的最右端即mid+1
return searchAll(arr, mid + 1, right, val);
} else {
ArrayList<Integer> arrayList = new ArrayList<>(arr.length);
arrayList.add(mid);
int temp = mid - 1;
//向左扫描是否有相同值，并记录
while (true) {
if (temp < 0 || arr[temp] != val) {
break;
}
arrayList.add(temp--);
}
temp = mid + 1;
//向右扫描是否有相同值，并记录
while (true) {
if (temp > arr.length - 1 || arr[temp] != val) {
break;
}
arrayList.add(temp++);
}
return arrayList;
}
}
public static int search(int[] arr, int left, int right, int val) {
System.out.println("开始查找--");
//因为是有序的，所以不在最小值最大值范围的直接不存在
if (left > right || val < arr[left] || val > arr[right]) {
return -1;
}
int mid = left + (right - left) * (val - arr[left]) / (arr[right] - arr[left]);
int midVal = arr[mid];
if (val < midVal) {
//向左递归,right移至递归段的最右端即mid-1
return search(arr, left, mid - 1, val);
} else if (val > midVal) {
//向右递归,left移至递归段的最右端即mid+1
return search(arr, mid + 1, right, val);
} else {
return mid;
}
}
public static int[] init(int num) {
int[] arr = new int[num];
for (int i = 0; i < num; i++) {
arr[i] = i;
}
return arr;
}
}
注： 对于数据量较大，元素分布均匀的表来说，插值查找优于二分，但是元素分布不均匀的可能会没有二分来的快；
5，斐波那契（黄金分割法）查找：
黄金分割点： 黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。其比值是一个无理数，用分数表示为(√5-1)/2，取其前三位数字的近似值是0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这个分割点就叫做黄金分割点（golden section ratio），通常用Φ表示。这是一个十分有趣的数字，以0.618来近似表示，通过简单的计算就可以发现：(1-0.618)/0.618≈0.618，即一条线段上有两个黄金分割点。
斐波那契数列： 斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……后者比上前者无限接近0.618；
分析：
- 基于二分查找，只改变中间节点mid的位置；
- 不在由中间位或插值得到，而是位于黄金分割点附近；
- mid=left+F(k-1)-1，F代表斐波那契数列，k代表数列的第几个元素；
package com.search;
import java.util.Arrays;
/**
* @param
* @Author: AaNeei
* @Date: 2019/6/19 21:21
* @Description: 游学网
* @throws:
*/
public class FibonacciSearch {
public static void main(String[] args) {
int[] arr = {1, 5, 9, 13, 15, 46, 191, 1234, 45678};
int search = search(arr, 45678);
System.out.println(search);
}
public static int search(int[] arr, int val) {
int left = 0;
int right = arr.length - 1;
int k = 0;//斐波那契分割元素的下标
int mid = 0;
int[] f = fibonacciArr(arr);
//获取得到斐波那契分个数的下标
while (right > f[k] - 1) {
k++;
}
int[] temp = Arrays.copyOf(arr, f[k]);
for (int i = right + 1; i < temp.length; i++) {
temp[i] = arr[right];
}
while (left <= right) {
mid = left + f[k - 1] - 1;
if (val < temp[mid]) {
right = mid - 1;
k--;
} else if (val > temp[mid]) {
left = mid + 1;
k -= 2;
} else {
if (mid <= right) {
return mid;
} else {
return right;
}
}
}
return -1;
}
//斐波那契数列
public static int[] fibonacciArr(int[] arr) {
int[] f = new int[arr.length];
f[0] = 1;
f[1] = 1;
for (int i = 2; i < arr.length; i++) {
f[i] = f[i - 1] + f[i - 2];
}
return f;
}
}
466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
