Funktion - Methode zum Sortieren eines Arrays von Strukturen. Preis 10$ - Seite 8

Neuer Kommentar
 
Georgiy Merts:

Ich persönlich habe mir vor langer Zeit eine Klasse CStructWrapper geschrieben, die von CObject geerbt wurde (CMyObject ist eigentlich dasselbe, mit zusätzlichen Debugging-Feldern), und zum Sortieren verwende ich eine Standardfunktion.

Wenn ich ein Array von Strukturen benötige, deklariere ich eine abgeleitete Klasse, die auf dieser Vorlage basiert. Darin deklariere ich eine Funktion für den Vergleich der notwendigen Felder der Struktur und verwende eine Standardklasse für ein Array von Objekten mit Sortierung.

Erstellte Objekte können mit dem Zuweisungsoperator direkt aus Strukturen kopiert werden. Falls erforderlich, kopiere ich sie.

Leider habe ich nicht so viel Erfahrung mit OOP, dass ich Ihren Code verstehen könnte.

 
Vladimir Pastushak:

Leider bin ich noch nicht gut genug in OOP, um Ihren Code zu verstehen.

Es ist nur eine Klasse, die unsere Struktur enthält.

Und alle Arten von Kopieroperatoren, die es erlauben, das Zuweisungszeichen (=) direkt zwischen dem Objekt und der Struktur zu verwenden.

Wenn ich ein Array von Strukturen benötige, erstelle ich ein Array von solchen Objekten. Jedes dieser Dokumente hat die erforderliche Struktur. Darüber hinaus ist in dieser Klasse eine Vergleichsfunktion definiert, die für die Sortierung und Suche erforderlich ist. Alle, dann werden Standardfunktionen der CArrayObj-Klasse verwendet

 
Vladimir Pastushak:

Leider bin ich noch nicht gut genug in OOP, um Ihren Code zu verstehen.

Nun, implementieren Sie die Methode ohne OOP. Machen Sie sich keine Sorgen, Sie können die "Schnellsortier"-Methode von SB nehmen( es gibt vieleSortieralgorithmen, jemand hat ein Video hochgeladen, in dem verschiedene Algorithmen visualisiert werden, jeder ist in bestimmten Situationen besser, aber dieser ist optimal und wird am häufigsten verwendet) und sie für Ihre Struktur ändern, hier sollten Sie wählen, nach welchem Feld der Struktur Sie mehr oder weniger vergleichen wollen. etwa so (sagen wir, nach einer Zeichenketteyour_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:

Leider bin ich noch nicht gut genug in OOP, um Ihren Code zu verstehen.

Aber zumindest können Sie gut zwischen *** und *** unterscheiden?

 
Vladimir Pastushak:

Leider funktionieren jetzt auch die Methoden, die fxsaber vorgeschlagen hat, nicht mehr.

Und ich bin auf der Suche nach Methoden zum Sortieren einer Reihe von Strukturen. Hat jemand eine funktionierende Variante?

Ich denke, eine solche Umgehung der Sprachbeschränkung würde funktionieren.

#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:

Aber zumindest können Sie gut zwischen *** und *** unterscheiden?

Ich glaube, du verwechselst mich mit jemand anderem...

 
Vladimir Pastushak:

Ich glaube, Sie verwechseln mich mit jemand anderem...

Das ist die Sache: Ich glaube, ich bin es. Aber ich bin es nicht.

 
Dmitry Fedoseev:

Das ist die Sache, es "scheint". Aber ich bin nicht verwirrt.

Was hat es mit dieser "Reibung" auf sich? Was hat das mit dem Thema zu tun?

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

Was ist der Sinn dieser "Reibung"? Was hat das mit diesem Thema zu tun?

Und warum? Gibt es dafür ein eigenes Thema?

 
Aleksey Mavrin:

Nun, implementieren Sie die Methode ohne OOP. Gehen Sie nicht zu weit, nehmen Sie die "Schnellsortiermethode" von SB

fxsaber:

Ich denke, diese Umgehung der Sprachbeschränkung wird ausreichen.

Danke, Freunde!

Ich habe es in mein Loch bekommen.

123456789
Neuer Kommentar