Leetcode 秋招冲刺--(专题1-3)

专题1：数组

题目1：两数之和(YES)

• 解题思路：使用哈希表查看target-nums[i]是否存在即可

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

• myself

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //使用哈希表
        unordered_map<int,int>map;

        for(int i=0;i<nums.size();i++)
        {
            //判断哈希表中是否存在
            if(map.find(target - nums[i])!=map.end())
            {
                return {i,map[target-nums[i]]};
            }

            //存数据
            map[nums[i]]=i;
        }
        return {};
    }
};

• 需要注意的点：map.find(nums[i])返回的是迭代器，如何不存在返回map.end()

• 迭代器写法

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //使用哈希表
        unordered_map<int,int>map;

        for(int i=0;i<nums.size();i++)
        {
            //判断哈希表中是否存在
            auto it = map.find(target - nums[i]);
            if(it!=map.end())
            {
                return {i,it->second};
            }

            //存数据
            map[nums[i]]=i;
        }
        return {};
    }
};

题目26：删除有序数组中的重复项(YES)

• 解题思路：双指针，如果nums[right]!=nums[right-1],则将nums[left]=nums[right]

给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。

• myself

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        
        if(nums.size()==1)
        {
            return 1;
        }
        //使用双指针
        int left=0;
        int right=0;
        for(right;right<nums.size();right++)
        {
            if(right==0)
            {
                nums[left++]=nums[right];
            }else
            {
                if(nums[right]!=nums[right-1])
                {
                    //找到不同的
                    nums[left++]=nums[right];
                }
            }
  
        }
        return left;
    }
};

题目27：移除元素(YES)

• 解题思路：双指针，left用来存储正确元素，right用来探路

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
返回 k。

• myself

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int len=nums.size();

        //双指针
        int left=0;
        int right=0;
        for(right;right<nums.size();right++)
        {
            if(nums[right]!=val)
            {
                nums[left++]=nums[right];
            }
        }

        return left;
    }
};

题目35：搜索插入位置(YES)

• 解题思路：过于简单，直接一次for就行

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

• myself

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
            for(int i=0;i<nums.size();i++)
            {
                if(nums[i]==target||nums[i]>target)
                {
                    return i;
                }
            }
            return nums.size();
    }
};

题目66：加一(YES)

• 解题思路：先给最后一位加1，从后面开始判断，如果是10，则当前位置为零，前一位加一，前一位需要进行合法性检测，如何不合法，说明最高位要进位，则需要扩充空间，重新申请一片空间，并将新空间首位置为1，其他位全部赋值过去。

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

• myself

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {

        //从尾到头进行扫描
        int len=digits.size();
        digits[len-1]+=1;
        for(int i=digits.size()-1;i>=0;i--)
        {
            if(digits[i]==10)
            {
                //该位变成0，前一位加一
                digits[i]=0;
                //判断前一位是否合法
                if(i-1<0)
                {
                    //把0号位也置零
                    digits[0]=0;
                    //需要扩充空间
                    vector<int>newDig(len+1);
                    for(int j=0;j<newDig.size();j++)
                    {
                        if(j==0)
                        {
                            newDig[j]=1;
                        }else
                        {
                            newDig[j]=digits[j-1];
                        }

                    }
                    return newDig;
                }

                //前一位合法
                digits[i-1]+=1;
            }
        }

        return digits;
    }
};

题目88：合并两个有序数组(YES)

• 解题思路：这里我开辟了一个新的nums1–new_nums1，然后分别用两个指针扫描new_nums1和nums2，哪个小哪个先插入，如果相等都插入。最后对没插完的数组进行统一插入就行了。

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

• myself

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        //以nums1为主导进行合并

        //赋值一个nums1
        vector<int>new_nums1(m);
        for(int i=0;i<m;i++)
        {
            new_nums1[i]=nums1[i];
        }

        int temp1=0;
        int temp2=0;
        int count=0;
        while(temp1<m&&temp2<n)
        {
            if(new_nums1[temp1]<nums2[temp2])
            {
                //new_nums1小，优先插入
                nums1[count++]=new_nums1[temp1++];
                
            }else if(new_nums1[temp1]==nums2[temp2])
            {
                //相等，两个都要插入
                nums1[count++]=new_nums1[temp1++];
                nums1[count++]=nums2[temp2++];
            }else if(new_nums1[temp1]>nums2[temp2])
            {
                //nums2小优先插入
                nums1[count++]=nums2[temp2++];
            }
        }
        
        //new_nums1没结束全部插入
        while(temp1<m)
        {
            nums1[count++]=new_nums1[temp1++];
        }

        //nums2没结束全部插入
        while(temp2<n)
        {
            nums1[count++]=nums2[temp2++];
        }

    }
};

题目108：将有序数组转换为二叉搜索树（NO）

• 解题思路：使用递归的思想，每次以中间节点nums[(left+right)/2]作为根节点，因为递归每次都能返回一个节点，所以直接root->left，root->right就行。

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡 二叉搜索树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        //一直以中间节点的左边作为根节点
        
        return Change(nums,0,nums.size()-1);
    }

    TreeNode*Change(vector<int>&nums,int left,int right)
    {
        if(left>right)
        {
            return nullptr;
        }

        int mid=(left+right)/2;
        TreeNode*root=new TreeNode(nums[mid]);//创建一个节点
        root->left=Change(nums,left,mid-1);
        root->right=Change(nums,mid+1,right);

        return root;
    }

};

题目118：杨辉三角（NO）

• 解题思路：前两排都是可以直接解决的，从第三排开始需要让ans[i][j]=ans[i-1][j-1]+ans[j-1][j],核心的点就是你只需满足第三行基本就不需要判断下一行了。

给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

class Solution {
public:
    vector<vector<int>> generate(int numRows) {
        vector<vector<int>>ans(numRows);
        for(int i=0;i<numRows;i++)
        {
            ans[i].resize(i+1);//重新设定vector<int>的大小
            ans[i][0]=ans[i][i]=1;//前两排直接节结局了

            for(int j=1;j<i;j++)
            {
                //结局第三行开始的元素
                ans[i][j]=ans[i-1][j-1]+ans[i-1][j];
            }
        }
        return ans;
    }
};

题目119：杨辉三角||（YES）

• 解题思路：直接构建一个杨辉到这行的杨辉三角，返回这个索引就行。

给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

• myself

class Solution {
public:
    vector<int> getRow(int rowIndex) {
        //直接构建一个到这行的杨辉三角返回这一层就行
        vector<vector<int>>ans;
        ans.resize(rowIndex+1);

        for(int i=0;i<rowIndex+1;i++)
        {
            //前两排设置
            ans[i].resize(i+1);
            ans[i][0]=ans[i][i]=1;

            //对第三排开始操作
            for(int j=1;j<i;j++)
            {
                ans[i][j]=ans[i-1][j-1]+ans[i-1][j];
            }
        }

        //构建完毕，直接返回
        return ans[rowIndex];
    }
};

题目121：买卖股票的最佳时机（NO）

• 解题思路：记录前面最小的一个数，然后用后面的数减去这个数

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int inf = 1e9;
        int minprice = inf, maxprofit = 0;
        for (int price: prices) {
            maxprofit = max(maxprofit, price - minprice);
            minprice = min(price, minprice);//一直记录前面最小的数
        }
        return maxprofit;
    }
};

题目136：出现一次的数字（NO)

• 解题思路：异或运算，相同的数字异或结果都为零。

给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ret = 0;
        for (auto e: nums) ret ^= e;
        return ret;
    }
};

题目169：多数元素（NO）

• 解题思路：使用哈希表没有初始化特定的键值时，默认是0的性质，使用其来统计数字出现的次数。

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        //使用哈希表
        unordered_map<int,int>map;
        int len=nums.size()/2;

        for(int i=0;i<nums.size();i++)
        {
            map[nums[i]]++;
            if(map[nums[i]]>len)
            {
                return nums[i];
                
            }
            
        }
        return -1;

    }
};

题目217：存在重复元素（YES）

• 解题思路：运用哈希表可以统计数据出现次数的原理，没初始化特定键值时，默认的键值是0

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

• myself

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        //使用哈希表可以统计数据出现次数的性质
        unordered_map<int,int>map;

        for(int i=0;i<nums.size();i++)
        {
            //没有指定特定的键值，初始值是0
            map[nums[i]]++;
            if(map[nums[i]]>=2)
            {
                return true;
            }
        }
        return false;
    }
};

题目219：存在重复元素||（NO）

• 使用哈希表map.count()可以辨别是否存在，1存在，0不存在。

给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        unordered_map<int, int> dictionary;
        int length = nums.size();
        for (int i = 0; i < length; i++) {
            int num = nums[i];
            if (dictionary.count(num) && i - dictionary[num] <= k) {
                return true;
            }
            dictionary[num] = i;
        }
        return false;
    }
};

专题2：字符串

题目13：罗马数字转整数（NO）

• 解题思路：当前位置的元素比下个位置的元素小，就减去当前值，否则加上当前值

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。

class Solution {
public:

    int romanToInt(string s) {
        //使用哈希表
        unordered_map<char,int>map=
        {
             {'I', 1},
             {'V', 5},
             {'X', 10},
             {'L', 50},
             {'C', 100},
             {'D', 500},
             {'M', 1000}
        };
        int len=s.size();
        int ans=0;

        for(int i=0;i<len;i++)
        {
            int current_value=map[s[i]];
            if(i<len-1&&current_value<map[s[i+1]])
            {
                //当前值小于下一个值，减去当前值
                ans-=current_value;
            }else
            {
                ans+=current_value;
            }
        }

        return ans;

    }
};

题目14：最长公共前缀（YES）

• 解题思路：两层for循环，以第一个元素为比较的基准。这里值得关注的点是string中的每一个strs[i]是一个char类型的

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

• myself

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        string ans="";
        if(strs.size()==1)
        {
            return strs[0];
        }

        for(int i=0;i<strs[0].size();i++)
        {
            char current_char=strs[0][i];
            for(int j=1;j<strs.size();j++)
            {
                if(i>strs[j].size()||strs[j][i]!=current_char)
                {
                    return ans;
                }
            }
            ans+=current_char;
        }
        
        return ans;

    }
};

题目20：有效的括号（YES）

• 解题思路：使用栈，我的做法是再底部留了一个字符确保st.top()能够安全使用。

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
每个右括号都有一个对应的相同类型的左括号。

• myself

class Solution {
public:
    bool isValid(string s) {
        //使用栈

        stack<char>st;
        st.push('a');//放在底部防止st.top()出现异常
        st.push(s[0]);//入栈
        //std::cout<<st.top()<<std::endl;
        for(int i=1;i<s.size();i++)
        {
            std::cout<<s[i]<<std::endl;
            switch(s[i])
            {
                case ')':
                
                if(st.top()=='(')
                {
                    st.pop();//出栈
                }else
                {
                    //入栈
                    st.push(s[i]);
                }
                break;
                case ']':
               if(st.top()=='[')
                {
                    st.pop();//出栈
                }else
                {
                    //入栈
                    st.push(s[i]);
                }
                break;
                case '}':
                if(st.top()=='{')
                {
                    st.pop();//出栈
                }else
                {
                    //入栈
                    st.push(s[i]);
                }
                break;
                default:
                st.push(s[i]);//入栈
                break;
            }
        }

        return st.top()=='a'?true:false;
    }
};

题目28：找出字符串中第一个匹配项下标（YES）

• 解题思路：没什么特别的方法，直接两层for循环

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

• myself

class Solution {
public:
    int strStr(string haystack, string needle) {
        //我记得数据结构专门有一种算法就计算这种

        //暴力解
        if(haystack.size()<needle.size())
        {
            return -1;
        }
        int ans=0;
        for(int i=0;i<haystack.size();i++)
        {   ans=i;
            //从这里开始与needle进行比较
            if(i+needle.size()-1>haystack.size())
            {
                //不满足比较条件了
                break;
            }else
            {
                //满足比较条件
                int count=0;
                for(int j=0;j<needle.size();j++)
                {
                    if(needle[j]!=haystack[i+j])
                    {
                        break;
                    }
                    count++;
                }
                if(count==needle.size())
                {
                    return ans;
                }
            }
        }

        return -1;
    }
};

题目58：最后一个单词的长度（YES）

• 解题思路：从字符串的最后开始入手，只要不是空格就开始统计。

给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。

单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。

• myself

class Solution {
public:
    int lengthOfLastWord(string s) {
        //我直接从字符串的末尾开始入手
        int len=s.size()-1;
        while(s[len]==' ')
        {
            len--;
        }
        //此时就是最后一个单词了
        int count=0;
        while(len>=0&&s[len]!=' ')
        {
            count++;
            len--;
        }
        return count;
    }
};

专题3：排序

题目350：两个数组的交集||（NO）

-解题思路：又是使用了map可以计数的原理先统计一个容器的元素，后面再查看另一个元素的。

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int>map;
        vector<int>ans;

        //先统计一个容器的内容
        for(auto num:nums1)
        {
            map[num]++;
        }

        //开始判别第二个的内容
        for(auto num:nums2)
        {
            if(map[num])
            {
                //能进来这里必然是两者都有的，
                //且用记录次数的方式也能解决一个容器有多个相同元素的问题
                map[num]--;
                ans.push_back(num);
            }
        }
        return ans;

    } 
};

题目506：相对名次（YES）

• 这个题只能舍弃空间，申请一个相同的容器ans用来重新排序分数（降序），此时再使用哈希表依次的排序第一个就是第一名一直往后，然后再用一个string容器返回原来次序的对应名次。

给你一个长度为 n 的整数数组 score ，其中 score[i] 是第 i 位运动员在比赛中的得分。所有得分都 互不相同 。

运动员将根据得分 决定名次 ，其中名次第 1 的运动员得分最高，名次第 2 的运动员得分第 2 高，依此类推。运动员的名次决定了他们的获奖情况：

名次第 1 的运动员获金牌 “Gold Medal” 。
名次第 2 的运动员获银牌 “Silver Medal” 。
名次第 3 的运动员获铜牌 “Bronze Medal” 。
从名次第 4 到第 n 的运动员，只能获得他们的名次编号（即，名次第 x 的运动员获得编号 “x”）。
使用长度为 n 的数组 answer 返回获奖，其中 answer[i] 是第 i 位运动员的获奖情况。

• myself

class Solution {
public:
    vector<string> findRelativeRanks(vector<int>& score) {
        vector<int>ans=score;

        //对ans进行排序，递减排序
        sort(ans.begin(),ans.end(),std::greater<int>());

        //使用哈希表
        unordered_map<int,string>map;
        for(int i=0;i<ans.size();i++)
        {
            if(i==0)
            {
                map[ans[i]]="Gold Medal";
            }else if(i==1)
            {
                map[ans[i]]="Silver Medal";
            }else if(i==2)
            {
                map[ans[i]]="Bronze Medal";
            }else
            {
                map[ans[i]]=std::to_string(i+1);
            }
        }

        //根据原理的顺序给出正确的名次
        vector<string>ret;
        for(int i=0;i<score.size();i++)
        {
            ret.push_back(map[score[i]]);
        }

        return ret;

    }
};

题目594：最长和谐子序列（NO）

• 解题思路：用的还是哈希表map没初始键值默认为零的特性，先对原来每个元素进行统计，后来二次遍历的时候查看比自己大一的元素数量加上自己自己的数量，一直取最大的。相当巧妙的方法。

和谐数组是指一个数组里元素的最大值和最小值之间的差别 正好是 1 。

现在，给你一个整数数组 nums ，请你在所有可能的子序列中找到最长的和谐子序列的长度。

数组的子序列是一个由数组派生出来的序列，它可以通过删除一些元素或不删除元素、且不改变其余元素的顺序而得到。

class Solution {
public:
    int findLHS(vector<int>& nums) {
        //使用哈希表

        //先统计一下自己出现的次数
        unordered_map<int,int>map;//哈希表未指定键值时，初始键值就是零，可以用来计数
        for(int num:nums)
        {
            map[num]++;//此时的value是出现的次数
        }

        //再次查看 一下比自己大一个的出现次的总和哪个最大
        int max_count=0;
        for(int num:nums)
        {
            if(map.count(num+1))
            {
                //如果存在，对比数量,自己的数量加上大一的数量
                max_count=max(max_count,map[num]+map[num+1]);
            }
        }

        return max_count;

    }
};

题目628：三个数的最大乘积（NO）

-解题思路：他这个真的不好想

首先将数组排序。

如果数组中全是非负数，则排序后最大的三个数相乘即为最大乘积；如果全是非正数，则最大的三个数相乘同样也为最大乘积。

如果数组中有正数有负数，则最大乘积既可能是三个最大正数的乘积，也可能是两个最小负数（即绝对值最大）与最大正数的乘积。

综上，我们在给数组排序后，分别求出三个最大正数的乘积，以及两个最小负数与最大正数的乘积，二者之间的最大值即为所求答案。

• 给你一个整型数组 nums ，在数组中找出由三个数组成的最大乘积，并输出这个乘积。

class Solution {
public:
    int maximumProduct(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        return max(nums[0] * nums[1] * nums[n - 1], nums[n - 3] * nums[n - 2] * nums[n - 1]);
    }
};

题目654：错误的集合(YES)

• 解题思路：使用哈希表可以统计数据的性质，先统计一边数据个数，查找重复的数字，第二遍看哪个元素没有。

集合 s 包含从 1 到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个数字复制了成了集合里面的另外一个数字的值，导致集合 丢失了一个数字 并且 有一个数字重复 。

给定一个数组 nums 代表了集合 S 发生错误后的结果。

请你找出重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。

class Solution {
public:
    vector<int> findErrorNums(vector<int>& nums) {
        //就是找到重复的哪个数字，这题不知道是不是递增的

        //使用哈希表
        unordered_map<int,int>map;//使用哈希表可以用来计数的性质
        
        //先统计一下所有的数据
        int copy=0;//记录重复的数据
        for(int num:nums)
        {
            if(map.count(num))
            {
                copy=num;
            }
            map[num]++;
        }

        //检查一下是哪个元素丢失的
        int count_no=0;
        for(int i=1;i<=nums.size();i++)
        {
            if(!map.count(i))
            {
                //不存在
                count_no=i;
            }
        }
        return {copy,count_no};
    }
};