排序算法总结 java实现

/*
Date类用来定义数据，其中比较的是date，依次是
排序，
冒泡排序
选择排序
快速排序
直接插入排序

*/

//用来定义数组
class Data implements Comparable<Data>{
int data ;
String flag ;
//构造数据的方法
public Data(int a ,String flag){

this.data = a;
this.flag = flag ;
}
//重写toString()方法
public String toString(){

return data + flag ;
}
//重写比较的方法
public int compareTo(Data d){

if(this.data > d.data ){
return 1;
}
if(this.data == d.data){
return 0;
}
else{
return -1 ;
}
}
}

//排序
public class AllSort{
//shell 排序
public static void shellSort(Data[] data){

System.out.println("开始排序：");
//lenth 用来记录数组的长度
int length = data.length ;
//h 表示每次间隔的增量，公式是h=3*h+1 ;所以是从１，４，１３，４０
//反过来就是h=(h-1)/3; 序列是：40,13,4,1
int h = 1;
while(h <= length/3){
h = h*3 + 1 ;
}
while(h > 0){
System.out.println("====h=:"+ h + "====" );
for(int i = h; i < length ; i++){
//记录当前h 下的值
Data tmp = data[i] ;
//当当前值和前退h 的值进行比较，要是小则交换。
if(data[i].compareTo(data[i-h]) < 0){
int j = i -h ;
for( ; j>= 0 && data[j].compareTo(tmp) >0 ;j-=h)        {
data[j + h] = data [j];
}
data[j+h] = tmp ;
}
System.out.println(java.util.Arrays.toString(data));
}
h = (h -1) / 3 ;
}
}

//直接插入排序,就想接扑克，假如手中有一张牌，则第二张和第一张比较，加入前面以有多张排序的，则依次后移，在合适的位置加入当前的tmp
public static void insertSort(Data [] data){
System.out.println("开始排序：");
//lenth 用来记录数组的长度
int length = data.length ;
//从第二张开始接
for(int i = 1; i < length ; i++){
Data tmp = data[i] ;
//如果当前的小于前一个，则向后移
if(data[i].compareTo(data[i-1]) < 0){
int  j = i -1;
//整体向后移
for( ; j >= 0 && data[j].compareTo(tmp) > 0 ;j--){
data[j+1] = data[j];
}
//上层循环结束后是j=-1,所以下一个tmp 时要加上１．等于０．
data[j+1] = tmp ;
}
System.out.println(java.util.Arrays.toString(data));
}

}

//快速排序，假设以第一个数为起点，i,j分别记录下标，ｉ从前往后，记录大于第一个数的下标，Ｊ从后往前，记录第一个小于第一个数的下标
//循环一次，则比第一个大的在后边，比第一个小的在前面,在这里会用到一个交换数组元素的方法，swap(data,int i,int j);
public static void swap(Data data[] ,int i,int j){
Data tmp ;
tmp = data [i];
data[i] = data [j];
data[j] = tmp ;
}
//快速排序的函数
public static void subSort(Data [] data ,int start ,int end){
if(start < end){
//以第一个元素作为分界
Data base = data [start];
//从０，和最后一个数＋１开始，是因为下边用的是++i,--j
int i = start ;
int j = end+1 ;
while(true){
//data[1]<=data[0],则继续ｉ＋＋，直到找到ｉ> data[0];
while( i < end && data[ ++i].compareTo(base) <= 0);
//从最后一个数往前找，找到那个小于的才返回
while(j > start && data[--j].compareTo(base) >=0);
if( i < j){
swap(data ,i ,j);
}
//当ｉ>j时，说明前面的以及是有序，不需要在交换
else{
break;
}
}
swap(data ,start ,j);
//递归遍历左子树
subSort(data,start,j-1);
subSort(data ,j+1 ,end);
}
}

//递归调用的函数
public static void QuickSort(Data data[]){
subSort(data,0,data.length-1 ) ;
}

//冒泡排序，0,1 1,2, 2,3 依次比较，循环一次会将最大的排在最后
public static void BubbleSort(Data [] data){
System.out.println("开始排序:");
int length = data.length ;
//i<length-1,是因为最后一个ｉ应该是倒数第二个后最后一个比，j<length-1-i,是因为这里比较的是j he j+1.
for(int  i = 0; i < length-1; i++){
boolean flag = false ;
//注意这一个j是一个内循环，从０－－最后，比较也是连续的，所以不能从i+1开始。
for(int j = 0; j < length-i-1; j++){

if(data[j].compareTo(data[j+1]) > 0){
Data tmp = data[j+1] ;
data[j+1] = data [j] ;
data[j] = tmp ;
flag = true ;
}
}
System.out.println(java.util.Arrays.toString(data));
//if(flag =false),则表明这一趟没有进行交换，处于有序
if(!flag){
break;
}
}
}

//选择排序，第一次循环是第一个与后边的每一个比较，选出最小的放第一个，第二次是从第二个开始，依次和后边的比较

public static void SelectSort(Data [] data){
System.out.println("开始排序:");
int length = data.length ;

for(int  i = 0; i < length-1; i++){
//minIndex用来记录当前这个ｉ的下标，当有第一趟下来换最小的一个就是，减少了交换次数。
int minIndex = i;
for(int j = i+1; j < length; j++){

if(data[minIndex].compareTo(data[j]) > 0){
minIndex = j ;
}
}
//不等于i说明有交换
if(minIndex != i){
Data tmp = data[i] ;
data[i] = data [minIndex] ;
data[minIndex] = tmp ;

}

System.out.println(java.util.Arrays.toString(data));
}
}
public static void main(String args[]){
Data[] data = {
new Data(9," "),
new Data(-16," "),
new Data(21,"*"),
new Data(23," " ),
new Data(-30," "),
new Data(-49," "),
new Data(21," "),
new Data(30,"*"),
new Data(30," ")
};
System.out.println("排序之前：\n"+java.util.Arrays.toString(data));
//shellSort(data);
//insertSort(data);
//QuickSort(data);
//BubbleSort(data);
SelectSort(data) ;
System.out.println("排序之后：\n"+java.util.Arrays.toString(data));
}
}