Функция - Метод сортировки массива структур. Приз 10$ - страница 8

Новый комментарий
 
Georgiy Merts:

Лично я написал себе давно уже класс CStructWrapper, пронаследованный от CObject (CMyObject - это, фактически, тоже самое, с дополнительными отладочными полями), и для сортировки использую стандартную функцию.

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

Создаваемые объекты могут напрямую копироваться из структур с помощью оператора присваивания. Если надо - копирую.

К сожалению я еще не настолько силен в ООП что бы понять Ваш код.

 
Vladimir Pastushak:

К сожалению я еще не настолько силен в ООП что бы понять Ваш код.

Это просто класс, который внутри содержит нашу структуру.

И всевозможные операторы копирования, позволяющие использовать знак присваивания (=) напрямую между объектом и структурой.

Когда нужен массив структур - я создаю массив таких объектов. В каждом - есть требуемая структура. Кроме того, в этом классе определяется функция сравнения, необходимая для сортировки и поиска. Все, дальше используется стандартные функции класса CArrayObj

 
Vladimir Pastushak:

К сожалению я еще не настолько силен в ООП что бы понять Ваш код.

Ну реализуй метод без ООП. Чтоб далеко не ходить, берёшь метод "быстрой сортировки" из СБ (алгоритмов сортировки много, кто-то скидывал видео типа  визуализация разных алгоритмов, каждый в какой-то ситуации лучше, но этот - оптимальный и наиболее широко используемый) и меняешь его под свою структуру, тут надо выбрать, по какому полю структуры ты будешь сравнивать больше-меньше. примерно так (допустим по какой-то строке your_value )

//+------------------------------------------------------------------+
//| Method QuickSort                                                 |
//+------------------------------------------------------------------+
void CArrayString::QuickSort(int beg,int end,const int mode)
  {
   int    i,j;
   string p_string;
   string  YOUR_STRUCT t_string;
//--- check
   if(beg<0 || end<0)
      return;
//--- sort
   i=beg;
   j=end;
   while(i<end)
     {
      //--- ">>1" is quick division by 2
      p_string=m_data[(beg+end)>>1].your_value;
      while(i<j)
        {
         while(m_data[i].your_value<p_string)
           {
            //--- control the output of the array bounds
            if(i==m_data_total-1)
               break;
            i++;
           }
         while(m_data[j].your_value>p_string)
           {
            //--- control the output of the array bounds
            if(j==0)
               break;
            j--;
           }
         if(i<=j)
           {
            t_string=m_data[i];
            m_data[i++]=m_data[j];
            m_data[j]=t_string;
            //--- control the output of the array bounds
            if(j==0)
               break;
            j--;
           }
        }
      if(beg<j)
         QuickSort(beg,j);
      beg=i;
      j=end;
     }
  }
 
Vladimir Pastushak:

К сожалению я еще не настолько силен в ООП что бы понять Ваш код.

Но за то вы хорошо умеете отличать *** от ***?

 
Vladimir Pastushak:

К сожалению сейчас даже те методы которые предложил fxsaber перестали работать.

И я ищу методы сортировки массива структур. Есть у кого то рабочие Варианты ?

Думаю, подойдет такой обход ограничения языка.

#property strict

// Сортировка массива структур и указателей на объекты по (под-) полю/методу.
#define ArraySortStruct(T, ARRAY, FIELD)                                         \
{                                                                                \
  class SORT                                                                     \
  {                                                                              \
  private:                                                                       \
    static void Swap( T &Array[], const int i, const int j )                     \
    {                                                                            \
      const T Temp = Array[i];                                                   \
                                                                                 \
      Array[i] = Array[j];                                                       \
      Array[j] = Temp;                                                           \
                                                                                 \
      return;                                                                    \
    }                                                                            \
                                                                                 \
    static int Partition( T &Array[], const int Start, const int End )           \
    {                                                                            \
      int Marker = Start;                                                        \
                                                                                 \          
      for (int i = Start; i <= End; i++)                                         \
        if (Array[i].##FIELD <= Array[End].##FIELD)                              \
        {                                                                        \
          SORT::Swap(Array, i, Marker);                                          \
                                                                                 \
          Marker++;                                                              \
        }                                                                        \
                                                                                 \
       return(Marker - 1);                                                       \
    }                                                                            \
                                                                                 \
    static void QuickSort( T &Array[], const int Start, const int End )          \
    {                                                                            \
      if (Start < End)                                                           \
      {                                                                          \
        const int Pivot = Partition(Array, Start, End);                          \
                                                                                 \
        SORT::QuickSort(Array, Start, Pivot - 1);                                \
        SORT::QuickSort(Array, Pivot + 1, End);                                  \
      }                                                                          \
                                                                                 \
      return;                                                                    \
    }                                                                            \
                                                                                 \
  public:                                                                        \
    static void Sort( T &Array[], int Count = WHOLE_ARRAY, const int Start = 0 ) \
    {                                                                            \
      if (Count == WHOLE_ARRAY)                                                  \
        Count = ::ArraySize(Array);                                              \
                                                                                 \
      SORT::QuickSort(Array, Start, Start + Count - 1);                          \
                                                                                 \
      return;                                                                    \
    }                                                                            \
  };                                                                             \
                                                                                 \
  SORT::Sort(ARRAY);                                                             \
}

void OnStart()
{
  MqlRates Rates[];
  
  CopyRates(_Symbol, PERIOD_CURRENT, 0, 5, Rates); // Взяли бары
  
  Print("\nБары без сортировки - как получили.");
  ArrayPrint(Rates);
  
  Print("\nСортируем по open-цене.");
  ArraySortStruct(MqlRates, Rates, open);
  ArrayPrint(Rates);

  Print("\nСортируем по high-цене.");
  ArraySortStruct(MqlRates, Rates, high);
  ArrayPrint(Rates);

  Print("\nСортируем по времени.");
  ArraySortStruct(MqlRates, Rates, time);
  ArrayPrint(Rates);
}
 
Dmitry Fedoseev:

Но за то вы хорошо умеете отличать *** от ***?

Как и людей...  Мне кажется Вы меня с кем то путаете...

 
Vladimir Pastushak:

Как и людей...  Мне кажется Вы меня с кем то путаете...

В том-то и дело, что "кажется". Но не путаю.

 
Dmitry Fedoseev:

В том-то и дело, что "кажется". Но не путаю.

А к чему вот эти "тёрки"? К теме КАК относится?

 
Сергей Таболин:

А к чему вот эти "тёрки"? К теме КАК относится?

А что? Отдельную тему для этого заводить?

 
Aleksey Mavrin:

Ну реализуй метод без ООП. Чтоб далеко не ходить, берёшь метод "быстрой сортировки" из СБ

fxsaber:

Думаю, подойдет такой обход ограничения языка.

Спасибо, друзья!

Утащил к себе в норку.

123456789
Новый комментарий