常用排序算法（冒泡、选择、归并、快排、插入）

冒泡排序（时间复杂度On^2 空间复杂度O1)稳定

步骤：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

//冒泡排序改进版
void BubbleSort(int a[]){
int temp;
for(int i=0;i<a.length;i++){
int flag = 0;
for(int j=i+1;j<a.length;j++){
if(a[i]<a[j]){
temp=a[i];
a[i]=a[j];
a[j]=temp;
flag=1;
}
}
if(flag==0){
break;
}
}
for(int i=0;i<a.length;i++){
System.out.print(" "+a[i]);
}
System.out.println();
}

选择排序：（时间复杂度On^2 空间复杂度O1)不稳定

//选择排序
void SelectSort(int a[]){
int temp;
int length = a.length;
for(int i=0;i<length-1;i++){
int index = i;
for(int j=i+1;j<length;j++){
if(a[j]>a[index]){
index=j;
}
}
if(i!=index){
temp=a[i];
a[i]=a[index];
a[index]=temp;
}
}
for(int i=0;i<length;i++){
System.out.print(" "+a[i]);
}
System.out.println();
}

归并排序 时间复杂度O(nlogn)，而空间复杂度是O(n) 稳定

是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用

将一个数组递归划分成子集，直到划分到已经排序好了，在进行递归合并

//归并排序子函数
void MergeSort(int r[],int s, int t){
int m;
int[] r1= new int[1000];
if(s==t)return;
else{
m=(s+t)/2;
MergeSort(r,s,m);
MergeSort(r,m+1,t);
Merge(r,r1,s,m,t);
for(int i=s;i<=t;i++)
r[i]=r1[i];
}
}
//归并排序
void Merge(int r[],int r1[],int s,int m,int t){
int i=s,j=m+1,k=s;
while(i<=m&&j<=t){
if(r[i]<r[j])
r1[k++]=r[i++];
else
r1[k++]=r[j++];
}
while(i<=m)
r1[k++]=r[i++];
while(j<=t)
r1[k++]=r[j++];
}

快速排序：（时间复杂度O nlog2(n) 空间复杂度O nlog2(n))不稳定

1从数列中挑出一个元素，称为 “基准”（pivot），

2重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

3递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

//快速排序子函数
int Partition(int r[],int first,int end){
int i=first,j=end;
while(i<j){
while(i<j&&r[i]<=r[j])
j--;
if(i<j){
int temp=r[i];
r[i]=r[j];
r[j]=temp;
i++;
}
while(i<j&&r[i]<=r[j])
i++;
if(i<j){
int temp=r[i];
r[i]=r[j];
r[j]=temp;
j--;
}
}
return i;
}
//快速排序
void QuickSort(int r[],int first,int end){
int pivot;
if(first<end){
pivot=Partition(r,first,end);
QuickSort(r,first,pivot-1);
QuickSort(r,pivot+1,end);
}
}

插入排序：（时间复杂度On^2 空间复杂度O1)稳定

步骤：

1从第一个元素开始，该元素可以认为已经被排序

2取出下一个元素，在已经排序的元素序列中从后向前扫描

3如果该元素（已排序）大于新元素，将该元素移到下一位置

4重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

5将新元素插入到该位置中

6重复步骤2

//插入排序
void insetrion(int a[]){
int n=a.length;
int j;
for(int i=2;i<a.length;i++){
a[0]=a[i];
for(j=i-1;a[0]<a[j];j--)
a[j+1]=a[j];
a[j+1]=a[0];
}
}