Função - Método para ordenar uma série de estruturas. Prêmio 10$ - página 8

Novo comentário
 
Georgiy Merts:

Pessoalmente, eu mesmo escrevi há muito tempo uma classe CStructWrapper, herdada do CObject (CMyObject é realmente a mesma, com campos de depuração adicionais), e para a classificação eu uso uma função padrão.

Se eu precisar de um conjunto de estruturas, declaro uma classe derivada com base neste modelo. Nele, declaro uma função para comparar os campos necessários da estrutura. E então - uso uma classe padrão de uma série de objetos com ordenação.

Os objetos criados podem ser copiados diretamente das estruturas utilizando o operador de atribuição. Se necessário, eu os copio.

Infelizmente, não tenho tanta experiência em OOP que pudesse entender seu código.

 
Vladimir Pastushak:

Infelizmente, ainda não sou suficientemente forte no OOP para entender seu código.

É apenas uma classe que contém nossa estrutura interna.

E todos os tipos de operadores de cópia, permitindo usar o sinal de atribuição (=) diretamente entre o objeto e a estrutura.

Quando eu preciso de uma série de estruturas - eu crio uma série de tais objetos. Cada um deles tem a estrutura necessária. Além disso, uma função de comparação é definida nesta classe, que é necessária para a classificação e a busca. Todas as funções padrão da classe CArrayObj são utilizadas

 
Vladimir Pastushak:

Infelizmente, ainda não sou suficientemente forte no OOP para entender seu código.

Bem, implemente o método sem o OOP. Não se preocupe, você pode pegar o método de "classificação rápida" da SB( há muitosalgoritmos de classificação, alguém carregou um vídeo como visualização de diferentes algoritmos, todos são melhores em alguma situação, mas este é ótimo e mais amplamente utilizado) e mudá-lo para sua estrutura, aqui você deve escolher, por qual campo de estrutura você irá comparar mais ou menos. aproximadamente assim (suponha por alguma stringseu_valor)

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

Infelizmente, ainda não sou forte o suficiente no OOP para entender seu código.

Mas ao menos você é bom em distinguir *** de ***?

 
Vladimir Pastushak:

Infelizmente agora até mesmo os métodos que a fxsaber sugeriu não funcionam mais.

E estou procurando métodos de ordenação de uma série de estruturas. Alguém tem alguma variante de trabalho?

Acho que uma tal solução para a limitação da linguagem funcionaria.

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

Mas ao menos você é bom em distinguir *** de ***?

Assim como as pessoas... Acho que você me confundiu com outra pessoa...

 
Vladimir Pastushak:

As pessoas também... Acho que me confundiram com outra pessoa...

O problema é esse: eu acho que sou. Mas eu não sou.

 
Dmitry Fedoseev:

Aí é que está, "parece". Mas eu não estou confuso.

De que se trata todo esse "atrito"? O que isso tem a ver com o assunto?

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

Qual é o objetivo deste "atrito"? O que isso tem a ver com o assunto?

Por quê? Existe um tópico separado para isso?

 
Aleksey Mavrin:

Bem, implemente o método sem o OOP. Não vá muito longe, pegue o método "quick sort" da SB

fxsaber:

Acho que esta solução para a limitação da linguagem será suficiente.

Obrigado, amigos!

Coloquei-o no meu buraco.

123456789
Novo comentário