代码实现
package com.springboot.数据结构和算法.search;
/**
* @author: 牧羊
* @Date: 2020/5/23 14:05
* 线性查找算法
*/
public class SeqSearch {
public static void main(String[] args) {
//没有顺序额数组
int[] arr = {1,9,11,-1,34,89};
int index = seqSearch(arr,-11);
if(index == -1){
System.out.println("没有找到");
}else{
System.out.println("找到值,下标为:" + index);
}
}
/**
* 这里我们实现线性查找,找到一个满足条件的值,就返回
* @param arr
* @param i
* @return
*/
private static int seqSearch(int[] arr, int value) {
//线性查找是逐一对比,发现有相同的值,就返回下标
for(int i = 0 ; i < arr.length ; i++){
if(arr[i] == value){
return 1;
}
}
return -1;
}
}
代码实现
package com.springboot.数据结构和算法.search;
import java.util.ArrayList;
import java.util.List;
/**
* @author: 牧羊
* @Date: 2020/5/23 14:05
* 二分查找算法,使用二分法的前提是数组是有序的
*/
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1,8,10,89,1000,1000,1234};
int index = binarySearch(arr, 0, arr.length - 1, 1000);
List<Integer> indexs = binarySearch2(arr, 0, arr.length - 1, 1000);
System.out.println("查找数的下标为:" + index);
System.out.println("查找数的下标为:" + indexs);
}
/**
* 二分查找算法
* @param arr 数组
* @param left 左边的索引
* @param right 右边的索引
* @param findVal 要查找的值
* @return 如果找到就返回下标,如果没有找到,就返回-1
*/
public static int binarySearch(int[] arr,int left,int right,int findVal){
//当left > right 时,说明递归整个数组,暗示没有找到
if(left > right){
return -1;
}
int mid = (left + right)/2;
int midVal = arr[mid];
if(findVal > midVal){ //向右递归
return binarySearch(arr,mid + 1, right,findVal);
}else if (findVal < midVal){ //向左递归
return binarySearch(arr,left,mid - 1,findVal);
}else{
return mid;
}
}
/**
* {1,8,10,89,1000,1000,1234}当一个有序数组中
* 有多个相同的数值时,如何将所有的数值都查到,比如1000
*/
public static List<Integer> binarySearch2(int[] arr,int left,int right,int findVal){
//当left > right时,说明递归整个数组,但是没有找到
if(left > right){
return new ArrayList<Integer>();
}
int mid = (left + right)/2;
int midVal = arr[mid];
if(findVal > midVal){ //向右递归
return binarySearch2(arr,mid + 1, right,findVal);
}else if (findVal < midVal){ //向左递归
return binarySearch2(arr,left,mid - 1,findVal);
}else{
//思路分析:
//1:在找到mid索引值,不要马上返回
//2:向mid索引的左边扫描,将所有满足1000的元素下边,加入到list当中
//3:向mid索引的右边扫描,将所有满足1000的元素下边,加入到list当中
//4: 将list返回
List<Integer> list = new ArrayList<>();
list.add(mid);
//想mid索引值额左边扫描,将所有满足1000的元素下标,加入到list当中
int temp= mid -1;
while (true){
if(temp < 0 || arr[temp] != findVal){ //退出
break;
}
//否则,就temp放入到list当中
list.add(temp);
temp -= 1;
}
//想mid索引值额右边扫描,将所有满足1000的元素下标,加入到list当中
temp= mid +1;
while (true){
if(temp > arr.length || arr[temp] != findVal){ //退出
break;
}
//否则,就temp放入到list当中
list.add(temp);
temp += 1;
}
return list;
}
}
}
代码实现
package com.springboot.数据结构和算法.search;
/**
* @author: 牧羊
* @Date: 2020/5/23 14:05
* 插值查找算法(数组需要有序的)
*/
public class InsertValSearch {
public static void main(String[] args) {
//
int[] arr = {1,8,10,89,1000,1000,1234};
int index = insertValSearch(arr, 0, arr.length - 1, 1234);
System.out.println("查找出数据的下标为:" + index);
}
/**
* 插值查找算法
* @param arr 数组
* @param left 左边的索引
* @param right 右边的索引
* @param findVal 要查找的值
* @return 如果找到就返回下标,如果没有找到,就返回-1
*/
private static int insertValSearch(int[] arr,int left,int right,int findVal) {
//当left > right 时,说明递归整个数组,暗示没有找到
if(left > right || findVal < arr[left] || findVal > arr[right]){
return -1;
}
//求出mid,自适应
int mid = left + (right + left)*(findVal - arr[left])/(arr[right] - arr[left]);
int midVal = arr[mid];
if(findVal > midVal){ //向右递归
return insertValSearch(arr,mid + 1, right,findVal);
}else if (findVal < midVal){ //向左递归
return insertValSearch(arr,left,mid - 1,findVal);
}else{
return mid;
}
}
}
代码实现
package com.springboot.数据结构和算法.search;
import java.util.Arrays;
/**
* @author: 牧羊
* @Date: 2020/5/23 14:05
* 斐波那契查找算法(数组需要有序的)
*/
public class FibonacciValSearch {
public static int maxSize = 20;
public static void main(String[] args) {
int[] arr = {1, 8, 10, 89, 1000, 1000, 1234};
int index = fibonacciValSearch(arr, 189);
System.out.println("查找出数据的下标为:" + index);
}
//因为后面我们mid = low + F(k - 1) -1,需要使用到斐波那契劽,因此我们需要先获取一个斐波那契数列,
//使用递归得到一个斐波那契数列
public static int[] fib() {
int[] f = new int[maxSize];
f[0] = 1;
f[1] = 1;
for (int i = 2; i < maxSize; i++) {
f[i] = f[i - 1] + f[i - 2];
}
return f;
}
//编写斐波那契查找算法
//使用非递归的方式编写查找算法
/**
* @param arr 数组
* @param k 我们需要查找的关键值
* @return
*/
private static int fibonacciValSearch(int[] arr, int key) {
int low = 0;
int high = arr.length - 1;
int k = 0; //表示斐波那契分割数的下标
int mid = 0; //存放到斐波那契数列
int[] f = fib(); //获取到斐波那契数列
//获取到斐波那契数列的下标
while (high > f[k] - 1) {
k++;
}
//因为f{k}值,可能大于a的长度,因此我们需要使用Arrays类,构造一个新的数组,并指向temp[]
//不足的不分使用0填充
int[] temp = Arrays.copyOf(arr, f[k]);
//实际上需求使用arr数组最后的数填充temp
for (int i = high + 1; i < temp.length; i++) {
temp[i] = arr[high];
}
//使用while来循环处理,找到我们的数key
while (low <= high) { //只要满足这个条件,就可以找
mid = low + f[k - 1] - 1;
if (key < temp[mid]) { //我们应该继续向数组的前面查找(左边)
high = mid - 1;
//为什么是k--
//说明
//1:全部元素 = 前面的元素 + 后面的元素
//2:f[k] = f[k-1]+f[k-2]
//因为前面有f[k-1]个元素,所以可以继续拆分f[k-1] = f[k-2] + f[k-3]
//即在f[k-1]的前面继续查找k--
//即下次循环mid=f[k-1]-1
k--;
} else if (key > temp[mid]) { //我们应该继续向数组的后面查找(右边)
low = mid + 1;
//为什么是 k-=2
//说明
//1:全部元素 = 前面的元素 + 后边的元素
//2:f[k] = f[k-1] + f[k-2]
//3:因为后面我们又f[k-2],所以可以继续拆分f[k-1] = f[k-3] + f[k-4]
//4:即在f[k-2]的前面进行查找k-=2
//5:即下次循环mid = f[k-1-2] - 1
k -= 2;
} else { //找到
//需要确定,返回的那个下标
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
}