-mql5_scripts/sSortTest - script for MetaTrader 5/ssorttest.mq5

//+------------------------------------------------------------------+
//|                                                    sSortTest.mq5 |
//|                                                          Integer |
//|                          https://login.mql5.com/en/users/Integer |
//+------------------------------------------------------------------+
#property copyright "Integer"
#property link      "https://login.mql5.com/en/users/Integer"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   Alert("Start");

   int Size=10000;
   double x0[];
   double x1[];
   ArrayResize(x0,Size);
   ArrayResize(x1,Size);

   long start;
   long t,t1=0,t2=0,t3=0,t4=0,t5=0,t6=0;

   int Rounds=30;

   for(int j=0;j<Rounds;j++)
     {

      Alert("==> Pass "+IntegerToString(j+1));

      for(int i=0;i<Size;i++)
        {
         x0[i]=MathRand();
        }

      ArrayCopy(x1,x0);
      start=GetTickCount();
      SortBubbleUp(x1);
      t=GetTickCount()-start;
      t1+=t;
      Alert("Bubble: "+IntegerToString(t));
      Check(x1);

      ArrayCopy(x1,x0);
      start=GetTickCount();
      SortSelectUp(x1);
      t=GetTickCount()-start;
      t2+=t;
      Alert("Select: "+IntegerToString(t));
      Check(x1);

      ArrayCopy(x1,x0);
      start=GetTickCount();
      SortInsertUp(x1);
      t=GetTickCount()-start;
      t3+=t;
      Alert("Insert: "+IntegerToString(t));
      Check(x1);

      ArrayCopy(x1,x0);
      start=GetTickCount();
      SortShellUp(x1);
      t=GetTickCount()-start;
      t4+=t;
      Alert("Shell: "+IntegerToString(t));
      Check(x1);

      ArrayCopy(x1,x0);
      start=GetTickCount();
      SortHoareUp(x1);
      t=GetTickCount()-start;
      t5+=t;
      Alert("Hoare: "+IntegerToString(t));
      Check(x1);

      ArrayCopy(x1,x0);
      start=GetTickCount();
      SortSelectUpFst(x1);
      t=GetTickCount()-start;
      t6+=t;
      Alert("SelectFst: "+IntegerToString(t));
      Check(x1);
     }

   Alert("==> Average:");
   Alert("Bubble: "+IntegerToString(t1/Rounds));
   Alert("Select: "+IntegerToString(t2/Rounds));
   Alert("Insert: "+IntegerToString(t3/Rounds));
   Alert("Shell: "+IntegerToString(t4/Rounds));
   Alert("Hoare: "+IntegerToString(t5/Rounds));
   Alert("SelectFst: "+IntegerToString(t6/Rounds));

   Alert("Finish");
  }
//+------------------------------------------------------------------+
//| Checks if array is alrady sorted (ascending)                     |
//+------------------------------------------------------------------+
void Check(double  &aAr[])
  {
   for(int i=ArraySize(aAr)-1;i>0;i--)
     {
      if(aAr[i]<aAr[i-1])
        {
         Alert("Error");
         return;
        }
     }
  }
//+------------------------------------------------------------------+
//| ArrayAlertR                                                      |
//| Prints array as line                                             |
//+------------------------------------------------------------------+
void ArrayAlertR(double  &aAr[],int aDigits=0,string aHeader="")
  {
   int Len=ArraySize(aAr);
   string str=aHeader+": ";
   for(int i=0;i<Len;i++)
     {
      str=str+DoubleToString(aAr[i],aDigits)+", ";
     }
   Alert(str);
  }
//+------------------------------------------------------------------+
//| ArrayAlertC                                                      |
//| Prints array as column                                           |
//+------------------------------------------------------------------+
void ArrayAlertC(double  &aAr[],int aDigits=0,string aHeader="")
  {
   int Len=ArraySize(aAr);
   Alert("=== "+aHeader+" ===");
   for(int i=0;i<Len;i++)
     {
      Alert(IntegerToString(i)+": "+DoubleToString(aAr[i],aDigits));
     }
  }
//+------------------------------------------------------------------+
//| SortHoareUp                                                      |
//+------------------------------------------------------------------+
void SortHoareUp(double  &aAr[])
  {
   HoareUp(aAr,0,ArraySize(aAr)-1);
  }
//+------------------------------------------------------------------+
//| HoareUp                                                          |
//| Auxiliary function for Hoare sort                                |
//+------------------------------------------------------------------+
void HoareUp(double  &aAr[],int aLeft,int aRight)
  {
   double tmp;
   int i=aLeft;
   int j=aRight;
   double xx=aAr[(aLeft+aRight)/2];
   do
     {
   while(i<aRight && aAr[i]<xx)i++;
   while(j>aLeft && xx<aAr[j])j--;
   if(i<=j)
     {
      tmp=aAr[i];
      aAr[i]=aAr[j];
      aAr[j]=tmp;
      i++;
      j--;
     }
  }
while(i<=j);
if(aLeft<j)HoareUp(aAr,aLeft,j);
if(i<aRight)HoareUp(aAr,i,aRight);
}
//+------------------------------------------------------------------+
//| SortHoareDn                                                      |
//+------------------------------------------------------------------+
void SortHoareDn(double  &aAr[])
{
   HoareDn(aAr,0,ArraySize(aAr)-1);
}
//+------------------------------------------------------------------+
//| HoareDn                                                          |
//| Auxiliary function for Hoare sort                                |
//+------------------------------------------------------------------+
void HoareDn(double  &aAr[],int aLeft,int aRight)
{
   double tmp;
   int i=aLeft;
   int j=aRight;
   double xx=aAr[(aLeft+aRight)/2];
      do
      {
         while(i<aRight && aAr[i]>xx)i++;
         while(j>aLeft && xx>aAr[j])j--;
            if(i<=j)
            {
               tmp=aAr[i];
               aAr[i]=aAr[j];
               aAr[j]=tmp;
               i++;
               j--;
            }
      }
      while(i<=j);
      if(aLeft<j)HoareDn(aAr,aLeft,j);
      if(i<aRight)HoareDn(aAr,i,aRight);
}
//+------------------------------------------------------------------+
//| SortShellUp                                                      |
//+------------------------------------------------------------------+
void SortShellUp(double  &aAr[])
{
   double tmp;
   int n[]={9,5,3,2,1};
   int i,j,k,g;
   int Len=ArraySize(aAr);
   for(k=0;k<5;k++)
   {
         g=n[k];
            for(i=g;i<Len;i++)
            {
               tmp=aAr[i];
                  for(j=i-g;j>=0 && tmp<aAr[j];j-=g)
                  {
                     aAr[j+g]=aAr[j];
                  }
               aAr[j+g]=tmp;
             }
      }
}
//+------------------------------------------------------------------+
//| SortShellDn                                                      |
//+------------------------------------------------------------------+
void SortShellDn(double  &aAr[])
{
   double tmp;
   int n[]={9,5,3,2,1};
   int i,j,k,g;
   int Len=ArraySize(aAr);
      for(k=0;k<5;k++)
      {
         g=n[k];
            for(i=g;i<Len;i++)
            {
               tmp=aAr[i];
                  for(j=i-g;j>=0 && tmp>aAr[j];j-=g)
                  {
                     aAr[j+g]=aAr[j];
                  }
               aAr[j+g]=tmp;
            }
      }
}
//+------------------------------------------------------------------+
//| SortInsertUp                                                     |
//+------------------------------------------------------------------+
void SortInsertUp(double  &aAr[])
{
   double tmp;
   int i,j,Len=ArraySize(aAr);
   for(i=1;i<Len;i++)
   {
      tmp=aAr[i];
         for(j=i-1;j>=0 && tmp<aAr[j];j--)
         {
            aAr[j+1]=aAr[j];
            aAr[j]=tmp;
         }
   }
}
//+------------------------------------------------------------------+
//| SortInsertDn                                                     |
//+------------------------------------------------------------------+
void SortInsertDn(double  &aAr[])
{
   double tmp;
   int i,j,Len=ArraySize(aAr);
   for(i=1;i<Len;i++)
   {
      tmp=aAr[i];
         for(j=i-1;j>=0 && tmp>aAr[j];j--)
         {
            aAr[j+1]=aAr[j];
            aAr[j]=tmp;
         }
   }
}
//+------------------------------------------------------------------+
//| SortSelectUp                                                     |
//+------------------------------------------------------------------+
void SortSelectUp(double  &aAr[])
{
   double tmp;
   int i,j,k;
   int Len=ArraySize(aAr);
   int Len1=Len-1;
      for(i=0;i<Len1;i++)
      {
         tmp=aAr[i];
         k=i;
            for(j=i+1;j<Len;j++)
            {
               if(aAr[j]<tmp)
               {
                  k=j;
                  tmp=aAr[j];
               }
            }
         aAr[k]=aAr[i];
         aAr[i]=tmp;
      }
}
//+------------------------------------------------------------------+
//| SortSelectDn                                                     |
//+------------------------------------------------------------------+
void SortSelectDn(double  &aAr[])
{
   double tmp;
   int i,j,k;
   int Len=ArraySize(aAr);
   int Len1=Len-1;
      for(i=0;i<Len1;i++)
      {
         tmp=aAr[i];
         k=i;
            for(j=i+1;j<Len;j++)
            {
               if(aAr[j]>tmp)
               {
                  k=j;
                  tmp=aAr[j];
               }
            }
         aAr[k]=aAr[i];
         aAr[i]=tmp;
      }
}
//+------------------------------------------------------------------+
//| SortBubbleUp                                                     |
//+------------------------------------------------------------------+
void SortBubbleUp(double  &aAr[])
{
   double tmp;
   int i,j;
   int Len=ArraySize(aAr);
   int Len1=Len-1;
      for(i=1;i<Len;i++)
      {
         for(j=Len1;j>=i;j--)
         {
            if(aAr[j-1]>aAr[j])
            {
               tmp=aAr[j-1];
               aAr[j-1]=aAr[j];
               aAr[j]=tmp;
            }
         }
      }
}
//+------------------------------------------------------------------+
//| SortBubbleDn                                                     |
//+------------------------------------------------------------------+
void SortBubbleDn(double  &aAr[])
{
   double tmp;
   int i,j;
   int Len=ArraySize(aAr);
   int Len1=Len-1;
      for(i=1;i<Len;i++)
      {
         for(j=Len1;j>=i;j--)
         {
            if(aAr[j-1]<aAr[j])
            {
               tmp=aAr[j-1];
               aAr[j-1]=aAr[j];
               aAr[j]=tmp;
            }
         }
      }
}
//+------------------------------------------------------------------+
//| SortSelectUpFst                                                  |
//+------------------------------------------------------------------+
void SortSelectUpFst(double  &aAr[])
{
   double tmp;
   int i,j,Len=ArraySize(aAr)-1;
      for(i=0;i<Len;i++)
      {
         j=ArrayMinimum(aAr,i);
         tmp=aAr[i];
         aAr[i]=aAr[j];
         aAr[j]=tmp;
      }
}
//+------------------------------------------------------------------+
//| SortSelectDnFst                                                  |
//+------------------------------------------------------------------+
void SortSelectDnFst(double  &aAr[])
{
   double tmp;
   int i,j,Len=ArraySize(aAr)-1;
      for(i=0;i<Len;i++)
      {
         j=ArrayMaximum(aAr,i);
         tmp=aAr[i];
         aAr[i]=aAr[j];
         aAr[j]=tmp;
      }
}
//+------------------------------------------------------------------+