用C#实现的排序算法

//选择排序，从小到大
  public static int SelectSort(int[] a)
  {
   int count=0;// 计算时间复杂度，运行的次数
   int length = a.Length;
   int k= 0;
   int chan;//用来交换的中间变量
   
   for(int i=0;i<length;i++) //需要更换的位置i
   {
    k =i; //初始化最大值的下标
    for(int j=i;j<length;j++) //寻找最大值
    {
     if(a[j]<a[k])
     {
      k=j;
     }

     count++;

    }
    //将最大值和需要换的位置i上的值互换
    chan = a[i];
    a[i] = a[k];
    a[k] = chan;
     }

   for(int i=0;i<length;i++)
   {
    Console.Write(a[i].ToString()+"/t");
   }
   return count;
  }

 //冒泡排序从小到大
  public static int ToTop(int[] array)
  {
   int count=0;
   int p=1;//标志量，看数组是否已经符合了了从小到大的排序要求
   int chan; //用来交换的临时变量
   int length = array.Length;
   for(int i=0;i<length-1&&p!=0;i++) //在p=1的条件下做length-1次循环，每次循环把前面的最大值后移
   {
    /*
     当数组满足了从小到大的排列顺序时p在下面的循环中一直被赋值为0，当做完下面的循环回到上面是因为无法符合条件跳出
    */
    for(int j=0;j<length-i-1;j++)  //控制比较到达的位置
    {
     p=0;
     if(array[j]>array[j+1])  //当相连的两个数的满足前者大于后者时交换数值
     {
      p=1;
      chan   =  array[j];
      array[j]   =  array[j+1];
      array[j+1] =  chan;
     }
     count++;
    }
   }

   for(int i=0;i<length;i++)
   {
    Console.Write(array[i].ToString()+"/t");
   }
   return count;
  }

 //插入排序从小到大
  public static void InsertSort(int[] array)
  {
   int length = array.Length;
   int chan;
   for(int i=1;i<length;i++) //从第2个数开始做length-1次循环，分别找到下标为i的数的确切位置
   {
    int k=i;
    while(k>0&&array[k]<array[k-1]) //当位置k上的数未超出边界值(k>0)且值小于前面的的数时需要交换
    {
     chan =array[k];
     array[k] =array[k-1];
     array[k-1]=chan;
     k--; //k下标左移一位，进行下一步的比较

    }
   }

   for(int i=0;i<length;i++)
   {
    Console.Write(array[i].ToString()+"/t");
   }
  }

 /// <summary>
  /// 快速排序
  /// </summary>
  /// <param name="array">要排序的数组</param>
  /// <param name="start">正在排序的数组的起始位置</param>
  /// <param name="end">正在排序的数组的结束位置</param>
  public static void QuickSort(int[] array,int start,int end)  //找到start位置上的数的确切位置，让数组满足他左边的数都比他小，右边的数都比他大
  {
   if(start == end)
    return;

   int Start = start;
   int End =end;
   if(start>end) //控制边界，起始位置下标值小于结束位置的小标值
   {
    Console.WriteLine("start postion larger than end postion!Error!");
    return;
   }
   int valu = array[start]; //将start位置上的值赋给valu，位置设为空
   while(start<end) //设置循环的终止条件
   {
    while(array[end]>valu&&end>start) //从后面往前找找到一个比valu值小的值进行调换
    {
     end--;
    }
    array[start]= array[end]; //找到的数填入前面找到start的位置 ，end位置空出
    while(array[start]<valu&&start<end) //从前面往前找找到一个比valu值大的值进行调换
    {
     start++;
    }
    array[end] =array[start]; //找到的数填入前面找到end的位置 ，start位置空出
    
   }
   array[start]=valu;

   QuickSort(array,Start,end); //递归，将数组的前面部分排序
   QuickSort(array,end+1,End);//递归，将数组的后面面部分排序
  }

public static int ShellSort(int[] array,int k)
  {
   int count=0;
   int len = array.Length;
   for(;k>0;k--)
   {
    for(int j=0;j<k;j++)
    {
     for(int h=j+k;h<len;)
     {
      int g = h ;
      while((g-k)>=0&&array[g]<array[g-k])
      {
       int n = array[g-k];
       array[g-k] = array[g];
       array[g]=n;
       g-=k;
       count ++;
      }
      h+=k;
     }
    }

   }

   for(int i=0;i<len;i++)
   {
    Console.WriteLine(array[i].ToString());
   }
   return count;
  }