İşlev - Bir dizi yapıyı sıralama yöntemi. Ödül 10$ - sayfa 8

Yeni yorum
 
Georgiy Merts :

Şahsen, uzun zaman önce kendime CObject'den miras alınan bir CStructWrapper sınıfı yazdım (CMyObject aslında ek hata ayıklama alanlarıyla aynı şeydir) ve sıralama için standart bir işlev kullanıyorum.

Bir dizi yapıya ihtiyacınız varsa, bu şablona dayalı bir ardıl sınıf da ilan ediyorum. İçinde yapının gerekli alanlarını karşılaştırmak için bir fonksiyon ilan ediyorum. Ve sonra - Sıralamalı bir dizi nesnenin standart sınıfını kullanıyorum.

Oluşturulan nesneler, atama operatörü kullanılarak yapılardan doğrudan kopyalanabilir. Gerekirse kopyalarım.

Maalesef, kodunuzu anlamak için OOP'de henüz yeterince güçlü değilim.

 
Vladimir Pastushak :

Maalesef, kodunuzu anlamak için OOP'de henüz yeterince güçlü değilim.

Bu sadece bizim yapımızı içinde barındıran bir sınıftır.

Ve doğrudan bir nesne ile bir yapı arasında atama işaretini (=) kullanmanıza izin veren her türlü kopyalama operatörü.

Bir dizi yapı gerektiğinde, bu tür nesnelerden oluşan bir dizi oluştururum. Her biri gerekli yapıya sahiptir. Ayrıca bu sınıf, sıralama ve arama için gerekli olan karşılaştırma fonksiyonunu tanımlar. İşte bu, o zaman CArrayObj sınıfının standart işlevleri kullanılır

 
Vladimir Pastushak :

Maalesef, kodunuzu anlamak için OOP'de henüz yeterince güçlü değilim.

OOP'siz bir yöntemi iyi uygulayın. Uzağa gitmemek için, SB'den "hızlı sıralama" yöntemini alırsınız (birçok sıralama algoritması vardır, biri farklı algoritmaların görselleştirilmesi gibi bir video attı, her biri bazı durumlarda daha iyi, ancak bu en uygun ve en yaygın olarak kullanılır) ve yapınıza uyacak şekilde değiştirin, burada yapının hangi alanını az ya da çok karşılaştıracağınızı seçmeniz gerekir. bunun gibi bir şey (bir satır için your_value için diyelim)

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

Maalesef, kodunuzu anlamak için OOP'de henüz yeterince güçlü değilim.

Ama bunun için *** ile ***'ı ayırt edebiliyor musunuz?

 
Vladimir Pastushak :

Ne yazık ki, şimdi fxsaber'ın önerdiği yöntemler bile çalışmayı durdurdu.

Ve bir dizi yapıyı sıralamak için yöntemler arıyorum. Herhangi bir çalışma seçeneği olan var mı?

Dil kısıtlamasının böyle bir baypas edilmesinin işe yarayacağını düşünüyorum.

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

Ama bunun için *** ile *** arasındaki farkı çok iyi ayırt edebiliyorsun?

İnsanlar gibi ... Bana öyle geliyor ki beni biriyle karıştırıyorsun ...

 
Vladimir Pastushak :

İnsanlar gibi ... Bana öyle geliyor ki beni biriyle karıştırıyorsun ...

Bu sadece "görünüyor" olan nokta. Ama karıştırmıyorum.

 
Dmitry Fedoseev :

Bu sadece "görünüyor" olan nokta. Ama karıştırmıyorum.

Ve bu "rendeler" ne için? Konuyla nasıl bir ilişkisi var?

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

Ve bu "rendeler" ne için? Konuyla nasıl bir ilişkisi var?

Ve ne? Bunun için ayrı bir konu açılsın mı?

 
Aleksey Mavrin :

OOP'siz bir yöntemi iyi uygulayın. Uzağa gitmemek için SB'den "hızlı sıralama" yöntemini alıyorsunuz.

fxsaber :

Dil kısıtlamasının böyle bir baypas edilmesinin işe yarayacağını düşünüyorum.

Teşekkürler arkadaşlar!

Onu deliğine sürükledi.

123456789
Yeni yorum