/// <summary>
/// 冒泡排序 第一次循环完毕，最小的在最上面。逐步处理
/// </summary>
/// <typeparam name="T"></typeparam>
public sealed class Bubble<T> where T : IComparable
{
public static void Sort(T[] array)
{
for (int i = 0; i <array.Length-1; i++)
{
bool exchange =false;
for (int j = array.Length - 1; j > i; j--)
{
T temp ;
if (array[j].CompareTo(array[j - 1])<0)
{
exchange = true;
temp =array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
SortCompareHelper<T>.Compare(array[j],array[j - 1]);
}
}
if (!exchange)
{
break;
}
}
}
}
/// <summary>
/// 选择排序
/// </summary>
/// <typeparam name="T"></typeparam>
public sealed class Select<T> where T : IComparable
{
public static void Sort(T[] array)
{
for (int i = 0; i < array.Length - 1; i++)
{
for (int j = array.Length - 1; j > i; j--)
{
T temp;
if (array[j].CompareTo(array[i]) < 0)
{
temp = array[j];
array[j] = array[i];
array[i] = temp;
SortCompareHelper<T>.Compare(array[j], array[i]);
}
}
}
}
}
/// <summary>
/// 插入排序
/// 算法思想简单描述：
/// 每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子列表当中的适当位置，直到全部记录插入完成为止。
/// 对直接插入排序我的理解就是：先将第一个记录视为一个有序序列，然后依次将后面的记录插入到这个有序序列中来。
/// 每次要插入的记录时，须从后往前依次比较有序序列中的记录，直到找到在有序序列中的位置，记录下该位置，该位置开始的每个记录都后移一位
/// 然后将插入记录插入该位置。这样每插入一个记录进去，有序序列长度加1，剩余记录减1，直到所有记录都插入到有序序列中，排序完成
/// </summary>
/// <typeparam name="T"></typeparam>
public sealed class Insert<T> where T : IComparable
{
public static void Sort(T[] array)
{
for (int i = 1; i < array.Length; i++)
{
Console.WriteLine("第{0}次",i);
T temp = array[i];
int j = i;
// 内层循环，在有序序列中从后往前比较，找到待排序记录在有序列中位置（位置空出）
for (j = i - 1; j >= 0 && temp.CompareTo(array[j]) < 0; j--)
{
// 将有序记录往后移
array[j + 1] = array[j];
SortCompareHelper<T>.Compare(temp, array[j + 1]);
}
// 将临时变量中的值放入正确位置，即空出的位置
array[j + 1] = temp;
}
}
}
/// <summary>
/// 希尔排序
/// 算法思想简单描述：
/// 在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点， 并且对插入下一个数没有提供任何帮助。
/// 如果比较相隔较远距离（称为 增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。
/// D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组，
/// 每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。
/// 下面的函数是一个希尔排序算法的一个实现，初次取序列的一半为增量，以后每次减半，直到增量为1。希尔排序是不稳定的
/// </summary>
/// <typeparam name="T"></typeparam>
public class Shell<T> where T : IComparable
{
public static void Sort(T[] array)
{
int length = array.Length;
for (int h = length / 2; h > 0; h = h / 2)
{
for (int i = h; i < length; i++)
{
T temp = array[i];
if (temp.CompareTo(array[i - h]) < 0)
{
for (int j = 0; j < i; j += h)
{
if (temp.CompareTo(array[j]) < 0)
{
temp = array[j];
array[j] = array[i];
array[i] = temp;
SortCompareHelper<T>.Compare(array[i], array[j]);
}
}
}
}
}
}
}
/// <summary>
/// 快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。
/// 它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，
/// 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
/// 设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。
/// 一趟快速排序的算法是：
/// 1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；
/// 2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]；
/// 3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，并与A[I]交换；
/// 4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，与A[J]交换；
/// 5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j+完成的最后另循环结束)
/// </summary>
/// <typeparam name="T"></typeparam>
public class Quick<T> where T : IComparable
{
public static void Sort(T[] array, int nLower, int nUpper)
{
if (nLower < nUpper)
{
int nSplit = Swap(array, nLower, nUpper);
///递归排序
Sort(array, nLower, nSplit - 1);
Sort(array, nSplit + 1, nUpper);
}
}
private static int Swap(T[] array, int nLower, int nUpper)
{
int nLeft = nLower + 1;
///以数组第一个元素值作为支点
T nPivot = array[nLower];
int nRight = nUpper;
T nSwap;
while (nLeft <= nRight)
{
///从左向右寻找大于支点元素
while (nLeft <= nRight && array[nLeft].CompareTo(nPivot)<0)
nLeft++;
///从右向左寻找小于支点元素
while (nLeft <= nRight && !(array[nRight].CompareTo(nPivot)<0))
nRight--;
///交换nLeft和nRight位置元素值
if (nLeft < nRight)
{
nSwap = array[nLeft];
array[nLeft] = array[nRight];
array[nRight] = nSwap;
nLeft++;
nRight--;
}
}
///以intArray[nRight]为新支点
nSwap = array[nLower];
array[nLower] = array[nRight];
array[nRight] = nSwap;
return nRight;
}
}
