剑指Offer学习 —— 有序二维数组中查找

二维数组中的查找

class Solution {
        /*
         *
         * 题目：在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
         *
         * 思路一：暴力遍历
         * 思路二：2个方向线性查找
         *       分析：数组本身部分有序，找到一个点，可以划分部分区域。
         *            从左下角或者右上角，沿一个方向增加，另一个方向减少
         *
         *
         * */

        //  从左下角
        public boolean findNumberIn2DArray1(int[][] matrix, int target) {
            if (matrix == null || matrix.length == 0 || matrix[0] == null || matrix[0].length == 0) {
                return false;
            }
            int row = matrix.length;
            int col = matrix[0].length;
            int x = row - 1;
            int y = 0;
            while (x >= 0 && x < row && y >= 0 && y < col) {
                if (matrix[x][y] > target) {
                    x--;
                } else if (matrix[x][y] < target) {
                    y++;
                } else {
                    return true;
                }

            }
            return false;
        }

        //  从右上角
        public boolean findNumberIn2DArray2(int[][] matrix, int target) {
            if (matrix == null || matrix.length == 0 || matrix[0] == null || matrix[0].length == 0) {
                return false;
            }
            int row = matrix.length;
            int col = matrix[0].length;
            int x = 0;
            int y = col - 1;
            while (x >= 0 && x < row && y >= 0 && y < col) {
                if (matrix[x][y] > target) {
                    y--;
                } else if (matrix[x][y] < target) {
                    x++;
                } else {
                    return true;
                }

            }
            return false;
        }
    }

旋转数组的最小数字

class Solution {
        /*
         *
         * 题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。
         *      例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1
         *
         *
         * 思路1：遍历一遍，找到第一个拐点，或者就是第一个元素
         * 思路2：有序数组用2分 注意：防止溢出，mid = low + (high - low) / 2
         *       分析：递增数组旋转，假设最小值的索引是x ， 则 [0,x)都大于等于 num[n-1] ; (x,n) 都小于等于 num[n-1]
         *            以这个为标准分区 等于的时候，修改右侧
         *
         * */
        public int minArray1(int[] numbers) {
            for (int i = 0; i < numbers.length - 1; i++) {
                if (numbers[i + 1] < numbers[i]) {
                    return numbers[i + 1];
                }
            }
            return numbers[0];
        }

        public int minArray2(int[] numbers) {
            int n = numbers.length;
            int left = 0;
            int right = n - 1;
            while (left < right) {
                int mid = left + (right - left) / 2;
                if (numbers[mid] < numbers[right]) {
                    right = mid;
                } else if (numbers[mid] > numbers[right]) {
                    left = mid + 1;
                }else {
                    right --;
                }
            }
            return numbers[left];
        }
    }

第一个只出现一次的字符

 class Solution {
        /*
         *
         * 题目：在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。
         *
         * 思路：map记录次数，注意HashMap是无序的，要使用LinkedHashMap
         *
         * */
        public char firstUniqChar(String s) {
            if (s == null || s.length() == 0) {
                return ' ';
            }
            Map<Character, Integer> map = new LinkedHashMap<>();
            for (char c : s.toCharArray()) {
                map.put(c, map.getOrDefault(c, 0) + 1);
            }
            for (Map.Entry entry : map.entrySet()) {
                if(entry.getValue().equals(1)){
                    return (char)entry.getKey();
                }
            }
            return ' ';
        }

    }