Java常用查找：线性查找、二分查找、差值查找

一.线性查找

        逐一进行比对，查到返回下标，未查到返回-1

public static int seqSearch(int[] array, int value) {
        // 线性查找，逐一匹配
        for (int i = 0; i < array.length; i++) {
            if (array[i] == value) {
                return i;
            }
        }
        return -1;
    }

二.二分查找

        列表必须有序，时间复杂度O(logn)

public static int search(int[] arr, int left, int right, int findVal) {
        int mid = (left + right) / 2;
        int midVal = arr[mid];

        if (left > right) return -1;

        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 static List<Integer> searchPlus(int[] arr, int left, int right, int findVal) {

        int mid = (left + right) / 2;
        int midVal = arr[mid];

        if (left > right) return new ArrayList<>();

        if (findVal > midVal) {
            return searchPlus(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {
            return searchPlus(arr, left, mid - 1, findVal);
        } else {
            ArrayList<Integer> list = new ArrayList<>();

            // 左边是否还有
            int temp = mid - 1;
            while (true) {
                if (temp < 0 || arr[temp] != findVal) {
                    break;
                }
                list.add(temp);
                temp--;
            }

            list.add(mid);

            // 右边是否还有
            temp = mid + 1;
            while (true) {
                if (temp > arr.length - 1 || arr[temp] != findVal) {
                    break;
                }
                list.add(temp);
                temp++;
            }
            return list;
        }
    }

三.差值查找   

• 对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找，速度较快
• 关键字分布不均匀的情况下，该方法不一定比折半查找要好

  public static int search(int[] arr, int left, int right, int findVal) {
          System.out.println("hello");
          if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) 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;
          }
      }

  公式：