一、数组_统计数组中的元素_697.数组的度

题目描述
给定一个非空且只包含非负数的整数数组 nums，数组的度的定义是指数组里任一元素出现频数的最大值。

你的任务是在 nums 中找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。

示例 1：

输入：[1, 2, 2, 3, 1]
输出：2
解释：
输入数组的度是2，因为元素1和2的出现频数最大，均为2.
连续子数组里面拥有相同度的有如下所示:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
最短连续子数组[2, 2]的长度为2，所以返回2.
示例 2：

输入：[1,2,2,3,1,4,2]
输出：6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/degree-of-an-array

hashmap解法
1.这里首先设置一个hashmap表，遍历nums所有的元素，map[num]++即有一个num就加加
2.并且记录最大的度数，再次遍历nums遇到最大度数的就放入set集合中
3.遍历set集合，每次都要遍历完整的nums数组，找到最大度的连续子数组的长度
4.返回最小的长度

int findShortestSubArray(vector<int>& nums) {
    unordered_map<int, int> map;  //map表
    set<int> s;   //集合
    int max_len = 0;    //记录最大度
    int short_len = INT_MAX;   //最短长度

    //遍历nums找到记录每个数出现的频率，并记录最大的频率
    for(int i = 0; i < nums.size(); i++) {
        int num = nums[i];
        map[num]++;

        if(map[num] >= max_len) {
            max_len = map[num];
        }
    }

    //遍历map，需要创建一个正向迭代器
    unordered_map<int, int>::iterator   iter;

    //这里first是key，second是value，遍历map，将所有最大频率取出，放入set中
    for(iter = map.begin(); iter != map.end(); iter++) {
        if(iter->second == max_len) {
            s.insert(iter->first);
        }
    }

    //遍历集合，创建迭代器
    set<int>::iterator it;

    for(it = s.begin(); it != s.end(); it++) {
        int max_num = *it;
        bool flag = true;
        int start_loc = 0;
        int end_loc = -1;

        //遍历set的过程中，找到对应元素，遍历nums，找到起始和结束为止
        //其实位置使用flag来标识，结束位置若不存在，则等于开始位置
        //记录子数组的长度，其实也就是结束位置-起始位置+1
        for(int i = 0; i < nums.size(); i++) {
            if(flag && nums[i] == max_num) {
                start_loc = i;
                flag = false;
            } else if(nums[i] == max_num) {
                end_loc = i;
            }
        }

        if(end_loc == -1) {
            end_loc = start_loc;
        }

        //保留最大度的最短子串的长度
        if(end_loc - start_loc + 1 < short_len) {
            short_len = end_loc - start_loc + 1;
        }
    }

    return short_len;
}

hashmap解法优化
1.题目主要就是统计出现次数最大的元素的起始位置和结束位置
2.但是出现次数最多的元素不止一个，而且要求取最短子数组的哪一个
3.这里存储的时候，使用unordered_map，值存入出现的次数，起始位置，结束位置
4.起始位置当未出现过，自然就是其实位置，在之后的自然就是结束位置
5.遍历map中的每个元素，记录当前最大长度，若是等于最大长度，则记录长度

int findShortestSubArray(vector<int>& nums) {
    unordered_map<int, vector<int>> map;
    int max_num = 1;

    //map和set两种容器的底层结构都是红黑树，所以容器中不会出现相同的元素，因此count()的结果只能为0和1，可以以此来判断键值元素是否存在
    //这里count可能是根据元素的位置，直接查找，所以复杂度是O(1)
    for(int i = 0; i < nums.size(); i++) {
        if(map.count(nums[i])) {    //如果出现过，这里map.count这个函数复杂度应该也不小吧能说是O(n)
            map[nums[i]][0]++; //次数加加
            map[nums[i]][2] = i;  //更新结束位置

            if(map[nums[i]][0] > max_num) {
                max_num = map[nums[i]][0];
            }
        } else {//如果没出现过
            map[nums[i]] = {1, i, i};
        }
    }

    //这里map是一个集合
    unordered_map<int, vector<int>>::iterator   iter;
    int min_len = INT_MAX;

    //遍历map的过程中，如果元素的度等于最大度，那么记录最小长度，并且返回
    for(iter = map.begin(); iter != map.end(); iter++) {
        if(iter->second[0] == max_num) {  //如果当前元素等于最大度的话
            if(iter->second[2] - iter->second[1] + 1 < min_len) {
                min_len = iter->second[2] - iter->second[1] + 1;
            }
        }
    }

    return min_len;
}

int main() {
    vector<int> nums = { 2, 1};
    cout << findShortestSubArray(nums) << endl;
    return 0;
}

//相对于上面代码的一点优化
//这里若是在遍历nums的时候，不记录最大度的话，可以在遍历map的时候，记录最大度
if (maxNum < vec[0]) {
    maxNum = vec[0];
    minLen = vec[2] - vec[1] + 1; //这里每次出现最大度的时候都记录minLen
} else if (maxNum == vec[0]) {   //这里遇到同样最大度的时候，在继续保存这个最小长度
    if (minLen > vec[2] - vec[1] + 1) {
        minLen = vec[2] - vec[1] + 1;
    }
}