1、顺序查找

按照顺序一个一个比较，查找需要的值。

代码实现：

时间复杂度：T(n) = O(n)

空间复杂度：S(n) = O(1)

    static int findKey(int[] arr,int obj){
        for(int i = 0;i< arr.length;i++){
            if(arr[i]==obj) return i;
        }
        return -1;
    }

2、折半查找

前提：

　　1、必须是顺序表存储结构。

　　2、被查找的表必须按关键字大小有序排列。

代码实现（非递归）：

时间复杂度： T(n) = O( log₂n)

空间复杂度： S(n) = O(1)

    static int find2(int[] arr,int i){
        //首
        int head = 0;
        //尾
        int tail = arr.length-1;
        //中
        int mid = (head+tail)/2;

        //折半查找
        while (head<=tail){
            if(arr[mid]==i){ //找到了
                return mid;
            }else if(arr[mid]>i){//中间值大于要查找的值，则尾部前移
                tail = mid -1;
                mid = (head+tail)/2;
            }else if(arr[mid]<i){//中间值小于要查找的值，则头部后移
                head = mid +1;
                mid = (head+tail)/2;
            }
        }
        return -1;
    }

代码实现（使用递归）：

时间复杂度：T(n) = O( log₂n )

空间复杂度：S(n) = O( log₂n )

    public static int find3(int[] arr, int value){
        return  find3(arr,value,0,arr.length-1);
    }
    private static int find3(int[] arr, int value, int head, int tail){
        int mid = (head+tail)/2;

        if(head<=tail) {
            if (arr[mid] == value) { //找到了
                return mid;
            } else if (arr[mid] > value) {//中间值大于要查找的值，则尾部前移
                return find3(arr, value, head, mid - 1);
            } else if (arr[mid] < value) {//中间值小于要查找的值，则头部后移
                return find3(arr, value, mid + 1, tail);
            }
        }
        return -1;
    }