数据结构和算法--7查找算法

1）    顺序（线性）查找
2）    二分查找/折半查找
3）    插值查找
4）    斐波那契查找 

有一个数列[1,43,22，-10,0]，判断数列中是否包含此名称，如果找到了，就提示找到，并给出下标值。

package com.offcn.search;
//线性查找
public class SeqSearch {
    public static void main(String[] args){
        int[] arr = {1,43,22,-10,0};
        int result = seqSearch(arr,0);
        if(result != -1){
            System.out.println("找到了！下标为"+result);
        }else{
            System.out.println("未找到");
        }
    }
    public static int seqSearch(int[] arr,int value){
        for(int i = 0;i < arr.length;i++){
            if(arr[i] == value){
                return i;
            }
        }
        return -1;
    }
}

请对一个有序数组进行二分查找{1,8,10,89,1000,1234}，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示“没有这个数”

package com.offcn.search;
//二分查找
public class BinarySearch {
    public static void main(String[] args){
        int[] arr = {1,8,10,89,1000,1234};
        int i = binarySearch(arr, 0, arr.length - 1, 1234);
        if(i == -1){
            System.out.println("未找到");
        }else {
            System.out.println("找到了！下标为"+i);
        }
    }
    public static int binarySearch(int[] arr,int left,int right,int findValue){
        //如果一直没找到，left可能会一直mid+1，超出范围
        if(left > right){
            return -1;
        }
        //数组中间下标
        int mid = (left+right)/2;
        int midValue= arr[mid];
        //如果查找的元素大于中间值，向右递归
        if(findValue > midValue){
            return binarySearch(arr,mid+1,right,findValue);
            //小于中间值，向左递归
        }else if(findValue < midValue){
            return binarySearch(arr,left,mid-1,findValue);
            //正好是中间值
        }else{
            return mid;
        }
    }
}

{1,8,10,89,1000,1000,1000,1000,1234}当一个有序数组中有多个相同的值，如何将所有的数值都查找到？

package com.offcn.search;

import java.util.ArrayList;

public class BinarySearchList {
    public static void main(String[] args){
        int[] arr = {1,8,10,89,1000,1000,1000,1000,1234};
        ArrayList<Integer> list = binarySearchList(arr, 0, arr.length - 1, 1000);
        System.out.println(list);

    }
    public static ArrayList<Integer> binarySearchList(int[] arr,int left,int right,int findValue){
        if(left > right){
            return new ArrayList<>();
        }

        int mid = (left+right)/2;
        int midValue= arr[mid];
        if(findValue > midValue){
            return binarySearchList(arr,mid+1,right,findValue);
        }else if(findValue < midValue){
            return binarySearchList(arr,left,mid-1,findValue);
        }else{
            //如果找到，则先不返回，创建一个集合装相同数值的下标
            ArrayList list = new ArrayList();
            //向mid的左边扫描，寻找同数值的下标加入到集合中
            int temp = mid-1;
            while (true){
                if(temp < 0 || arr[temp] != findValue){
                    break;
                }
                list.add(temp);
                temp -= 1;
            }
            list.add(mid);
            //向mid的右边扫描，寻找同数值的下标加入到集合中
            temp = mid+1;
            while (true){
                if(temp > arr.length-1 || arr[temp] != findValue){
                    break;
                }
                list.add(temp);
                temp += 1;
            }
            return list;
        }
    }
}

package com.offcn.search;
//插值查找
public class InsertValSearch {
    public static void main(String[] args){
        int[] arr = new int[100];
        for(int i = 0; i < arr.length;i++){
            arr[i] = i+1;
        }
        int i = insertValSearch(arr, 0, arr.length-1, 100);
        System.out.println("下标为"+i);

    }
    public static int insertValSearch(int[] arr,int left,int right,int findVal){
        System.out.println("插值查找1次");
        //如果left>rigth 或者findValue的值不正确，返回-1
        if(left > right || findVal < arr[0] || findVal > arr[arr.length-1]){
            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;
        }
    }
}