Leetcode——统计数组中的元素练习

错误的集合

此题没做出来

class Solution {
public:
    vector<int> findErrorNums(vector<int>& nums) {
        vector<int> errorNums(2);
        int n = nums.size();
        sort(nums.begin(), nums.end());
        // 记录上一个元素
        int prev = 0;
        for (int i = 0; i < n; i++) {
            int curr = nums[i];
            if (curr == prev) {
                errorNums[0] = prev;
            }
            else if (curr - prev > 1) {
                errorNums[1] = prev + 1;
            }
            prev = curr;
        }
        // 最后一个元素单独考虑
        if (nums[n - 1] != n) {
            errorNums[1] = n;
        }
        return errorNums;
    }
};

数组的度

此题没做出来（有思路，但不会哈希表）

class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        // 哈希表构造（映射为长度为三的数组）
        unordered_map<int, vector<int>> mp;
        int n = nums.size();
        // 哈希表将数组映射为一个长度为3的数组，分别代表出现次数，第一次出现位置，最后一次出现位置
        for (int i = 0; i < n; i++) {
            // count()函数： 统计某个key值对应的元素个数， 因为unordered_map不允许重复元素，所以返回值为0或1
            if (mp.count(nums[i])) {
                // 如果是重复元素
                mp[nums[i]][0]++;
                // 最后一次出现位置
                mp[nums[i]][2] = i;
            }
            else {
                // 如果不是重复元素
                mp[nums[i]] = { 1, i, i };
            }
        }
        int maxNum = 0, minLen = 0;
        for (auto& [_, vec] : mp) {
            if (maxNum < vec[0]) {
                // 如果元素出现次数大于最大值
                maxNum = vec[0];
                // 求长度
                minLen = vec[2] - vec[1] + 1;
            }
            // 如果存在同样次数的不同元素则要比较最小长度
            else if (maxNum == vec[0]) {
                if (minLen > vec[2] - vec[1] + 1) {
                    minLen = vec[2] - vec[1] + 1;
                }
            }
        }
        return minLen;
    }
};

448. 找到所有数组中消失的数字

class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) {
        // 给定数组长度
        int n = nums.size();
        // 定义动态数组
        vector<int> num;
        // 排序并去重
        sort(nums.begin(), nums.end());
        nums.erase(unique(nums.begin(), nums.end()), nums.end());
        // i取值[1,n]，k遍历数组下标
        int i = 1, k = 0;
        // 思想：已经排序去重数组中依次与[1,n]比较，如元素不能对应则应添加到动态数组中，i++继续比较；
        //       如果元素对应则k++，i++
        while (i <= n) {
            if (nums[k] != i) {
                // 动态数组添加元素
                num.push_back(i);
                i++;
            }
            else {
                k++;
                i++;
            }
        }
        return num;
    }
};

442. 数组中重复的数据

class Solution {
public:
    vector<int> findDuplicates(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<int> n;
        int count = 1;
        // 数组中仅存在重复数为1或2的元素，计数为2就可以加入动态数组n中
        for (int i = 0; i < nums.size() - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                count++;
                if (count == 2) {
                    n.push_back(nums[i]);
                }
            }
            else {
                count = 1;
            }
        }
        return n;
    }
};

41. 缺失的第一个正数

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        // 数组排序去重
        sort(nums.begin(), nums.end());
        nums.erase(unique(nums.begin(), nums.end()), nums.end());
        // 计算去重后数组长度（去重不影响寻找最小缺失正数）
        int len = nums.size();
        // i为正数遍历，k为数组下标遍历
        int i = 1, k = 0;
        // 主体遍历条件：i值小于数组长度len
        while (i <= len) {
            // 当数组存在0或负数时
            while (nums[k] < 1) {
                // 数组下一个元素存在时，k++
                if (k < len - 1) {
                    k++;
                }
                // 数组下一个元素不存在时，停止遍历，此时i值即为最小不存在正数
                else {
                    break;
                }
            }
            // 如果数组元素与i值不对应则结束遍历，此时i值即为最小缺失正数
            if (nums[k] != i) {
                break;
            }
            // 如果数组元素与i值对应
            else {
                // 当数组下一元素存在时k++，i++继续比较
                if (k < len - 1) {
                    k++;
                    i++;
                }
                // 当遍历到数组最后一个元素时，说明数组中存在0或负数，可以结束遍历，i++即为最小缺失正数
                else {
                    i++;
                    break;
                }
            }
        }
        return i;
    }
};

H 指数

class Solution {
public:
    int hIndex(vector<int>& citations) {
        // 数组升序
        sort(citations.begin(), citations.end(), greater<>());
        int h = 0, i = 0;
        while (i<citations.size() && citations[i]>h) {
            i++;
            h++;
        }
        return h;
    }
};