归并排序类C#

复杂度

时间复杂度为O(nlog₂n) 这是该算法中最好、最坏和平均的时间性能。
空间复杂度为 O(n)
比较操作的次数介于(nlogn) / 2和nlogn - n + 1。
赋值操作的次数是(2nlogn)。归并算法的空间复杂度为：0 (n)
归并排序比较占用内存，但却是一种效率高且稳定的算法。

代码

public class MergeSort
{
    public int[] Sort(int[] Myarray)
    {
       return Sort<int>(Myarray);
    }
    public float[] Sort(float[] Myarray)
    {
       return Sort<float>(Myarray);
    }
    public double[] Sort(double[] Myarray)
    {
       return Sort<double>(Myarray);
    }
    public string[] Sort(string[] Myarray)
    {
       return Sort<string>(Myarray);
    }
    /// <summary>
    /// 归并排序
    /// </summary>
    /// <param name="Myarray"></param>
    /// <returns></returns>
    public T[] Sort<T>(T[] Myarray) where T : IComparable
    {
       int len = 1;
       while (len < Myarray.Length)
       {
           Merge<T>(Myarray, len);
           len *= 2;
       }
       return Myarray;
    }
    /// <summary>
    /// 归并操作
    /// </summary>
    /// <param name="Myarray"></param>
    /// <param name="len"></param>
    private void Merge<T>(T[] Myarray, int len) where T : IComparable
    {
        int m = 0;
        int l1 = 0;
        int h1, l2, h2;
        int j = 0;
        int i = 0;
        T[] tmp = new T[Myarray.Length];
        while (l1 + len < Myarray.Length)
        {
           l2 = l1 + len;
           h1 = l2 - 1;
           h2 = (l2 + len - 1) < Myarray.Length ? l2 + len - 1 : Myarray.Length - 1;
           j = l2;
           i = l1;
           //比较两个序列的最小值并赋值给临时表，同时那个拥有最小值得序列番号自
           //加，依次比较直至番号超出，取出最小的几个值。
           while ((i <= h1) && (j <= h2))
           {
               //if (Myarray[i] < Myarray[j])
               if (Myarray[i].CompareTo(Myarray[j]) < 0)
                 tmp[m++] = Myarray[i++];
               else
                 tmp[m++] = Myarray[j++];
           }
              //如果没有排序完，继续。
              while (i <= h1)
              {
                  tmp[m++] = Myarray[i++];
              }
              while (j <= h2)
              {
                 tmp[m++] = Myarray[j++];
              }
              l1 = h2 + 1;
            }
            i = l1;
            while (i < Myarray.Length)
            {
                tmp[m++] = Myarray[i++];
            }
            for (i = 0; i < Myarray.Length; i++)
            {
                Myarray[i] = tmp[i];
            }
        }
    }

排序索引类

/// <summary>
/// 排序索引类
/// </summary>
public class IndexSort
{
    private class IndexKey<T> : IComparable where T : IComparable
    {
        public int Index;
        public T Value;

        public int CompareTo(object obj)
        {
                T keyValue = ((IndexKey<T>)obj).Value;
                return Value.CompareTo(keyValue);
        }
    }

    public int[] GetIndex(int[] arrValue)
    {
        return GetIndex<int>(arrValue);
    }

    public int[] GetIndex(float[] arrValue)
    {
        return GetIndex<float>(arrValue);
    }

    public int[] GetIndex(double[] arrValue)
    {
        return GetIndex<double>(arrValue);
    }

    public int[] GetIndex(string[] arrValue)
    {
        return GetIndex<string>(arrValue);
    }

    public int[] GetIndex<T>(T[] arrValue) where T : IComparable
    {
        IndexKey<T>[] arrKey = new IndexKey<T>[arrValue.Length];
        for (int i = 0; i < arrValue.Length; i++)
        {
            arrKey[i] = new IndexKey<T>();
            arrKey[i].Index = i;
            arrKey[i].Value = arrValue[i];
        }

        MergeSort sort = new MergeSort();
        sort.Sort<IndexKey<T>>(arrKey);

        int[] arrIndex = new int[arrValue.Length];
        for (int i = 0; i < arrKey.Length; i++)
        {
            arrIndex[i] = arrKey[i].Index;
        }

        return arrIndex;
    }
}