Arrays 在有限空间的数组中查找不同值的数目

给定一个非常大的数组，在硬盘上分配={1，1，5，7，8，1，6，10，20，1}，我们需要找出存在多少不同的值。所提到的数组的解是7，7个不同的总数{1，5，6，7，6，10，20}。没有必要保存这些号码

给出了一些提示，我需要在HDD和RAM上工作。但是，HDD比RAM大得多。因此，当所有值都不同时，不可能保存哈希表和链表。根据我的理解，我需要为每个元素分配K个固定大小的常量arraysm元素。之后，我需要填充所有k个数组，对每个数组进行排序。然后比较它们，计算不同的部分，并再次填充它们，直到我完成硬盘上分配的所有值。我的问题是最后一部分，一旦数组被排序，我到底需要做什么

编辑：例如，HDD可能包含10^10条记录，RAM可能只能保存10^5条记录， K=10，M=10。对于处理的每个数组，需要将下一个M值读取到该特定数组

应该只有一个计数器，说明不同值的数量。最大的数字可能是N

---

谢谢

这是我的解决方案。我定义了2个向量，第一个向量表示Hdd数据，另一个向量表示Hdd向量内的偏移量

   #include <iostream>
    #include <fstream>
    #include <vector>
    #include <algorithm>
    #include <stdio.h>
    #include <stdlib.h>
    #include <iterator>
    #include <direct.h>

    #define FILE_NAME "\\data.txt"
    #define ROWS        10
    #define MAX_LINE    100
    #define ARRSIZE(arr) sizeof(arr) / sizeof(arr[0])

    class CPair
    {
    public:
        CPair(__int64 nOffset) : m_llOffset(nOffset), m_llCurOffset(nOffset), m_bChecked(0)
        { }

        __int64 m_llOffset;
        __int64 m_llCurOffset;
        bool    m_bChecked;
    };

    std::vector<long>       vecHDD;
    std::vector<CPair>  vecOffsets;

    long RetrieveValueFromHDD(__int64& i64Offset)
    {
        return vecHDD[(long)i64Offset];
    }

    void FindDistinct()
    {
        // calculate how many fragments within the HDD we've got
        long nFragments = (vecHDD.size() / ROWS);
        long nCount     = 0;

        while(nFragments > 0)
        {
            long nMinimum = INT_MAX;
            for(int i = 0; i < (int)vecOffsets.size(); i++)
            { // find the minimum number
                if((false == vecOffsets[i].m_bChecked) && (RetrieveValueFromHDD(vecOffsets[i].m_llCurOffset) < nMinimum))
                    nMinimum = vecHDD[(int)vecOffsets[i].m_llCurOffset];
            }

            // start changing indices for values equivalent to nMinimum
            for(int i = 0; i < (int)vecOffsets.size(); i++)
            {
                bool bKeepChanging  = true;
                for(int j = 0; j < ROWS && (true == bKeepChanging) && ((vecOffsets[i].m_llCurOffset - vecOffsets[i].m_llOffset) < ROWS); j++)
                {
                    if(RetrieveValueFromHDD(vecOffsets[i].m_llCurOffset) == nMinimum)
                        vecOffsets[i].m_llCurOffset++;
                    else // terminate correct fragment
                        bKeepChanging = false; 
                }

                if  ((vecOffsets[i].m_llCurOffset - vecOffsets[i].m_llOffset) >= ROWS && (false == vecOffsets[i].m_bChecked))
                {
                    vecOffsets[i].m_bChecked = true;
                    nFragments--;
                }
            }

            std::cout << "distinct number:" << nMinimum << '\n';
            nCount++;
        }

        std::cout << "total distinctive numbers: " << nCount;
    }

    void main()
    {
        FILE*       pf;
        std::string str;
        long        nCount          = 0;
        long        arr[ROWS]       = { 0 };
        __int64     i64Offset       = 0;
        char        pDirectoryPath[256 * 2];

        // get current location
        _getcwd(pDirectoryPath, ARRSIZE(pDirectoryPath));
        strcat_s(pDirectoryPath, FILE_NAME);
        fopen_s(&pf, pDirectoryPath, "r");
        if (pf == NULL)
            return;

        std::vector<CPair>      vecPos;
        char                    pLine[MAX_LINE];
        while (0 != fgets(pLine, MAX_LINE, pf))
        {
            arr[nCount] = atoi(pLine);
            nCount++;
            if (nCount == ROWS)
            {
                // create the offset array, save the start of each fragment
                vecOffsets.push_back(CPair(i64Offset));
                std::vector<long> vec(arr, arr + ARRSIZE(arr));
                std::sort(vec.begin(), vec.end());

                // continue creating the HDD array, it will hold sorted fragments.
                vecHDD.insert(vecHDD.end(), vec.begin(), vec.end());
                i64Offset   += nCount;
                nCount      = 0;
            }
        }

        FindDistinct();
        fclose(pf);
    }

---

数字可以任意大吗？可以写回硬盘吗？是否可以进行外部合并排序？如果所有项都可以是不同的，即没有重复项，并且这些项不能全部放入内存，那么如果不将临时信息写入磁盘或其他外部存储器，则无法执行此操作。您的问题的标准答案是使用外部合并排序。您的评论交替地使问题变得非常简单，并且不可能解决。您需要改进您的需求。如前所述，考虑到评论，您的问题没有答案。@JimMischel:这些项不能全部放入内存，那么，如果不将临时信息写入磁盘或其他外部存储器，您就无法做到这一点-这不是真的，您可以通过多次处理1-100、101-200之间的数字，…@JimMischel:字符串只不过是一系列数字。事实上，任何可以序列化的东西都可以被视为一个数字。现在这一次真的需要很长时间