1、冒泡排序
双层for循环，数组内部元素不断比较交换，最终排序。
时间复杂度为O(n2)
private void bubbleSort(int[] array)
{
int median=0;
for(int i=0;i<array.Length-1;i++)
{
for(int j=i+1;j<array.Length;j++)
{
if(array[i]>array[j])
{
median=array[i];
array[i]=array[j];
array[j]=median;
}
}
}
}
2、交换排序
双层for循环，相邻位不断比较，每一轮筛选出最大数元素，在下了一轮将其排除在外，再进行新一轮的的筛选（冒泡排序是最简单的交换排序）。
时间复杂度为O(n2)
private void exchangeSort(int[]array)
{
int demian=0;
for(int i=1;i<array.Length;i++)
{
for(int j=0;j<array.Length-i;j++)
{
if(array[j]>array[j+1])
{
demian=array[j];
array[j]=array[j+1];
array[j+1]=demian;
}
}
}
}
可以将其优化一下
private void exchangeSort(int[]array)
{
int demian=0;
bool isChange=true;
for(int i=1;i<array.Length && isChange;i++)
{
isChange=false;
for(int j=0;j<array.Length-i;j++)
{
if(array[j]>array[j+1])
{
demian=array[j];
array[j]=array[j+1];
array[j+1]=demian;
isChange=true;
}
}
}
}
3、选择排序
选择排序的原理是：在未排序的数组中寻找到最小的（最大的）数，将其放在数组的首位，然后剩下没排序的数组中再次寻找最小（最大的）数，将其放在上一轮的数后面，以此类推，直到没有剩余没排序的。
相比较于冒泡排序，选择排序的比较次数与冒泡排序相等，但是选择排序的交换次数要少于冒泡排序，至多交换数组长度减一次。
private void selectSort(int[]array)
{
int demian=0;
for(int i=0;i<array.Length-1;i++)
{
int minValue=int[i];//假设下标为i就是这一轮的最小数
int minIndex=i;//最小数的下标
for(int j=i+1;j<array.Length;j++)
{
if(minValue>array[j])
{
minValue=array[j];//将发现的最小值赋值给原定的最小值
minIndex=j;//下标也赋值
}
}
//将最小值的数的位置与原来假设的最小值的位置进行交换
demian=array[i];
array[i]=array[minIndex];
array[minIndex]=demian;
}
}
4、插入排序
排序思想：1.是将数组的首位元素作为已经排序好的数组
2.取出下一个元素，将其在排好序的从后往前进行扫描
3.找到比这个数小或等于这个数的，将这个数插在下个位置
4.重复2，3两个步骤，直到结束。
private void insertSort(int[]array)
{
for(int i=1;i<array>length;i++)
{
int insertValue=array[i];//要准备插入的数
int insertIndex=i-1;//前一个数的下标
//条件满足说明还要继续寻找合适的位置
while(insertIndex>=0 &&insertValue<array[insertIndex])
{
array[insertIndex+1]=array[insertIndex];//大于要插得数将其下标往后移
insertIndex--;
}
//插入适合的位置
array[insetIndex+1]=insertValue;
}
}
5、希尔排序
每隔整数（sp）个数进行排序，即组内有序，当sp为1时，进行类似于插入排序，最终构造成有序数组。
核心算法:
for(int i=0;i<array.Length-sp;i++)
{
for(int j=i;j<array.Length-sp;j+=sp)
{
if(array[j]>array[j+sp])
{
demian=array[j];
array[j]=array[j+sp];
array[j+sp]=demian;
}
}
}
private void spSort(int[] array,int[]sp)
{
for(int i=0;i<sp.Length;i++)
{
//这里的sp数组存储的是要间隔的数，数组里的数是从大到小的，列如{5，3，1}
//创建这个spSort是为了方便，也可以在main函数里自己用不同的sp多次调用shellSort
shellSort(array,sp[i]);
}
}
//希尔排序主体
private void shellSort(int[]array,int sp)
{
int demian=0;
for(int i=0;i<array.Length-sp;i++)
{
for(int j=i;j<array.Length-sp;j+=sp)
{
if(array[j]>array[j+sp])
{
demian=array[j];
array[j]=array[j+sp];
array[j+sp]=demian;
}
}
}
}
6、归并排序
归并思想：将若干个有序的数组合并成一个有序的数组，有两种合并思想
1.自下向上进行合并
2.自顶向下进行合并
（做法有点难讲，可百度）
private void mergeSort(int[] array,int first,int last)
{
try{
//first为表格的初始位置，last为表格的末尾位置
if(first<last)
{
int mid=(first+last)/2;
mergeSort(array,first,mid);//这里用到了递归的思想
mergeSort(array,mid+1,last);
mergeSortCore(array,first,mid,last);
}
}
catch(Expection ex)
{}
p
}
//归并排序核心部分
rivate void mergeSortCore(int[] array,int first,int mid,int last)
{
try{
int indexA=first;//左边表格的初始下标
int indexB=mid+1;//右边表格的初始下标
int[] coreArray=new int[last+1];//重新建立一个空数组，数组长度与array相同
int coreIndex=0;//空数组的下标
while(indexA<=mid&&indexB<=last)
{
//当左右表格中有一个遍历完之后，就退出
if(array[indexA]<=array[indexB])
{
coreArray[coreIndex++]=array[indexA++];
}
else(array[indexA]>array[indexB])
{
coreArray[coreIndex++]=array[indexB++]
}
}
//剩余没有遍历完的填在coreArray后面
while(indexA<=mid)
{
coreArray[coreIndex++]=array[indexA++];
}
while(indexB<=last)
{
coreArray[coreIndex++]=array[indexB++];
}
//将coreArray数组写入原数组
for(int i=0;i<array.Length;i++)
{
array[i]=coreArray[i];
}
}
catch(Exception ex)
{}
}
7、快速排序
快速排序的做法：在无序的数组中选择一个基准元素，使得在基准元素的左边都比基准元素小，右边都比基准元素大，基准元素不参加排序。
过程：
1.在无序数组中选择一个基准元素，命名为keyValue，数组的起始和末尾分别加一个指针i，j。
2.将i逐渐增大，直到找到大于keyValue的数为止。
3.将j逐渐增大，直到找到小于keyValue的数为止。
4.如果i<j的话，即两者之间的元素是大于1的，则array[i]与array[j]交换。
//快速排序
/// <summary>
/// 快速排序
/// </summary>
/// <param name="array"></param>
/// <param name="low"></param>
/// <param name="high"></param>
public static void QuickSort(int[] array,int low,int high)
{
//基线条件
if (low >= high)
{
return;
}
//得到基准值
int pivotIndex = QuickSortIndex(array, low, high);
//进行递归
QuickSort(array, low, pivotIndex - 1);
QuickSort(array, pivotIndex + 1, high);
}
#endregion
#region 快速排序的核心代码写法
public static int QuickSortIndex(int[] array,int low, int high)
{
//设置一个基准值
int pivote = array[low]; //9
int left = low;//左指针 0
int right = high;//右指针 8
try//由于快速排序是一个不稳定的排序算法，这里用异常处理机制来预防代码出现异常
{
while (left < right)
{
/*这里需要注意的是指针先从后往前进行一个移动
* 这里的指针的移动顺序非常重要，指针的移动一定是要从后往前进行移动的，再进行从前往后移动的
在两个指针相碰的人位置退出while循环，同时将这个位置记录下来作为一个预先设定基准值的位置*/
while (left < right && array[right] >= pivote)
{
right--;
}
array[left] = array[right];
while (left < right && array[left] <= pivote)
{
left++;
}
array[right] = array[left];
}
//此处的left=right;
//将此时的左右指针共同指向的位置赋予所设定的基准值
array[left] = pivote;
}
catch
{
}
return left;
}
#endregion
备注：快速排序时不稳定排序。