FUNC список возврата <int> с арг (интермедиат Arry [INT], целочисленный массив [INT])

Question

моя проблема:

алгоритм работы я думаю ... но Visual Studio 2013 дает мне эту ошибку:

C2893 неизвестный тип std :: less :: оператор() (_ Ty1 & &, _Ty2 & &) const.

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

list<int> sort_array(int *elenco1[C], int *elenco2[C]) 
{ 
    list<int> merge1; 
    list<int> merge2; 

    for (int i = 0; i < C; ++i) 
    { 
     merge1.push_back(*elenco1[i]); 
    } 

    for (int i = 0; i < C; ++i) 
    { 
     merge2.push_back(*elenco2[i]); 
    } 

    merge1.sort(); 
    merge2.sort(); 

    merge1.merge(merge2); 

    merge1.sort(); 

    list<int>::iterator inizio = merge1.begin(); 
    list<int>::iterator fine = merge1.end(); 

    for (inizio; inizio != fine; ++inizio) 
    { 
     for (fine; fine != inizio; --fine) 
     { 
      if (*fine == *inizio) 
      { 
       merge1.erase(inizio); 
      } 
      else{} 
     } 
    } 

    return merge1; 
} 

int main() 
{ 
    list<int> stampa; 

    int* elenco1[C]; 
    int* elenco2[C]; 

    for (int i = 1; i <= 5; ++i) 
    { 
     for (int k = 0; k < C; ++k) 
     { 
      *elenco1[k] = i; 
     } 
    } 

    for (int i = 5; i <= 9; ++i) 
    { 
     for (int k = 0; k < C; ++k) 
     { 
      *elenco1[k] = i; 
     } 
    } 

    stampa = sort_array(elenco1, elenco2); 

    list<int>::iterator inizio = stampa.begin(); 
    list<int>::iterator fine = stampa.end(); 

    for (inizio; inizio != fine; ++inizio) 
    { 
     cout << *inizio << " "; 
    } 

    cout << endl; 

    getchar(); 
    return 0; 
} 

Answer 1

отлично компилируется здесь также VS 2013 ...

ваш код не будет работать, хотя из-за массивов указателей на INT. Вам нужно массивы междунар не массивы указателей на INT

заменить

int *elenco1[C] 

с

int elenco[C]; 

и падение звездочки в sort_array

Там больше:

for (fine; fine != inizio; --fine) 
{ 
    if (*fine == *inizio) 
    { 
     merge1.erase(inizio); 
    } 
} 

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

inizio = merge1.erase(inizio); 

Answer 2

Если вы не на самом деле установить делать вещи, как трудный путь, как это возможно, использовать некоторые стандартные алгоритмы (и, вероятно, std::vector вместо list). Конкретные алгоритмы, которые вам нужны, - std::sort и std::unique.

Основная идея - создать вектор, содержащий элементы обоих входных векторов. Сортируйте это, затем используйте std::unique, чтобы удалить дубликаты. Код может выглядеть неопределенно так:

#include <vector> 
#include <algorithm> 
#include <iostream> 

std::vector<int> 
merge_sort_unique(std::vector<int> in1, std::vector<int> const &in2) { 
    in1.insert(in1.end(), in2.begin(), in2.end()); 
    std::sort(in1.begin(), in1.end()); 
    in1.erase(std::unique(in1.begin(), in1.end()), in1.end()); 
    return in1; 
} 

А вот быстрый демо с помощью этого:

int main() { 
    std::vector<int> in1{ 5, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 1 }; 
    std::vector<int> in2{ 10, 10, 9, 10, 1, 10, 9, 4, 4, 5, 2, 2, 2, 2, 8, 2, 2, 2 }; 

    std::vector<int> out = merge_sort_unique(in1, in2); 

    for (int i : out) 
     std::cout << i << "\t"; 
} 

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

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

И да, если вы действительно обеспокоены экономии места, даже за счет чуть большей алгоритмической сложности, вы, конечно, может сортировать, а затем удалить дубликаты из каждого входа, а затем объединить и удалить дубликаты снова.Если вы ожидаете, что у вас будет много дубликатов, это может быть даже быстрее - но вам потребуется достаточное количество знаний о входных данных, чтобы быть уверенным, что он был быстрее (или даже «не медленнее»).