C#, computación numérica: métodos de cálculo y programas fuente de varios algoritmos de clasificación clásicos (sort)

utilizando el sistema;

espacio de nombres Legalsoft.Truffer
{     clasificador de clase pública     {         clasificador público() { }

        public static void sort(doble[] arr)
        {             sort(arr, -1);         }

        public static void sort(doble[] arr, int m = -1)
        {             const int M = 7;             const int NSTACK = 64;             int jstack = -1;             intl = 0;             int n = arr.Length;             doble a;             int[] istack = new int[NSTACK];             si (m > 0)             {                 n = Math.Min(m, n);             }             int ir = n - 1;             para (; ; )             {                 si (ir - l < M)                 {                     para (int j = l + 1; j <= ir; j++)                     {


















                        a = matriz[j];
                        int yo = j - 1;
                        for (; i >= l; i--)
                        {                             //if (arr[i].CompareTo(a) <= 0)                             if (arr[i] <= a)                             {                                 break;                             }                             matriz[i + 1] = matriz[i];                         }                         matriz[i + 1] = a;                     }                     si (jstack < 0)                     {                         descanso;                     }













                    ir = istack[jstack--];
                    l = istack[jstack--];
                }
                más
                {                     int k = (l + ir) >> 1;                     Globals.SWAP(ref arr[k], ref arr[l + 1]);

                    if (arr[l] > arr[ir])
                    {                         Globals.SWAP(ref arr[l], ref arr[ir]);                     }                     if (arr[l + 1] > arr[ir])                     {                         Globals.SWAP(ref arr[l + 1], ref arr[ir]);                     }                     if (arr[l] > arr[l + 1])                     {                         Globals.SWAP(ref arr[l], ref arr[l + 1]);                     }                     int yo = l + 1;                     int j = ir;                     a = arr[l + 1];                     para (; ; )                     {















                        hacer
                        {                             i++;                         } while (arr[i] < a);                         hacer                         {                             j--;                         } while (arr[j] > a);                         si (j < i)                         {                             ruptura;                         }                         Globals.SWAP(ref arreglo[i], ref arreglo[j]);                     }                     matriz[l + 1] = matriz[j];                     matriz[j] = una;                     pila j += 2;















                    if (jstack >= NSTACK)
                    {                         throw new Exception("NSTACK demasiado pequeño en ordenación");                     }                     if (ir - i + 1 >= j - l)                     {                         istack[jstack] = ir;                         istack[jstack - 1] = yo;                         ir = j - 1;                     }                     else                     {                         istack[jstack] = j - 1;                         istack[jstack - 1] = l;                         l = yo;                     }             }                 }
















        }

        public static void hpsort(doble[] ra)
        {             int n = ra.Length;             for (int i = n / 2 - 1; i >= 0; i--)             {                 sift_down(ra, i, n - 1);             }             for (int i = n - 1; i > 0; i--)             {                 Globals.SWAP(ref ra[0], ref ra[i]);                 tamizar_abajo(ra, 0, i - 1);             }         }

        public static void sift_down(doble[] ra, int l, int r)
        {             doble a = ra[l];             int jold = l;             int j = 2 * l + 1;             while (j <= r)             {                 if (j < r && ra[j] < ra[j + 1])                 {                     j++;                 }                 if (a >= ra[j])                 {                     romper;                 }                 ra[jold] = ra[j];                 jold = j;                 j = 2 * j + 1;             }             ra[jold] = a;         }

        public static void piksrt(doble[] arr)
        {             int n = arr.Length;             for (int j = 1; j < n; j++)             {                 double a = arr[j];                 int yo = j;                 while (i > 0 && arr[i - 1] > a)                 {                     arr[i] = arr[i - 1];                     i--;                 }                 matriz[i] = una;             }         }

        public static void piksr2(doble[] arr, doble[] brr)
        {             int n = arr.Length;             for (int j = 1; j < n; j++)             {                 double a = arr[j];                 doble b = brr[j];                 int yo = j;                 while (i > 0 && arr[i - 1] > a)                 {                     arr[i] = arr[i - 1];                     brr[i] = brr[i - 1];                     i--;                 }                 matriz[i] = una;                 brr[i] = b;             }         }

        public static double select(int k, double[] arr)
        {             int n = arr.Length;             doble a;             intl = 0;             int ir = n - 1;             for (; ; )             {                 if (ir <= l + 1)                 {                     if (ir == l + 1 && arr[ir] < arr[l])                     {                         Globals.SWAP(ref arr[l], ref arr[ir ]);                     }                     return arr[k];                 }                 else                 {                     int mid = (l + ir) >> 1;

















                    Globals.SWAP(ref arr[mid], ref arr[l + 1]);
                    if (arr[l] > arr[ir])
                    {                         Globals.SWAP(ref arr[l], ref arr[ir]);                     }                     if (arr[l + 1] > arr[ir])                     {                         Globals.SWAP(ref arr[l + 1], ref arr[ir]);                     }                     if (arr[l] > arr[l + 1])                     {                         Globals.SWAP(ref arr[l], ref arr[l + 1]);                     }                     int yo = l + 1;                     int j = ir;                     a = arr[l + 1];













                    para (; ; )
                    {                         hacer                         {                             i++;                         } while (arr[i] < a);                         hacer                         {                             j--;                         } while (arr[j] > a);                         si (j < i)                         {                             ruptura;                         }                         Globals.SWAP(ref arreglo[i], ref arreglo[j]);                     }                     matriz[l + 1] = matriz[j];                     matriz[j] = una;
















                    si (j >= k)
                    {                         ir = j - 1;                     }                     si (j <= k)                     {                         l = yo;                     }                 }         }             }

        cáscara vacía estática pública (doble [] a, int m = -1)
        {             int n = a.Length;             si (m > 0)             {                 n = Math.Min(m, n);             }             int incrementado = 1;             hacer             {                 aum *= 3;                 inc++;             } mientras (inc <= n);             hacer             {                 inc /= 3;                 for (int i = inc; i < n; i++)                 {                     double v = a[i];                     intj = yo;                     //si (a[j - inc].CompareTo(v) > 0)



















                    while (a[j - inc] > v)
                    {                         a[j] = a[j - inc];                         j -= aumento;                         si (j < inc)                         {                             ruptura;                         }                     }                     a[j] = v;                 }             } mientras (inc > 1);         }

        public static void sort2(doble[] arr, doble[] brr)
        {             const int M = 7;             const int NSTACK = 64;             int jstack = -1;             intl = 0;             int n = arr.Length;             int[] istack = new int[NSTACK];             int ir = n - 1;             for (; ; )             {                 if (ir - l < M)                 {                     for (int j = l + 1; j <= ir; j++)                     {                         double a = arr[j];                         doble b = brr[j];                         int yo = j - 1;
















                        for (; i >= l; i--)
                        {                             if (arr[i] <= a)                             {                                 break;                             }                             matriz[i + 1] = matriz[i];                             brr[i + 1] = brr[i];                         }                         matriz[i + 1] = una;                         brr[i + 1] = b;                     }                     si (jstack < 0)                     {                         descanso;                     }                     ir = istack[jstack--];















                    l = istack[jstack--];
                }
                más
                {                     int k = (l + ir) >> 1;                     Globals.SWAP(ref arr[k], ref arr[l + 1]);                     Globals.SWAP(ref brr[k], ref brr[l + 1]);

                    if (arr[l] > arr[ir])
                    {                         Globals.SWAP(ref arr[l], ref arr[ir]);                         Globals.SWAP(ref brr[l], ref brr[ir]);                     }                     if (arr[l + 1] > arr[ir])                     {                         Globals.SWAP(ref arr[l + 1], ref arr[ir]);                         Globals.SWAP(ref brr[l + 1], ref brr[ir]);                     }                     if (arr[l] > arr[l + 1])                     {                         Globals.SWAP(ref arr[l], ref arr[l + 1]);                         Globals.SWAP(ref brr[l], ref brr[l + 1]);                     }













                    int yo = l + 1;
                    int j = ir;
                    doble a = arr[l + 1];
                    doble b = brr[l + 1];
                    para (; ; )
                    {                         hacer                         {                             i++;                         } while (arr[i] < a);                         hacer                         {                             j--;                         } while (arr[j] > a);                         si (j < i)                         {                             ruptura;                         }












                        Globals.SWAP(ref arr[i], ref arr[j]);
                        Globals.SWAP(ref brr[i], ref brr[j]);
                    }
                    matriz[l + 1] = matriz[j];
                    matriz[j] = una;
                    brr[l + 1] = brr[j];
                    brr[j] = b;
                    pila j += 2;
                    if (jstack >= NSTACK)
                    {                         throw new Exception("NSTACK demasiado pequeño en sort2.");                     }                     if (ir - i + 1 >= j - l)                     {                         istack[jstack] = ir;                         istack[jstack - 1] = yo;






                        ir = j - 1;
                    }
                    else
                    {                         istack[jstack] = j - 1;                         istack[jstack - 1] = l;                         l = yo;                     }                 }         }             }

        /// <summary>
        /// seleccione Mth mayor en el lugar
        /// </summary>
        /// <param name="k"></param>
        /// <param name="arr"></param >
        /// <devoluciones></devoluciones>
        /// <excepción cref="Excepción"></excepción>
        public static double selip(int k, double[] arr)
        {             const int M = 64;             constante doble GRANDE = 9.99e99;             int n = arr.Length;             int[] isel = new int[M + 2];             doble[] sel = nuevo doble[M + 2];

            if (k < 0 || k > n - 1)
            {                 throw new Exception("entrada incorrecta para selip");             }             int kk = k;             doble ahi = GRANDE;             doble alo = -GRANDE;             para (; ; )             {                 int mm = 0;                 int nlo = 0;                 doble suma = 0.0;                 int nxtmm = M + 1;                 for (int i = 0; i < n; i++)                 {                     if (arr[i] >= alo && arr[i] <= ahi)                     {                         mm++;                         //si (arr[i] == alo)

















                        if (Math.Abs(arr[i] - alo) <= float.Epsilon)
                        {                             nlo++;                         }                         if (mm <= M)                         {                             sel[mm - 1] = arr[i];                         }                         else if (mm == nxtmm)                         {                             nxtmm = mm + mm / M;                             sel[(i + 2 + mm + kk) % M] = arr[i];                         }                         suma += matriz[i];                     }                 }                 si (kk < nlo)















                {                     volver solo;                 }                 else if (mm < M + 1)                 {                     shell(sel, mm);                     ahi = sel[kk];                     vuelve ahi;                 }                 sel[M] = suma / mm;                 concha(sel, M + 1);                 sel[M + 1] = ahi;

                int j = 0;
                for (; j < M + 2; j++)
                {                     isel[j] = 0;                 }

                for (int i = 0; i < n; i++)
                {                     if (arr[i] >= alo && arr[i] <= ahi)                     {                         int jl = 0;                         int ju = M + 2;                         while (ju - jl > 1)                         {                             int jm = (ju + jl) / 2;                             if (arr[i] >= sel[jm - 1])                             {                                 jl = jm;                             }                             más                             {                                 ju = jm;














                            }
                        }
                        isel[ju - 1]++;
                    }
                }

                j = 0;
                while (kk >= isel[j])
                {                     alo = sel[j];                     kk -= isel[j++];                 }                 ahi = sel[j];             }         }

    }
}