算法笔记-查找算法

在 java 中，我们常用的查找有四种:

1) 顺序(线性)查找 (就是for循环遍历)

2) 二分查找/折半查找 (重要找mid)

3) 插值查找

4) 斐波那契查找

1.二分查找:(必须有序)

package com.nmys.story.search;

import java.util.ArrayList;
import java.util.List;
/**
 * @Auther: Jia
 * @Date: 2019/9/12 07:28
 * @Description:
 */
public class BinarySearch {

    public static void main(String[] args) {
        //int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 11, 12, 13,14,15,16,17,18,19,20 };
        //int index = binarySearch(arr, 0, arr.length - 1, 1000);
		//System.out.println("index=" + index);
        int arr[] = { 1, 8, 10, 89,1000,1000, 1234 };
        List<Integer> list = binarySearch2(arr, 0, arr.length - 1, 1000);
        System.out.println("list=" + list);

    }
    // 二分查找算法
    /**
     *
     * @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
     *
     * 思路分析
     * 1. 在找到mid 索引值，不要马上返回
     * 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
     * 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
     * 4. 将Arraylist返回
     */
    public static List<Integer> binarySearch2(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  binarySearch2(arr,mid+1,right,findVal);
        }else if(findVal<midVal){
            return binarySearch2(arr,left,mid-1,findVal);
        }else{
 //           * 思路分析
//			 * 1. 在找到mid 索引值，不要马上返回
//			 * 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
//			 * 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
//			 * 4. 将Arraylist返回
            List<Integer> list = new ArrayList<Integer>();
            //向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
            int temp = mid - 1 ;
            while (true){
                if(temp<0||arr[temp]!=findVal){
                    break;
                }
                //否则，就temp 放入到 resIndexlist
                list.add(temp);
                temp -= 1;//左移
            }
            list.add(mid);
            //向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
            temp = mid + 1;
            while (true){
                if(temp>arr.length - 1|| arr[temp]!= findVal){
                    break;
                }
                //否则，就temp 放入到 list
                list.add(temp);
                temp += 1;
            }
            return list;
        }
    }

}

 

2.插值:

1)   插值查找原理介绍:

插值查找算法类似于二分查找，不同的是插值查找每次从自适应 mid 处开始查找。

2)对应前面的代码公式：

int mid = left + (right  – left) * (findVal – arr[left]) / (arr[right]  – arr[left]

 

package com.nmys.story.search;
/**
 * @Auther: Jia
 * @Date: 2019/9/15 11:07
 * 1)   对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找,  速度较快.
 * 2)   关键字分布不均匀的情况下，该方法不一定比折半查找要好
 */
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 arr[] = { 1, 8, 10, 89,1000,1000, 1234 };

        int index = insertValueSearch(arr, 0, arr.length - 1, 89);
        //int index = binarySearch(arr, 0, arr.length, 89);
        System.out.println("index = " + index);
    }


    public static int binarySearch(int[] arr, int left, int right, int findVal) {
        System.out.println("二分查找被调用~");
        // 当 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;
        }

    }

    //编写插值查找算法
    //说明：插值查找算法，也要求数组是有序的
    /**
     *
     * @param arr 数组
     * @param left 左边索引
     * @param right 右边索引
     * @param findVal 查找值
     * @return 如果找到，就返回对应的下标，如果没有找到，返回-1
     */
    public static int insertValueSearch(int[] arr , int left , int right , int findVal){
        System.out.println("插值查找次数~~");
        //注意：findVal < arr[0]  和  findVal > arr[arr.length - 1] 必须需要
        //否则我们得到的 mid 可能越界
        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 insertValueSearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) { // 说明向左递归查找
            return insertValueSearch(arr, left, mid - 1, findVal);
        } else {
            return mid;
        }

    }

}