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方法就會將對象數按這個字段的值進行排序。