学习笔记-算法-7-查找

查找

线性查找

public class SeqSearch{
    public static void main(String[] args){
        int arr[] = {1,4,5,11,-1,34,89};
        int index = seqSearch(arr,11);
        
    }
    
    public static int seqSearch(int arr[],int value){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==value){
                return i;
            }
        }
        return -1;
    }
    
}

二分查找

• 有序数组
  • 首先确定改数组中间下标
  • 需要查找的数与中间数比较
  • 大于中间数，向右查找
  • 大于左边，向左查找

public class BinarySearch{
    public static void main(String[] args){
        // 有序数组
        int arr[] = {1,8,10,89,1000,1024};
        List<Integer> indexList = binarySearch(arr,0,arr.length-1,10);
    }
    
    public static List<Integer> binarySearch(int[] arr,int left,int right,int findVal){
        if(left > right){
            return new ArrayList<Integer>();
        }
        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;
            // 返回所有相同的mid
            List<Integer> resIndexList = new ArrayList<>();
            resIndexList.add(mid);
            // 向左查询
            int temp = mid - 1;
            while(true){
                if(temp < 0 || arr[temp] != findVal){
                    break;
                }else{
                    resIndexList.add(temp)
                    temp -= 1;
                }
            }
            temp = mid + 1;
             while(true){
                if(temp> arr.length -1 || arr[temp] != findVal){
                    break;
                }else{
                    resIndexList.add(temp)
                    temp += 1;
                }
            }
            return resIndexList;
        }
    }
}

插值查找

• mid
  • 二分
    • (left+right)/2
  • 插值
    • 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;;
        }
        System.out.print;n(Arrays.toString(arr));
        int index = search(arr,0,arr.length-1,20);
    }
    
    // 插值查找，也要求数组有序
    public static int search(int[] arr,int left,int right,int findVal){
        for(left>right || findVal< arr[left] || findVal > arr[right]){
            return -1;
        }
        int mid = left + (right-left)*(findVal-arr[left])/(arr[right]-arr[left]);
        int midVal = arr[mid];
        if(findVal>midVal){
            // 向右查找
            return search(arr,mid+1,right,findVal);
        }else if(findVal < midVal){
            return search(arr,left,mid-1,findVal);
        }else{
            return mid;
        }
        
    }
}

斐波那契查找

• 斐波那契查找法
  • 黄金分割查找法

public class FibonacciSearch{
    public static int maxSize = 20;
    
    public static void main(String[] args){
        int[] arr = {1,8,10,98,1000,1024};
    }
    
    // 创建斐波那契数列
    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;
    }
    
    public static int search(int[] ,int key){
        int low = 0;
        int high = a.length-1;
        int k = 0; // 分割的下标
        nt mid = 0; // 存放mid值
        int f[] = fib();// 获取数列
        while(high>f[k]-1){
            k++;
        }
        // 创建一个f[k]长度的数组，用a来填充
        int[] temp = Arrays.copyOf(a,f[k]);
        // 将多出的部分用a[high]填充
        for(int i=high+i;i<temp.length;i++){
            temp[i] = a[high];
        }
        while(low<=high){
            mid = low+f[k-1]-1;
            if(key<temp[mid]){
                // 向前找
                high = mid - 1;
                k--;
            }else if(key>temp[mid]){
                // 向后
                low = mid+1;
                k-=2;
            }else{
                if(mid<=high){
                    return mid;
                }else{
                    return high;
                }
            }
        }
    }
   
}