力扣刷题笔记-查找算法

查找算法

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        unordered_map<int, bool> map;
        for(int num : nums) {
            if(map[num]) return num;
            map[num] = true;
        }
        return -1;
    }
};

在遇到元素重复的问题时候想到map（元素有序）和unordered_map（元素无序）
http://c.biancheng.net/view/7231.html（unordered_map的用法）

统计一个数字在排序数组中出现的次数。

class Solution {
public:
    int binarySearch(vector<int>& nums, int target, bool lower) {
        int left = 0, right = (int)nums.size() - 1, ans = (int)nums.size();
        while (left <= right) {
            int mid = (left + right) / 2;
            if (nums[mid] > target || (lower && nums[mid] >= target)) {
                right = mid - 1;
                ans = mid;
            } else {
                left = mid + 1;
            }
        }
        return ans;
    }

    int search(vector<int>& nums, int target) {
        int leftIdx = binarySearch(nums, target, true);
        int rightIdx = binarySearch(nums, target, false) - 1;
        if (leftIdx <= rightIdx && rightIdx < nums.size() && nums[leftIdx] == target && nums[rightIdx] == target) {
            return rightIdx - leftIdx + 1;
        }
        return 0;
    }
};

用到了二分查找法，二分查找法的代码并不难，我认为难于理解的地方是那几个判断：一是求最左边一个和最右边一个的时候，怎么卡if条件。二是得到left和right之后的判断不要遗漏条件。

在一个 n * m 的二维数组中，每一行都按照从左到右 非递减 的顺序排序，每一列都按照从上到下 非递减 的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        int i = matrix.size() - 1,j = 0;
        while(i>=0 && j < matrix[0].size()) {
            if(matrix[i][j] > target) i--;
            else if(matrix[i][j] < target) j++;
            else return true;
        }
        return false;
    }
};

惊呆了，我看到这个解法之后真的惊呆了，算法这万一还得看天赋wok！！！
总的思路就是把这个矩阵看成一个二叉树，从右上角往左下角看的话，就成了一个二叉搜索树，然后就是遍历算法了，简简单单~

给你一个可能存在 重复 元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为 1。

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

这里有三种情况可能会遇到，分别是：
1.
2.
3.
然后根据这三种情况，最难的是判断条件到底怎么设计：对于第一种情况，需要判断的是mid>low？是的话就把mid+1赋给low（这里mid不可能是最小值，所以可以mid+1）。第二种情况就判断mid<high？是的话就把mid赋给high就可以了（这里mid有可能会直接取到最小值，所以是直接把high=mid）。针对第三种情况的话，就直接不管了，一个一个的排除，总会取到需要的那个，所以是high–。

在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。

class Solution {
public:
    char firstUniqChar(string s) {
        unordered_map<int, int> frequency;
        for (char ch: s) {
            ++frequency[ch];
        }
        for (int i = 0; i < s.size(); ++i) {
            if (frequency[s[i]] == 1) {
                return s[i];
            }
        }
        return ' ';
    }
};

主要需要记住的是哈希表的使用