查找（顺序查找、折半查找）

一、顺序查找

（1）顺序查找数组中的元素是否存在

public class Test {
    public boolean findNumberInArray(int[][] matrix, int target) {
        boolean result = false;
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                if (matrix[i][j] == target) {
                    result = true;
                    break;
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[][] matrix = {
                {1, 4, 7, 11, 15},
                {2, 5, 8, 12, 19},
                {3, 6, 9, 16, 22},
                {10, 13, 14, 17, 24},
                {18, 21, 23, 26, 30}};
        Test test=new Test();
        boolean b=test.findNumberInArray(matrix,2);
        System.out.println(b);
    }
}

相似于穷举法，遍历出每一种可能，而后找出须要的结果

测试结果：

true

（2）时间复杂度与空间复杂度

时间复杂度：O(n²)

空间复杂度：O(1)

 

二、折半查找

（1）查找流程

第一次：low=1，high=11（不是数组下标，仅表明元素顺序），计算的middle的值是6

第二次：由于要查找的数据的值要小于middle所对应的值，所以，要移动high到middle下标减一的位置

第三次：middle为3，查找的数据大于middle中的数据，所以要移动low到middle下标加一的位置

第四次：下标加1为4，也就是说low=4，high=5，计算middle的下标为4，此时的数据就是要查找的数据

（2）代码

public class Test {
    public static int binarySearch(int[] array,int key){
        int low = 0;
        int high = array.length - 1;
        if(low>high||key>array[high]||key<array[low]){
            return -1;
        }
        while(low<=high){
            int mid = low+ (high - low)/2;
            if(key==array[mid]){
                return mid;
            }else if (key>array[mid]){
                low = mid+1; //mid所对应的的值比key小,移动low
            }else {
                high = mid-1;  //mid所对应的的值比key大,移动high
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] arr = new int[]{15,66,48,9,54,11,87,100,40,8,9,7,12,13};
        int key = 11;
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(key+"元素的索引"+binarySearch(arr,key));
    }
}

测试结果：

true

先排除必定错误的状况，第一：low索引大于high索引，第二：要查找的数据的值比最小值小或者比最大值大

而后是low<high的状况：只要是low<high就一直执行死循环：令mid = low+ (high - low)/2，若是mid索引所对应的数据的值等于要查找的值就返回对应的值；若是要查找的数据的值大于mid索引所对应的数据，那么就让low=mid+1，不然，让high = mid-1

（3）总结

时间复杂度：O(log n)

空间复杂度：O（1）

要求：

顺序结构

元素有序：若是数据是无序的，能够尝试先将数据进行排序，变为有序后就可使用二分查找了

 

三、折半查找的递归写法

（1）递归实现者半查找

public class Test {
    public static int binarySearch(int[] array,int left,int right,int findVal){
        int mid = (right + left)/2;
        int midVal=array[mid];
        if (left>right){
            return -1;
        }
        if(findVal>midVal){
            return binarySearch(array,mid+1,right,findVal);
        }else if(findVal<midVal){
            return binarySearch(array,left,mid-1,findVal);
        }else {
            return mid;
        }
    }
    public static void main(String[] args) {
        int[] arr = new int[]{15,66,48,9,54,11,87,100,40,8,9,7,12,13};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println("元素的索引"+binarySearch(arr,0,arr.length-1,999));
    }
}

测试查找元素存在的状况：

[7, 8, 9, 9, 11, 12, 13, 15, 40, 48, 54, 66, 87, 100]
元素的索引2

测试元素不存在的状况：

[7, 8, 9, 9, 11, 12, 13, 15, 40, 48, 54, 66, 87, 100]
元素的索引-1

（2）总结

　　一个函数自身调用自身就是递归，要想使用递归须要知足如下三个条件：须要解决的问题能够转换为一个或多个子问题来求解，而这些子问题的解法与原问题彻底相同只是在数量和规模上不一样；递归的次数必须是有限的；必须有递归结束的终止条件