LeetCode05-二维数组中的查找-旋转数组中的最小位置-第一个只出现一次的字符

我是一ke卷心菜

已于 2023-01-07 21:10:29 修改

阅读量68

点赞数 2

文章标签：算法 leetcode 数据结构

于 2023-01-07 16:02:54 首次发布

本文链接：https://blog.csdn.net/weixin_57075614/article/details/128591696

版权

二维数组中的查找

问题描述：

在这里插入图片描述
思路分析：
用暴力法遍历矩阵，并找到target,若没有返回false。
代码如下：

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

官方题解：
由于矩阵 matrix中每一行的元素都是升序排列的，因此我们可以对每一行都使用一次二分查找，判断 target 是否在该行中，从而判断 target 是否出现。
代码如下：

class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        for (int[] row : matrix) {
            int index = search(row, target);
            if (index >= 0) {
                return true;
            }
        }
        return false;
    }

    public int search(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low <= high) {
            int mid = (high - low) / 2 + low;
            int num = nums[mid];
            if (num == target) {
                return mid;
            } else if (num > target) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }
}

旋转数组中的最小位置

问题描述：

在这里插入图片描述
思路分析：
定义一个min变量=numbers[0]，并依次和后一位比较，若min>后一位，使min=后一位。
代码如下：

class Solution {
    public int minArray(int[] numbers) {
        int min=numbers[0];
        for(int i=0;i<numbers.length;i++){
              if(min>numbers[i]){
                  min=numbers[i];
              }
        }
        return min;
    }
}

官方题解：
在这里插入图片描述

class Solution {
    public int minArray(int[] numbers) {
        int low = 0;
        int high = numbers.length - 1;
        while (low < high) {
            int pivot = low + (high - low) / 2;
            if (numbers[pivot] < numbers[high]) {
                high = pivot;
            } else if (numbers[pivot] > numbers[high]) {
                low = pivot + 1;
            } else {
                high -= 1;
            }
        }
        return numbers[low];
    }
}

第一个只出现一次的字符

问题描述：

在这里插入图片描述

解题思路:
我们可以对字符串进行两次遍历。
在第一次遍历时，我们使用哈希映射统计出字符串中每个字符出现的次数。在第二次遍历时，我们只要遍历到了一个只出现一次的字符，那么就返回该字符，否则在遍历结束后返回空格。
代码如下：

class Solution {
    public char firstUniqChar(String s) {
        Map<Character, Integer> frequency = new HashMap<Character, Integer>();
        for (int i = 0; i < s.length(); ++i) {
            char ch = s.charAt(i);
            frequency.put(ch, frequency.getOrDefault(ch, 0) + 1);
        }
        for (int i = 0; i < s.length(); ++i) {
            if (frequency.get(s.charAt(i)) == 1) {
                return s.charAt(i);
            }
        }
        return ' ';
    }
}