文章出處
一個排序的類,用了幾種方式實現的。
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);
}
}
}
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#對象數組排序方法
排序是編程中常用的法算之一,排序的方法有很多種,下面介紹一種簡單有效的排序方法,代碼如下:
這里使用了Array.Sort()和Array.Reverse()方法對數據進行正/反排序,變量isReverse做為反排序的標志位
方法傳入了2個參數,一個是要排序的對象數組list,一個是排序關鍵字key,即要對象的根據哪個屬性或字段來進行排序(這個值是等于對象的屬性/字段名)
type.InvokeMember()方法可以得到對象實例的屬性/字段值,這里使用的是字段
在得到數組中的每一個要排序的字段值后,把這個字段值數組做為Array.Sort()方法的參數傳入,Sort方法就會將對象數按這個字段的值進行排序。
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;
}
}
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方法就會將對象數按這個字段的值進行排序。
不含病毒。www.avast.com |
全站熱搜
留言列表