Удаление дубликатов из массива.

 
В массив загоняются данные из файла построчно.
Потом происходит сортировка и т.д. в самом массиве.
Как до сортировки удалить из массива повторяющиеся строки.
Ниже приведу примерт того, что построчно находится в массиве.

3319 602.62 7 0.00 86.09 0.00 0.00
3187 602.62 7 0.00 86.09 0.00 0.00
3165 602.62 7 0.00 86.09 0.00 0.00
3060 602.62 7 0.00 86.09 0.00 0.00
2522 602.62 7 0.00 86.09 0.00 0.00
3903 590.62 6 0.00 98.44 0.00 0.00
3902 590.62 6 0.00 98.44 0.00 0.00
3901 590.62 6 0.00 98.44 0.00 0.00
3900 590.62 6 0.00 98.44 0.00 0.00

после удаления всех повторов должно остаться только

2522 602.62 7 0.00 86.09 0.00 0.00
3903 590.62 6 0.00 98.44 0.00 0.00

С массивами еще плохо разобрался, поэтому прошу помощи.
 
Используйте, что-нить типа:

//+----------------------------------------------------------------------------+
//| Выполняет поиск элемента массива по значению                               |
//| и возвращает индекс найденного элемента или -1                             |
//| Параметры:                                                                 |
//|   m - массив элементов                                                     |
//|   e - значение элемента                                                    |
//+----------------------------------------------------------------------------+
int ArraySearch(int& m[], int e) {
  for (int i=0; i<ArraySize(m); i++) {
    if (m[i]==e) return(i);
  }
  return(-1);
}
Если функция вернула -1, добавляйте новый элемент, иначе - нет.
 

Я так понимаю мне нужно выбрать элемент массива, дальше прошерстить весь массив на схожесть и удалить все схожие элементы.
А как удалить из массива скажем 10, 15, 22, 23 элементы одним махом? Одним наверное не получится, хотябы наверное в цикле.

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

 

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

 
Здравая мысль.

Вопрос к разработчикам, а почему не предусматрели штатную функцию удаления элемента массива?
 
Я не разработчик, но попытаюсь.

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

А как такую целостность сохранить для массива? После удаления элемента придется перетаскивать весь хвост массива, оставшийся после удаляемого элемента, к его голове (на одну позицию), да еще и менять его размер. Крайне затратная операция.

Бывают еще и другие структуры - например, множества. Это такие структуры, в которых порядок элементов неважен. Насколько мне известно, в них операция удаления/добавления элемента тоже не затратная.

Вообще говоря, языку MQL4 далековато до полноценного языка высокого уровня типа Си или Паскаля: мало типов данных, нет возможности создания новых типов и т.п. Претензий к MQ никаких, так как это все же очень специализированный язык - и очень хороший для торгового терминала.

Так что придется тебе собирать новый массив, просматривая исходный. Можешь попробовать отсортировать исходный массив, кстати. Его-то уже потом можно будет обработать за 1 проход. Штатная функция сортировки имеется - ArraySort(). (Кстати, в отличие от массивов, списки сортировать намного сложнее. ..)
 
Лучше сначала отсортировать, а затем удалять дубликаты. Будет работать намного быстрее, т.к. дубликаты будут находиться в соседних ячейках их не нужно будет искать по всему массиву
 
А реализацию с многомерным массивом наподобие того, что предложил KimIV можно сделать.
С простым массивом мне все понятно и достаточно просто, а вот если у меня массив имеет такую структуру

double m[][21];

И допустим в нем данные, и куча переменных

__1_____2___3___4____5_____6___7____8___9___10__11__12__13___14__15___16__17__18___19__20__21_
3319; 602.62; 7; 0.00; 86.09; 0.00; 0.00; 100; 101; 102; 103; 104; 105; 106; 107; 108; 109; 110; 111; 112; 113;
3320; 602.62; 7; 0.00; 86.09; 0.00; 0.00; 101; 101; 102; 103; 104; 105; 106; 107; 108; 109; 110; 111; 112; 113;

понятно что первый элемент уникалиный, номер прогона в оптимизатора, остальные элементы могут меняться
дубликаты хотелось бы убрать по следующим элементам 2,3,4,5,6,7, 8, 9,10,11, остальные элементы массива меня мало интересуют.

//+----------------------------------------------------------------------------+
//| Выполняет поиск элемента массива по значению                               |
//| и возвращает индекс найденного элемента или -1                             |
//| Параметры:                                                                 |
//|   m - массив элементов                                                     |
//|   e - значение элемента                                                    |
//+----------------------------------------------------------------------------+
int ArraySearch(int& m[][ Что писать тут? ], int e) {
  for (int i=0; i<ArraySize(m); i++) {
    if (m[i]==e) return(i);
  }
  return(-1);
}

Может через цикл проверять каждый элемент?

 
HIDDEN писал (а):

Может через цикл проверять каждый элемент?

Зачем? Это будет множество лишних проверок.

Двумерный массив - это таблица. Есть строки и есть столбцы. Один столбец предлагаю сделать ключевым и по нему искать дубликаты перебором строк. Пусть первое измерение Вашего массива - это строки, а второе - столбцы. Тогда функция ArraySearch() примет следующий вид:

//+----------------------------------------------------------------------------+
//| Выполняет поиск элемента массива по значению                               |
//| и возвращает индекс найденного элемента или -1                             |
//| Параметры:                                                                 |
//|   m - массив элементов                                                     |
//|   e - значение элемента                                                    |
//+----------------------------------------------------------------------------+
int ArraySearch(int& m[][], int e) {
  for (int i=0; i<ArrayRange(m, 0); i++) {
    if (m[i][0]==e) return(i);
  }
  return(-1);
}
 
Дополню по ключевому столбцу...

Значения этого столбца можно формировать комбинируя значения нужных Вам столбцов массива 2,3,4,5,6,7,8,9,10,11, то есть тех, столбцов, по которым Вы хотели бы устранять дубликаты. Алгоритм формирования ключа придумайте сами. Он должен быть адекватным Вашим потребностям.
 
Если брать конкретно мой случай то получается следующее
//+----------------------------------------------------------------------------+
//| Выполняет поиск элемента массива по значению                               |
//| и возвращает индекс найденного элемента или -1                             |
//| Параметры:                                                                 |
//|   m - массив элементов                                                     |
//|   a,b,c,d,e,f,g,h,x,y - значение элемента                                  |
//+----------------------------------------------------------------------------+
int ArraySearch(int& m[][], double a, double b, double c, double d, double e, double f, double g, double h, double x, double y) {
  for (int i=0; i<ArrayRange(m, 0); i++) {
    if (m[i][1]==a && m[i][2]==b && m[i][3]==c && m[i][4]==d && m[i][5]==e && m[i][6]==f && m[i][7]==g && m[i][8]==h && m[i][9]==x && m[i][10]==y) return(i);
  }
  return(-1);
}


если я все правильно понял.

Причина обращения: