海量数据查找重复的数字

1，vector容器中存放了一些数据，在O（n）时间找到第一个重复的数据

#include<iostream>
#include<vector>
#include<iterator>
#include<ctime>
#include<set>
#include<unordered_set>
using namespace std
    
 int main()
{
    vector<int>vec;
    for(int i=0;i<1000;++i)
    {
        vec.push_back(rand()%300);
    }
    unordered_set<int>set1;
    for(int i=0;i<vec.size();++i)
    {
        //if(set1.count(vec[i])==0)
        if(set1.find(vec[i]==set1.end())
        {
            set1.insert(vec[i]);
        }
        else
        {
            cout<<vec[i]<<"重复了！"<<endl;   
            set1.count(vec[i]);
            break;
        }
    }
    return 0;
}        

结果如下：

2，vector容器中存放了一些数据，在O（n）时间找到重复的数据，打印数字和重复次数

#include<iostream>
#include<vector>
#include<iterator>
#include<ctime>
#include<map>
#include<unordered_map>
using namespace std
    
int main()
{
    vector<int>vec;
    for(int i=0;i<1000;i++)
    {
        vec.push_back(rand()%300);
    }
    unordered_map<int,int>map1;
    for(int i=0;i<vec.size();++i)
    {
        //map1[vec[i]]++;
        unordered_map<int,int>::it=map1.find(map1.find(vec.[i]));
        if(it!=map1.end())
        {
            it->second++;
        }
        else
        {
            map1.insert(make_pair(vec[i],1));
        }
    }
    auto it=map1.begin();
    unordered_map<int,int>::iterator it=map1.begin();
    for(;it!=map1.end();++it)
    {
        cout<<it->first<<" "<<it->second<<endl;
    }
    return 0;
}

结果如下：

3，vector容器中存放了一些数据，在O（n）时间找到重复次数最大的三个数据，打印数字和重复次数

#include<iostream>
#include<map>
#include<vector>
#include<iterator>
#include<ctime>
#include<queue>
#include<functional>
#include<unordered_map>
using namespace std

int main()
{
    vector<int>vec;
    for(int i=0;i<1000;++i)
    {
        vec.push_back(rand()%400);
    }
    unordered_map<int,int>map1;
    for(int i=0;i<vec.size();++i)
    {
        //map1[vec[i]]++;
        unordered_map<int,int>::iterator it=map1.find(vec[i]);
        if(it!=map1.end())
        {
            it->second++;
        }
        else
        {
            map1.insert(make_pair(vec[i],1));
        }
    }
    struct Node
    {
        Node(int n=0,int c=0):num(n),count(c){}
        bool operator>(const Node&node)const
        {
            return count>node.count;
        }
        int num;
        int count;
    }
    priority_queue<Node,vector<Node>,greater<Node>>minHeap;
    unordered_map<int,int>::iterator it1=map1.begin();
    for(;it1!=map1.end();it1++)
    {
        if(minHeap.size()<3)
        {
            minHeap.push_back(Node(it1->first,it1->second));
        }
        else
        {
            if(it1->second>minHeap.top().count)
            {
                minHeap.pop();
                minHeap.push(Node(it1->first,it1->second));
            }
        }
    }
    while(!minHeap.empty())
    {
        cout<<minHeap.top().num<<" "<<minHeap.top().count<<endl;
        minHeap.pop();
    }
    return 0;
}

结果为：