功能 - 对一个结构数组进行排序的方法。奖金10元 - 页 8

新评论
 
Georgiy Merts:

就我个人而言，我在很久以前自己写了一个CStructWrapper类，继承自CObject（CMyObject实际上是一样的，有额外的调试字段），对于排序我使用了一个标准函数。

如果我需要一个结构数组，我就根据这个模板声明一个派生类。在其中，我声明了一个用于比较结构中必要字段的函数。 然后--我使用一个标准的对象数组类，并进行排序。

创建的对象可以使用赋值运算符直接从结构中复制。如果有必要，我就复制它们。

不幸的是，我在OOP方面没有那么多的经验，以至于我无法理解你的代码。

 
Vladimir Pastushak:

不幸的是，我在OOP方面还没有强大到可以理解你的代码。

它只是一个包含我们结构的类。

还有各种各样的复制操作符，允许在对象和结构之间直接使用赋值符号（=）。

当我需要一个结构数组时--我创建一个这样的对象数组。每一个人都有所需的结构。此外，该类中还定义了一个比较函数，这对于排序和搜索是必要的。所有，然后使用CArrayObj类的 标准函数

 
Vladimir Pastushak:

不幸的是，我在OOP方面还没有强大到可以理解你的代码。

那么，在没有OOP的情况下实现这个方法。别担心，你可以采用SB的 "快速排序 "方法（ 有很多排序算法，有人上传了一个视频，类似于不同算法的可视化，在某些情况下每个人都更好，但这个方法是最佳的，也是最广泛使用的），并为你的结构改变它，这里你应该选择，你将通过结构的哪个字段进行多与少的比较，大约是这样的（比如，通过一些字符串our_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:

不幸的是，我在OOP方面还没有强大到可以理解你的代码。

但至少你善于区分***和***？

 
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:

那么，在没有OOP的情况下实现这个方法。不要走得太远，采取SB的 "快速排序 "方法

fxsaber:

我认为这种语言限制的变通方法可以做到。

谢谢你，朋友们!

把它弄到我的洞里。

123456789
新评论