代码随想录拓展day1 1365.有多少小于当前数字的数字；941.有效的山脉数组；1207.独一无二的出现次数；283. 移动零

打卡结束了，趁着世界杯当了几天懒狗，现在正好世界杯也结束了，希望能保持一个好习惯吧。

1365.有多少小于当前数字的数字

1365. 有多少小于当前数字的数字 - 力扣（Leetcode）

挺有意思的一个数组题目，关键在于如何处理排序后数组中相同的数。从后向前就可以解决这个问题。其实dp也有些题目会从后向前的更新策略。

思路

排序之后，其实每一个数值的下标就代表这前面有几个比它小的了。

代码如下：

vector<int> vec = nums;
sort(vec.begin(), vec.end()); // 从小到大排序之后，元素下标就是小于当前数字的数字

用一个哈希表hash（本题可以就用一个数组）来做数值和下标的映射。这样就可以通过数值快速知道下标（也就是前面有几个比它小的）。

此时有一个情况，就是数值相同怎么办？

例如，数组：1 2 3 4 4 4 ，第一个数值4的下标是3，第二个数值4的下标是4了。

这里就需要一个技巧了，在构造数组hash的时候，从后向前遍历，这样hash里存放的就是相同元素最左面的数值和下标了。代码如下：

int hash[101];
for (int i = vec.size() - 1; i >= 0; i--) { // 从后向前，记录 vec[i] 对应的下标
    hash[vec[i]] = i;
}

最后在遍历原数组nums，用hash快速找到每一个数值对应的小于这个数值的个数。存放在将结果存放在另一个数组中。

代码如下：

// 此时hash里保存的每一个元素数值 对应的 小于这个数值的个数
for (int i = 0; i < nums.size(); i++) {
    vec[i] = hash[nums[i]];
}

流程如图：

在这里插入图片描述

关键地方讲完了，整体C++代码如下：

class Solution {
public:
    vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
        vector<int> vec = nums;
        sort(vec.begin(), vec.end()); // 从小到大排序之后，元素下标就是小于当前数字的数字
        int hash[101];
        for (int i = vec.size() - 1; i >= 0; i--) { // 从后向前，记录 vec[i] 对应的下标
            hash[vec[i]] = i;
        }
        // 此时hash里保存的每一个元素数值 对应的 小于这个数值的个数
        for (int i = 0; i < nums.size(); i++) {
            vec[i] = hash[nums[i]];
        }
        return vec;
    }
};

可以排序之后加哈希，时间复杂度为 $O (n l o g n)$

941.有效的山脉数组

941. 有效的山脉数组 - 力扣（Leetcode）

本来一开始想着用一个标记来表示有没有山顶，结果发现没法用于多个山顶，然后根据比较方式也没法用于单增或者单减的数组，看了解析才知道要用双指针法。

思路

判断是山峰，主要就是要严格的保存左边到中间，和右边到中间是递增的。

这样可以使用两个指针，left和right，让其按照如下规则移动，如图：

在这里插入图片描述

注意这里还是有一些细节，例如如下两点：

因为left和right是数组下标，移动的过程中注意不要数组越界
如果left或者right没有移动，说明是一个单调递增或者递减的数组，依然不是山峰

C++代码如下：

class Solution {
public:
    bool validMountainArray(vector<int>& A) {
        if (A.size() < 3) return false;
        int left = 0;
        int right = A.size() - 1;

        // 注意防止越界
        while (left < A.size() - 1 && A[left] < A[left + 1]) left++;

        // 注意防止越界
        while (right > 0 && A[right] < A[right - 1]) right--;

        // 如果left或者right都在起始位置，说明不是山峰
        if (left == right && left != 0 && right != A.size() - 1) return true;
        return false;
    }
};

1207.独一无二的出现次数

1207. 独一无二的出现次数 - 力扣（Leetcode）

注意是数出现的次数不能重复，开始一看到以为是数不能重复，以为这么简单高兴写代码发现过不了，又读了一遍才注意到。同时要注意一下用数组模拟哈希表的时候的下标的对应的问题。

思路

本题强调了-1000 <= arr[i] <= 1000，那么就可以用数组来做哈希，arr[i]作为哈希表（数组）的下标，那么arr[i]可以是负数，怎么办？负数不能做数组下标。

此时可以定义一个2000大小的数组，例如int count[2002];，统计的时候，将arr[i]统一加1000，这样就可以统计arr[i]的出现频率了。

题目中要求的是是否有相同的频率出现，那么需要再定义一个哈希表（数组）用来记录频率是否重复出现过，bool fre[1002]; 定义布尔类型的就可以了，因为题目中强调1 <= arr.length <= 1000，所以哈希表大小为1000就可以了。

如图所示：

在这里插入图片描述

C++代码如下：

class Solution {
public:
    bool uniqueOccurrences(vector<int>& arr) {
        int count[2002] = {0}; // 统计数字出现的频率
        for (int i = 0; i < arr.size(); i++) {
            count[arr[i] + 1000]++;
        }
        bool fre[1002] = {false}; // 看相同频率是否重复出现
        for (int i = 0; i <= 2000; i++) {
            if (count[i]) {
                if (fre[count[i]] == false) fre[count[i]] = true;
                else return false;
            }
        }
        return true;
    }
};

283. 移动零

283. 移动零 - 力扣（Leetcode）

和删除数组的同样的思路，就是加了个把后续不要的部分置0的操作。

思路

双指针法在数组移除元素中，可以达到O(n)的时间复杂度，相当于对整个数组移除元素0，然后slowIndex之后都是移除元素0的冗余元素，把这些元素都赋值为0就可以了。

如动画所示：

在这里插入图片描述

C++代码如下：

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (nums[fastIndex] != 0) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        // 将slowIndex之后的冗余元素赋值为0
        for (int i = slowIndex; i < nums.size(); i++) {
            nums[i] = 0;
        }
    }
};