C#对象数组排序方法

一个排序的类，用了几种方式实现的。

using  System;
  
namespace  DataStruct
{
    public   class  Sorter
   {

    ///   <summary>
    ///  冒泡排序法1
    ///   </summary>
        /*
         （1）对于数组list中的1至n个数据，先将第1个和第2个数据进行比较，然后比较第2个和第3个数据；
         依次类推，直到第n-1个数据和第n个数据进行比较交换，这称为一趟冒泡。
         这一趟最明显的效果是：将最小的数据传到了第1位。由此还可推断出，对于n个数，一趟应该进行n-1 次比较操作；
       
         （2）然后，对2至n个数据进行同样操作，则具有次小值的数据被安置在第2位上。
         （3）重复以上过程，每次的移动都向最终排序的目标前进，直至没有数据需要
 交换为止。
         这种排序的方法被形象地比喻成“冒泡”，在排序过程中，小的数就如气泡一
 般逐层上冒，而大的数逐个下沉。 
        */
        ///   <param name="list"></param>
   public   static   void  BubbleSort( int [] list)
  {
       for  ( int  i  =   0 ; i  <  list.Length; i ++ )
      {
           for  ( int  j  =   0 ; j  <  list.Length  -  i  -   1 ; j ++ )      // 一趟排序开始
           // 也可以使用for (int j = 0; j < list.Length - 1; j++) 这样会多几次swap
          {
               if  (list[j]  <  list[j  +   1 ])
              {
                   int  temp  =  list[j];    // 交换开始
                  list[j]  =  list[j  +   1 ];
                  list[j  +   1 ]  =  temp;        // 交换结束
              }
          }                                              // 一趟排序结束
      }
  }

   ///   <summary>
   ///  冒泡排序法2
   ///   </summary>
   ///   <param name="list"></param>
   public   static   void  BubbleSort2( int [] list)
  {
       for  ( int  i  =   1 ; i  <  list.Length; i ++ )  // 进行n-1次比较操作
      {
           for  ( int  j  =   0 ; j  <  list.Length  -   1 ; j ++ )      // 一趟排序开始
          {
               if  (list[j]  <  list[j  +   1 ])
              {
                   int  temp  =  list[j];    // 交换开始
                  list[j]  =  list[j  +   1 ];
                  list[j  +   1 ]  =  temp;        // 交换结束
              }
          }                                              // 一趟排序结束
      }
  }
 
   ///   <summary>
   ///  插入排序法
   ///   </summary>
   ///   <param name="list"></param>
   public   static   void  InsertionSort( int [] list)
  {
       for  ( int  i  =   1 ; i  <  list.Length; i ++ )
      {
           int  t  =  list[i];
           int  j  =  i;
           while  ((j  >   0 )  &&  (list[j  -   1 ]  >  t))
          {
              list[j]  =  list[j  -   1 ];
               -- j;
          }
          list[j]  =  t;
      }
  }
 
   ///   <summary>
   ///  选择排序法
   ///   </summary>
   ///   <param name="list"></param>
   public   static   void  SelectionSort( int [] list)
  {
       int  min;
       for  ( int  i  =   0 ; i  <  list.Length  -   1 ; i ++ )
      {
          min  =  i;
           for  ( int  j  =  i  +   1 ; j  <  list.Length; j ++ )
          {
               if  (list[j]  <  list[min])
              min  =  j;
          }
           int  t  =  list[min];
          list[min]  =  list[i];
          list[i]  =  t;
      }
  }
 
   ///   <summary>
   ///  希尔排序法
   ///   </summary>
   ///   <param name="list"></param>
   public   static   void  ShellSort( int [] list)
  {
       int  inc;
       for  (inc  =   1 ; inc  <=  list.Length  /   9 ; inc  =   3   *  inc  +   1 ) ;
       for  (; inc  >   0 ; inc  /=   3 )
      {
           for  ( int  i  =  inc  +   1 ; i  <=  list.Length; i  +=  inc)
          {
               int  t  =  list[i  -   1 ];
               int  j  =  i;
               while  ((j  >  inc)  &&  (list[j  -  inc  -   1 ]  >  t))
              {
                  list[j  -   1 ]  =  list[j  -  inc  -   1 ];
                  j  -=  inc;
              }
              list[j  -   1 ]  =  t;
          }
      }
  }
 
   private   static   void  Swap( ref   int  l,  ref   int  r)
  {
       int  s;
      s  =  l;
      l  =  r;
      r  =  s;
  }

  ///   <summary>
  ///  快速排序法
  ///   </summary>
  ///   <param name="list"></param>
  ///   <param name="low"></param>
  ///   <param name="high"></param>
  public   static   void  Sort( int [] list,  int  low,  int  high)
 {
      int  pivot;
      int  l, r;
      int  mid;
      if  (high  <=  low)
      return ;
      else   if  (high  ==  low  +   1 )
     {
          if  (list[low]  >  list[high])
         Swap( ref  list[low],  ref  list[high]);
          return ;
     }
     mid  =  (low  +  high)  >>   1 ;
     pivot  =  list[mid];
     Swap( ref  list[low],  ref  list[mid]);
     l  =  low  +   1 ;
     r  =  high;
      do
     {
          while  (l  <=  r  &&  list[l]  <  pivot)
         l ++ ;
          while  (list[r]  >=  pivot)
         r -- ;
          if  (l  <  r)
         Swap( ref  list[l],  ref  list[r]);
     }  while  (l  <  r);
     list[low]  =  list[r];
     list[r]  =  pivot;
      if  (low  +   1   <  r)
     Sort(list, low, r  -   1 );
      if  (r  +   1   <  high)
     Sort(list, r  +   1 , high);
 }
    }
}

C#对象数组排序方法

排序是编程中常用的法算之一，排序的方法有很多种，下面介绍一种简单有效的排序方法，代码如下:

private   bool  isReverse  =   false ;
private   void  Sort(PersonalNotificationEntity [] list, string  key)
{
if ( isReverse )
{
Array.Reverse(list);
isReverse = false;
}
else
{
int len = list.Length;
Type type = typeof(PersonalNotificationEntity);
object [] keys = new object[len];
for(int i = 0 ; i < len ; i++)
{
keys[i] = type.InvokeMember(key,BindingFlags.GetField ,null,list[i],null);
}
Array.Sort(keys,list);
isReverse = true;
}
}

这里使用了Array.Sort()和Array.Reverse()方法对数据进行正/反排序，变量isReverse做为反排序的标志位
方法传入了2个参数，一个是要排序的对象数组list，一个是排序关键字key，即要对象的根据哪个属性或字段来进行排序(这个值是等于对象的属性/字段名)
type.InvokeMember()方法可以得到对象实例的属性/字段值，这里使用的是字段
在得到数组中的每一个要排序的字段值后，把这个字段值数组做为Array.Sort()方法的参数传入，Sort方法就会将对象数按这个字段的值进行排序。