自己用java实现的七个经典排序算法

public class Test {
public static void main(String[] args) {
int[] a={2,5,3,9,6,4,2,6,8,7};
//chooseSort(a);
//bubbleSort(a);
//insertSort(a);
//quickSort(a, 0, a.length-1);
shellSort(a);
//输出
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}


}
/**
* 简单选择排序
* 最差O(n2),平均O(n2),空间O(1),不稳定
*/
public static void chooseSort(int[] array){
int temp=0;
int index=0;
int length=array.length;
//取每个数与后面的进行比较，取最小的数与当前的数交换位置
for(int i=0;i<length;i++){
temp=array[i];
for(int j=i+1;j<length;j++){
if(temp<array[j]){
//每次覆盖最小值，直到取得最终的最小值
temp=array[j];
//记下最小值的位置
index=j;
}
}
//最小值与当前比较值交换位置
array[index]=array[i];
array[i]=temp;
}

}

/**
* 冒泡排序
* 最差O(n2),平均O(n2),空间O(1),稳定
*/
public static void bubbleSort(int[] array){
int temp=0;
int length=array.length;
//进行length-1遍的比较
for(int i=0;i<length-1;i++){
//每遍进行length-1-j次比较
for(int j=0;j<length-1-i;j++){
//附近两个进行比较，大的往上冒
if(array[j]<array[j+1]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
}

/**
* 直接插入排序
* 最差O(n2),平均O(n2),空间O(1),稳定
*/
public static void insertSort(int[] array){
int temp=0;
int length=array.length;
for(int i=1;i<length;i++){
temp=array[i];
int j=i;
while(j>0&&temp>array[j-1])
{
array[j]=array[j-1];
j--;
}
array[j]=temp;
}

}
/**
* 快速排序分组算法
* 以left指针位置为基数，把输入数组划分，结果是基数左边的数都比基数小，基数右边的数不比基数小
*/
public static int division(int[] array,int left,int right){
int base=array[left];
//左右指针一直向中间移动，直到左右指针重合
while(left<right){
//从后往前比较，遇到比级基数小的，就把小的放到当前左指针位置
while(left<right&&array[right]>=base){
right--;
}
array[left]=array[right];

//从前往后比较，遇到比基数大的，就把大的放到当前右指针位置
while(left<right&&array[left]<=base){
left++;
}
array[right]=array[left];
}
array[left]=base;
return left;
}
/**
* 快速排序算法实现
* 通过递归调用自己把数组进行分组排列，知道最后分组中只有一个元素
* 最差O(n2),平均O(nlog2n),空间O(log2n）~O(n)由于递归调用需要栈空间,不稳定
*/
public static void quickSort(int[] array,int left,int right){
//递归终止条件是左右指针重合
if(left<right){
//排序一次，把当前数组分成两组，返回当前指针位置
int baseindex=division(array, left, right);
//分别调用自己，把当前分拆出来的两个数组进行排序
quickSort(array, left, baseindex-1);
quickSort(array, baseindex+1, right);
}
}

/**
* 希尔排序
* 按照一定的步长，把原数组分隔成若干个数组，每个数组内部进行直接插入排序。
* 减少步长，按照此逻辑重新分组排序，直到步长为1，此时只有一个数组，
* 但是此数据比较有序化，采用此数组进行直接插入排序可大大提高效率
* 最差O(n2),平均O(nlog2n),空间O(1),不稳定
*/
public static void shellSort(int[] array){
int length=array.length;
//第一层循环，按步长分组gap为步长，原始步长为数组长度的二分之一，
//后面步长是前面的二分之一
for(int gap=length/2;gap>0;gap=gap/2){
for(int i=0;i<gap;i++){//按步长分组
//每个分组进行直接插入排序,跟直接插入排序原理一样，
//不过正常的直接插入排序步长为1，现在为gap
for(int j=gap+i;j<length;j=j+gap){
int temp=array[j];
int k=j;
//比较当前数与前面数的大小，先把当前的数记录下来，
//把前面比当前数小的数往后移，直到不比当前小，把当前数插入
while(k>=gap&&temp>array[k-gap])
{
array[k]=array[k-gap];
k=k-gap;
}
array[k]=temp;
}
}
}

}
/**
* 归并排序
* 将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，
* 每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
* 最差O(n2),平均O(nlog2n),空间O(n),不一定稳定
*/
public static void mergeSort(int[] array){

}
//堆排序
public static void heapSort(int[] array){

}
}