剑指Offer-学习计划（八）查找算法（下）

考点：关于查找算法，分类其实还挺多的，比如二分查找，顺序查找，插值查找，树表查找，哈希查找等，实际上日常编码也会接触到，可以借用他们的思想给我们的编码过程带来更好的体验，这几道题里面最多的用到的就是二分、顺序和哈希了，顺序和哈希一般考点不会太深主要是二分查找。变种比较多，纯靠套公式很容易出现问题，要理解什么时候能用如何用，怎么设计中间值，low和high还有表达式关系。

题目一：剑指 Offer 50. 第一个只出现一次的字符

在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。
示例 1:
输入：s = "abaccdeff"
输出：'b'
示例 2:
输入：s = ""
输出：' '
https://leetcode.cn/problems/di-yi-ge-zhi-chu-xian-yi-ci-de-zi-fu-lcof/

解法一：字符串转换字符数组，两次遍历

 public char firstUniqChar(String s) {
        int[] count = new int[26];
        char[] chars = s.toCharArray();
        for (char c : chars) count[c - 'a']++;
        for (char c : chars) {
            if (count[c - 'a'] == 1) return c;
        }
        return ' ';
    }

解法二： 判空，先存入Map之后迭代使用Map过滤

    public char firstUniqChar2(String s) {
        if (s.length() == 0) return ' ';
        Map<Character, Integer> map = new LinkedHashMap<>();
        for (int i = 0; i < s.length(); i++) {
            map.put(s.charAt(i), map.getOrDefault(s.charAt(i),0)+1);
        }
        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            if (entry.getValue()==1)return entry.getKey();
        }
        return ' ';
    }

题目二：剑指 Offer 11. 旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
给你一个可能存在 重复 元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。
例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为 1。
注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。
示例 1：
输入：numbers = [3,4,5,1,2]
输出：1
示例 2：
输入：numbers = [2,2,2,0,1]
输出：0
https://leetcode.cn/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/

解法一：遍历比大小，简单易懂

public int minArray1(int[] numbers) {
        int min = Integer.MAX_VALUE;
        for (int number : numbers) {
            min = Math.min(min, number);
        }
        return min;
    }

解法二： 二分就是最好的解法，这道题直接套公式即可

public int minArray2(int[] numbers) {
        int low = 0, high = numbers.length - 1;

        while (low < high) {
            int mid = low + ((high - low) >> 1);
            if (numbers[mid] < numbers[high]) {
                high = mid;
            } else if (numbers[mid] > numbers[high]) {
                low = mid + 1;
            } else {
                high -= 1;
            }
        }
        return numbers[low];

    }

题目三：剑指 Offer 04. 二维数组中的查找

在一个 n * m 的二维数组中，每一行都按照从左到右 非递减 的顺序排序，每一列都按照从上到下 非递减 的顺序排序。
请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
示例:
现有矩阵 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]
]
给定 target = 5，返回 true。
给定 target = 20，返回 false。
https://leetcode.cn/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof

解法一：很简单常见的嵌套循环法

    public boolean findNumberIn2DArray2(int[][] matrix, int target) {
        for (int i = 0; i < matrix.length; i++) {
            jf:
            for (int j = 0; j < matrix[0].length; j++) {
                int n = matrix[i][j];
                if (target<n){
                    break jf;
                }else if (target == n){
                    return true;
                }
            }
        }
        return false;
    }

解法二：对解法一进行精简后，可读性增强，性能差不多

 public boolean findNumberIn2DArray1(int[][] matrix, int target) {
        for (int[] ints : matrix) {
            for (int j = 0; j < matrix[0].length; j++) {
                if (target == ints[j]) return true;
            }
        }
        return false;
    }

解法三： 正解只能是二分了，这个题，二维数组，顺序的，这不妥妥勾引你用二分求解？

    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        if (matrix == null || matrix.length ==0)return false;

        int m = matrix.length, n = matrix[0].length;
        int row = 0, col = n - 1;
        while (row<m && col>=0){
            if (matrix[row][col]>target){
                col--;
            }else if (matrix[row][col]<target){
                row++;
            }else {
                return true;
            }
        }
        return false;
    }