Fonction - Méthode pour trier un tableau de structures. Prix 10$. - page 8

Nouveau commentaire
 
Georgiy Merts:

Personnellement, j'ai écrit moi-même il y a longtemps une classe CStructWrapper, héritée de CObject (CMyObject est en fait le même, avec des champs de débogage supplémentaires), et pour le tri j'utilise une fonction standard.

Si j'ai besoin d'un tableau de structures, je déclare une classe dérivée basée sur ce modèle. J'y déclare une fonction permettant de comparer les champs nécessaires de la structure, puis j'utilise une classe standard de tableau d'objets avec tri.

Les objets créés peuvent être copiés directement à partir des structures en utilisant l'opérateur d'affectation. Si nécessaire, je les copie.

Malheureusement, je n'ai pas assez d'expérience en POO pour comprendre votre code.

 
Vladimir Pastushak:

Malheureusement, je ne suis pas encore assez fort en POO pour comprendre votre code.

C'est juste une classe qui contient notre structure à l'intérieur.

Et toutes sortes d'opérateurs de copie, permettant d'utiliser le signe d'affectation (=) directement entre l'objet et la structure.

Lorsque j'ai besoin d'un tableau de structures, je crée un tableau de ces objets. Chacun d'eux possède la structure requise. En outre, une fonction de comparaison est définie dans cette classe, qui est nécessaire pour le tri et la recherche. Tout, alors les fonctions standard de la classe CArrayObj sont utilisées

 
Vladimir Pastushak:

Malheureusement, je ne suis pas encore assez fort en POO pour comprendre votre code.

Eh bien, implémentez la méthode sans OOP. Ne vous inquiétez pas, vous pouvez prendre la méthode de "tri rapide" de SB( il y a beaucoup d'algorithmes de tri, quelqu'un a téléchargé une vidéo comme la visualisation de différents algorithmes, chacun est meilleur dans certaines situations, mais celui-ci est optimal et le plus largement utilisé) et le changer pour votre structure, ici vous devez choisir, par quel champ de la structure vous allez comparer plus ou moins. approximativement ainsi (supposons par une certaine chaînevotre_valeur)

//+------------------------------------------------------------------+
//| 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:

Malheureusement, je ne suis pas encore assez fort en POO pour comprendre votre code.

Mais au moins, tu sais faire la différence entre *** et *** ?

 
Vladimir Pastushak:

Malheureusement, même les méthodes suggérées par fxsaber ne fonctionnent plus.

Et je cherche des méthodes pour trier un tableau de structures. Quelqu'un a-t-il des variantes qui fonctionnent ?

Je pense qu'une telle solution de contournement de la limitation de la langue fonctionnerait.

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

Mais au moins, tu sais faire la différence entre *** et *** ?

Comme les gens... Je pense que vous me confondez avec quelqu'un d'autre...

 
Vladimir Pastushak:

Les gens le font aussi... Je pense que vous me confondez avec quelqu'un d'autre...

C'est ça le truc : je pense que je le suis. Mais je ne le suis pas.

 
Dmitry Fedoseev:

C'est ça le truc, ça "semble". Mais je ne suis pas confus.

C'est quoi cette "friction" ? Qu'est-ce que ça a à voir avec le sujet ?

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

Quel est l'intérêt de toutes ces "frictions" ? Qu'est-ce que cela a à voir avec le sujet ?

Pourquoi ? Y a-t-il un sujet distinct pour cela ?

 
Aleksey Mavrin:

Eh bien, implémentez la méthode sans OOP. N'allez pas trop loin, prenez la méthode de "tri rapide" de SB

fxsaber:

Je pense que cette solution de contournement de la limitation de la langue fera l'affaire.

Merci, mes amis !

Je l'ai mis dans mon trou.

123456789
Nouveau commentaire