скажем, у вас есть коллекция элементов, как вы можете выбрать те, с дубликатами и поместить их в каждую группу с наименьшим количеством сравнения? предпочтительно на C++, но алгоритм важнее языка. например учитывая {E1,E2,E3,E4,E4,E2,E6,E4, E3}, я хочу извлечь {E2, E2}, {E3, E3}, {E4,E4, E4}. какую структуру данных и алгоритм вы выберете? Пожалуйста, также включите стоимость настройки структуры данных, скажем, если она предварительно отсортирована, как std:: multimap

обновления

чтобы сделать вещи яснее, как было предложено. есть одно ограничение: элементы должны сравниваться сами по себе чтобы быть уверенным, что они дубликаты.

поэтому хэши не применяются, потому что фактически они смещают сравнение с тяжелых элементов (например, куски данных) на легкие элементы (целые числа) и уменьшают некоторое сравнение, но не избавляются от них, и в конце концов мы возвращаемся к нашей первоначальной проблеме, когда внутри одно ведро столкновения.

представьте, что у вас есть куча потенциалов, дублирующих файлы GBs каждый, они несут одно и то же значение хэша каждым хэш-алгоритмом, который знают люди. Теперь вы обнаружите настоящие дубликаты.

нет, это не может быть реальной проблемой(даже MD5 достаточно для создания уникального хэша для реальных файлов). Но только притворись, что мы можем!--9-->сосредоточиться на поиске структуры данных алгоритм+, который включает в себя наименьшее количество сравнение.

что я делаю это

1. представляют в структуру данных STL std::list(в том, что 1) его элемент-удаление дешевле, чем, скажем, вектор 2) его вставка дешевле, не требуя сортировки.)

2. выскочить один элемент и сравнить его с остальными, если найден дубликат, он вытащил из списка. по достижении конца списка обнаруживается одна группа дублирования, если любой.

3. повторите описанные выше 2 шага, пока список не опустеет.

в лучшем случае требуется N-1, но (N-1)! в худшем случае.

каковы лучшие альтернативы?

мой код с использованием метода, описанного выше:

// algorithm to consume the std::list container,
// supports: list<path_type>,list< pair<std::string, paths_type::const_iterater>>
template<class T>
struct consume_list
{
    groups_type operator()(list<T>& l)
    {
        // remove spurious identicals and group the rest
        // algorithm:  
        // 1. compare the first element with the remaining elements, 
        //    pick out all duplicated files including the first element itself.
        // 2. start over again with the shrinked list
        //     until the list contains one or zero elements.

        groups_type sub_groups;           
        group_type one_group; 
        one_group.reserve(1024);

        while(l.size() > 1)
        {
            T front(l.front());
            l.pop_front();

            item_predicate<T> ep(front);
            list<T>::iterator it     = l.begin(); 
            list<T>::iterator it_end = l.end();
            while(it != it_end)
            {
                if(ep.equals(*it))
                {
                    one_group.push_back(ep.extract_path(*(it))); // single it out
                    it = l.erase(it);
                }
                else
                {
                    it++;
                }
            }

            // save results
            if(!one_group.empty())
            {
                // save
                one_group.push_back(ep.extract_path(front));                    
                sub_groups.push_back(one_group);

                // clear, memory allocation not freed
                one_group.clear(); 
            }            
        }
        return sub_groups;
    }        
}; 


// type for item-item comparison within a stl container, e.g.  std::list 
template <class T>
struct item_predicate{};

// specialization for type path_type      
template <>
struct item_predicate<path_type>
{
public:
    item_predicate(const path_type& base)/*init list*/            
    {}
public:
    bool equals(const path_type& comparee)
    {
        bool  result;
        /* time-consuming operations here*/
        return result;
    }

    const path_type& extract_path(const path_type& p)
    {
        return p;
    }
private:
    // class members
}; 


};

Спасибо за ответ ниже, однако они, похоже, введены в заблуждение моим примером, что речь идет о целых числах. На самом деле элементы типа agnostic(не обязательно целые числа, строки или любые другие стручки), и равные предикаты являются самоопределяющимися, то есть сравнение может быть очень тяжелым.

поэтому, возможно, мой вопрос должен быть: использование какой структуры данных + алгоритм включает в себя меньше сравнений.

используя предварительно отсортированный контейнер, такой как multiset, multimap не лучше в соответствии с моим тестом, так как

1. сортировка при вставке уже делает сравнения,
2. следующая смежная находка снова выполняет сравнение,
3. эти структуры данных предпочитают операции меньше, чем равные операции, они выполняют 2 меньше, чем (a

Я не вижу, как он может сохранить сравнения.

еще одна вещь, которая игнорируется некоторыми ответами ниже, мне нужно отличать дубликаты групп друг от друга, а не просто держать их в контейнере.

вывод

после всего обсуждения, кажется, есть 3 способа

1. мой оригинальный наивный метод, как описано выше
2. начните с линейного контейнера, такого как std::vector , отсортировать его, а затем найдите равные диапазоны
3. начните с связанного контейнера, такого как std::map<Type, vector<duplicates>>, выберите дубликаты во время установки связанного контейнера, как предложил Чарльз Бейли.

я закодировал образец для проверьте все методы, как опубликовано ниже.

количество дубликатов и когда они распределены могут повлиять на лучший выбор.

• метод 1 лучше всего, когда они сильно падают спереди, и хуже всего, когда в конце. Сортировка не изменит распределение, но endian.
• Метод 3 имеет самую среднюю производительность
• Способ 2 не лучший выбор

спасибо всем, кто участвует в обсуждение.

один выход с 20 деталями образца от кода ниже.

тест с [ 20 10 6 5 4 3 2 2 2 2 1 1 1 1 1 1 1 1 1 1 ]

и [ 1 1 1 1 1 1 1 1 1 1 2 2 2 2 3 4 5 6 10 20 ] соответственно

использование std:: vector - > sort () - > adjacent_find ():

сравнения: [ '

сравнения: [ '

использование std:: список - > сортировка() -> уменьшаться список:

сравнения: [ '

сравнения: [ '

использование std:: list - > shrink list:

сравнения: [ '

сравнения: [ '

использование std:: vector - > std:: map>:

сравнения: [ '

сравнения: [ '

использование std:: vector - > std:: multiset - > adjacent_find ():

сравнения: [ '

сравнения: [ '

код

// compile with VC++10: cl.exe /EHsc

#include <vector>
#include <deque>
#include <list>
#include <map>
#include <set>
#include <algorithm>
#include <iostream>
#include <sstream>

#include <boost/foreach.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/format.hpp>

using namespace std;

struct Type
{
    Type(int i) : m_i(i){}

    bool operator<(const Type& t) const
    {
        ++number_less_than_comparison;
        return m_i < t.m_i;
    }

    bool operator==(const Type& t) const
    {
        ++number_equal_comparison;    
        return m_i == t.m_i;
    }
public:
    static void log(const string& operation)
    {
        cout 
        << "comparison during " <<operation << ": [ "
        << "'<'  = " << number_less_than_comparison
        << ", "
        << "'==' = " << number_equal_comparison
        << " ]n";

        reset();
    }

    int to_int() const
    {
        return m_i;
    }
private:
    static void reset()
    {
        number_less_than_comparison = 0;
        number_equal_comparison = 0;      
    }

public:
    static size_t number_less_than_comparison;
    static size_t number_equal_comparison;    
private:
    int m_i;
};

size_t Type::number_less_than_comparison = 0;
size_t Type::number_equal_comparison = 0;  

ostream& operator<<(ostream& os, const Type& t) 
{
    os << t.to_int();
    return os;
}

template< class Container >
struct Test
{    
    void recursive_run(size_t n)
    { 
        bool reserve_order = false;

        for(size_t i = 48; i < n; ++i)
        {
            run(i);
        }    
    }

    void run(size_t i)
    {
        cout << 
        boost::format("nnTest %1% sample elementsnusing method%2%:n") 
        % i 
        % Description();

        generate_sample(i);
        sort();
        locate();   

        generate_reverse_sample(i);
        sort();
        locate(); 
    }

private:    
    void print_me(const string& when)
    {
        std::stringstream ss;
        ss << when <<" = [ ";
        BOOST_FOREACH(const Container::value_type& v, m_container)
        {
            ss << v << " ";
        }
        ss << "]n";    
        cout << ss.str();
    }

    void generate_sample(size_t n)
    {
        m_container.clear();
        for(size_t i = 1; i <= n; ++i)
        {
            m_container.push_back(Type(n/i));    
        }
        print_me("init value");
        Type::log("setup");
    }

    void generate_reverse_sample(size_t n)
    {
        m_container.clear();
        for(size_t i = 0; i < n; ++i)
        {
            m_container.push_back(Type(n/(n-i)));     
        }
        print_me("init value(reverse order)");
        Type::log("setup");
    }    

    void sort()
    {    
        sort_it();

        Type::log("sort");
        print_me("after sort");

    }

    void locate()
    {
        locate_duplicates();

        Type::log("locate duplicate");
    }
protected:
    virtual string Description() = 0;
    virtual void sort_it() = 0;
    virtual void locate_duplicates() = 0;
protected:
    Container m_container;    
};

struct Vector : Test<vector<Type> >
{    
    string Description()
    {
        return "std::vector<Type> -> sort() -> adjacent_find()";
    } 

private:           
    void sort_it()
    {    
        std::sort(m_container.begin(), m_container.end()); 
    }

    void locate_duplicates()
    {
        using std::adjacent_find;
        typedef vector<Type>::iterator ITR;
        typedef vector<Type>::value_type  VALUE;

        typedef boost::tuple<VALUE, ITR, ITR> TUPLE;
        typedef vector<TUPLE> V_TUPLE;

        V_TUPLE results;

        ITR itr_begin(m_container.begin());
        ITR itr_end(m_container.end());       
        ITR itr(m_container.begin()); 
        ITR itr_range_begin(m_container.begin());  

        while(itr_begin != itr_end)
        {     
            // find  the start of one equal reange
            itr = adjacent_find(
            itr_begin, 
            itr_end, 
                []  (VALUE& v1, VALUE& v2)
                {
                    return v1 == v2;
                }
            );
            if(itr_end == itr) break; // end of container

            // find  the end of one equal reange
            VALUE start = *itr; 
            while(itr != itr_end)
            {
                if(!(*itr == start)) break;                
                itr++;
            }

            results.push_back(TUPLE(start, itr_range_begin, itr));

            // prepare for next iteration
            itr_begin = itr;
        }  
    }
};

struct List : Test<list<Type> >
{
    List(bool sorted) : m_sorted(sorted){}

    string Description()
    {
        return m_sorted ? "std::list -> sort() -> shrink list" : "std::list -> shrink list";
    }
private:    
    void sort_it()
    {
        if(m_sorted) m_container.sort();////std::sort(m_container.begin(), m_container.end()); 
    }

    void locate_duplicates()
    {       
        typedef list<Type>::value_type VALUE;
        typedef list<Type>::iterator ITR;

        typedef vector<VALUE>  GROUP;
        typedef vector<GROUP>  GROUPS;

        GROUPS sub_groups;
        GROUP one_group; 

        while(m_container.size() > 1)
        {
            VALUE front(m_container.front());
            m_container.pop_front();

            ITR it     = m_container.begin(); 
            ITR it_end = m_container.end();
            while(it != it_end)
            {
                if(front == (*it))
                {
                    one_group.push_back(*it); // single it out
                    it = m_container.erase(it); // shrink list by one
                }
                else
                {
                    it++;
                }
            }

            // save results
            if(!one_group.empty())
            {
                // save
                one_group.push_back(front);                    
                sub_groups.push_back(one_group);

                // clear, memory allocation not freed
                one_group.clear(); 
            }            
        }
    }        

private:
    bool m_sorted;
};

struct Map : Test<vector<Type>>
{    
    string Description()
    {
        return "std::vector -> std::map<Type, vector<Type>>" ;
    }
private:    
    void sort_it() {}

    void locate_duplicates()
    {
        typedef map<Type, vector<Type> > MAP;
        typedef MAP::iterator ITR;

        MAP local_map;

        BOOST_FOREACH(const vector<Type>::value_type& v, m_container)
        {
            pair<ITR, bool> mit; 
            mit = local_map.insert(make_pair(v, vector<Type>(1, v)));   
            if(!mit.second) (mit.first->second).push_back(v); 
         }

        ITR itr(local_map.begin());
        while(itr != local_map.end())
        {
            if(itr->second.empty()) local_map.erase(itr);

            itr++;
        }
    }        
};

struct Multiset :  Test<vector<Type>>
{
    string Description()
    {
        return "std::vector -> std::multiset<Type> -> adjacent_find()" ;
    }
private:
    void sort_it() {}

    void locate_duplicates()
    {   
        using std::adjacent_find;

        typedef set<Type> SET;
        typedef SET::iterator ITR;
        typedef SET::value_type  VALUE;

        typedef boost::tuple<VALUE, ITR, ITR> TUPLE;
        typedef vector<TUPLE> V_TUPLE;

        V_TUPLE results;

        SET local_set;
        BOOST_FOREACH(const vector<Type>::value_type& v, m_container)
        {
            local_set.insert(v);
        }

        ITR itr_begin(local_set.begin());
        ITR itr_end(local_set.end());       
        ITR itr(local_set.begin()); 
        ITR itr_range_begin(local_set.begin());  

        while(itr_begin != itr_end)
        {     
            // find  the start of one equal reange
            itr = adjacent_find(
            itr_begin, 
            itr_end, 
            []  (VALUE& v1, VALUE& v2)
                {
                    return v1 == v2;
                }
            );
            if(itr_end == itr) break; // end of container

            // find  the end of one equal reange
            VALUE start = *itr; 
            while(itr != itr_end)
            {
                if(!(*itr == start)) break;                
                itr++;
            }

            results.push_back(TUPLE(start, itr_range_begin, itr));

            // prepare for next iteration
            itr_begin = itr;
        }  
    } 
};

int main()
{
    size_t N = 20;

    Vector().run(20);
    List(true).run(20);
    List(false).run(20);
    Map().run(20);
    Multiset().run(20);
}