查找算法(线性查找,二分查找)

线性查找

线性查找:用逐一的去比对数组每个位置元素的值,直到找到需要找到的元素.

线性查找也叫做顺序查找,从数组的第一个元素一直到最后一个元素去查找.方法简单,遍历整个数组即可;

public class SeqSearch {
    public static void main(String[] args) {
        int[] arr={12,2,3,13,13,8,6};
        int result = searchIndex(arr, 3);
        System.out.println(result);
    }
    public  static int searchIndex(int[] arr,int value){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==value){
               return i;
            }
        }
        return -1;
    }
}

二分查找

二分查找思路:针对于有序的数组先找到数组的中间值,若需要查找的数据比中间值大,则向数组的右半部分查找,再通过右半部分中间值,比较需要找的元素大小,进而缩小查找区间,最后完成查找.

arr={1,8, 10, 89, 1000, 1234}

若需要将上述的数组通过二分查找方法找到元素1000.则查找步骤

1.确定数组中间元素的值,midValue=arr[left+right]=89

2.比较 1000>89,不相等则进一步再89右边进行查找,查找范围  [midIndex+1,right]

3.此时left=4,right=5,midIndex=arr[4+5]=1000;找到数据;

 

俩种情况特殊考虑 

第一种,若数组无需要查找的数,则需加以限制条件,否则就会递归造成栈空间不足;

 public static int binary(int leftIndex, int rightIndex, int value, int[] arr) {
        if (leftIndex > rightIndex) {
            return -1;
        }
        int midIndex;
        midIndex = (leftIndex + rightIndex) / 2;
        int midValue;
        midValue = arr[midIndex];

        if (value < midValue) {
            return binary(leftIndex, midIndex - 1, value, arr);
        } else if (value > midValue) {
            return binary(midIndex + 1, rightIndex, value, arr);
        } else {
            return midIndex;
        }
    }

 终止条件是,左边索引大于右边的索引,则程序停止.

第二种,若数组中有多个重复的数据,则需要全部查询,否则只会返回一个数据.用list集合保存. 

当找到中间的一个数据时,左右延申分别找到相同的数,为了防止数组溢出,则头尾分别考虑.

public static ArrayList<Integer> binaryAll(int leftIndex, int rightIndex, int value, int[] arr) {
        ArrayList<Integer> array = new ArrayList<Integer>();
        if (leftIndex > rightIndex) {
            return new ArrayList<Integer>();
        }

        int midIndex;
        midIndex = (leftIndex + rightIndex) / 2;
        int midValue;
        midValue = arr[midIndex];
        if (value < midValue) {
            return binaryAll(leftIndex, midIndex - 1, value, arr);
        } else if (value > midValue) {
            return binaryAll(midIndex + 1, rightIndex, value, arr);
        } else {
            int temp = midValue;           //临时变量保存中间值,和中间索引,防止俩次左右寻找将中间值和索引覆盖
            int tempIndex = midIndex;
            if (arr[arr.length - 1] == midValue) {   //防止数组溢出,尾特殊化
                array.add(arr.length - 1);
            }
            if (arr[0] == midValue) {             //防止数组溢出,头特殊化
                array.add(0);
            }
            while (arr[tempIndex] == temp && tempIndex < arr.length - 1) {  //向右查找相同的数
                array.add(tempIndex);
                tempIndex++;
            }

            while (arr[--midIndex] == midValue && midIndex > 0) {  //向左查找相同的数
                array.add(midIndex);
            }
            return array;
        }
    }