JAVA实现八种排序学习
public class SortClass {
public static final String MAX_TO_SMALL="max_to_small";//由大到小
public static final String SMALL_TO_MAX="small_to_max";//由小到大
/**
*[一] 直接插入排序
* 基本思想：在要排序的一组数中，假设前面n-1,n>=2个数是已经排好顺序的
* ，现在要把第n个数插入前面的有序数中，使得这n个数也是排序好的。如此反复
* 直到全部排序好
*/
void insert_sort(String type){
int[] a={49,38,65,97,76,13,27};
int temp=0;
System.out.println("insert_sort 直接插入排序前："+Arrays.toString(a));
if(type.equals(SMALL_TO_MAX)){//由小到大
for(int i=1;i<a.length;i++){
int j=i-1;
temp=a[i];
for(;j>=0 && temp<a[j];j--){
a[j+1]=a[j];
}
a[j+1]=temp;
}
}
if(type.equals(MAX_TO_SMALL)){//由大到小
for(int i=1;i<a.length;i++){
int j=i-1;
temp=a[i];
for(;j>=0 && temp>a[j];j--){
a[j+1]=a[j];
}
a[j+1]=temp;
}
}
System.out.println("insert_sort 直接插入排序后："+Arrays.toString(a));
}
/**
* [二]希尔排序（最小增量排序）
* 基本思想：将要排序的一组数按某个增量d(n/2,n为要排序的个数)
* 分成若干组，每组中记录的下标相差d,对每组中全部元素进行直接插入排序
* 然后再用一个较小的增量(d/2)对它进行分组，再没组中再进行直接排序。
* 当增量减到1时，进行直接排序后，排序完成。
* @param type
*/
void sell_sort(String type){
int [] a={1,54,6,3,78,34,12,45,56,100};
double d1=a.length;
int temp=0;
System.out.println("sell_sort 排序前:"+Arrays.toString(a));
// while(true){
// d1=Math.ceil(d1/2);
// int d=(int)d1;
// for(int x=0;x<d;x++){
// for(int i=x+d;i<a.length;i+=d){
// int j=i-d;
// temp=a[i];
// if(type.equals(SMALL_TO_MAX)){//由小到大
// for(;j>=0 && temp<a[j];j-=d){
// a[j+d]=a[j];
// }
// }
// if(type.equals(MAX_TO_SMALL)){//由大到小
// for(;j>=0 && temp>a[j];j-=d){
// a[j+d]=a[j];
// }
// }
//
// a[j+d]=temp;
// }
// }
// if(d==1){
// break;
// }
//
// }
while(true){
d1=Math.ceil(d1/2);
int d=(int)d1;
for(int i=0;i<d;i++){
for(int j=i;j+d<a.length;j+=d){
if(a[j]>a[j+d]){
temp=a[j];
a[j]=a[j+d];
a[j+d]=temp;
}
}
}
if(d==1){
break;
}
d--;
}
System.out.println("sell_sort 排序后:"+Arrays.toString(a));
}
/**
* [三]简单选择排序
* 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
* 然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数
* 比较为止。
* @param type
*/
void select_sort(String type){
int[] a={1,54,3,78,34,23,45};
System.out.println("select_sort排序前:"+Arrays.toString(a));
int position=0;
for(int i=0;i<a.length;i++){
int j=i+1;
position=i;
int temp=a[i];
if(type.equals(MAX_TO_SMALL)){
for(;j<a.length;j++){
if(a[j]>temp){
temp=a[j];
position=j;
}
}
}
if(type.equals(SMALL_TO_MAX)){
for(;j<a.length;j++){
if(a[j]<temp){
temp=a[j];
position=j;
}
}
}
a[position]=a[i];
a[i]=temp;
}
System.out.println("select_sort 排序后:"+Arrays.toString(a));
}
/**
* [四]堆排序：
* 基本思想:堆排序是一种树形选择排序，是对直接选择排序的有效改进。
* 堆排序的定义如下：具有n个元素的序列(h1,h2,...,hn),当且仅当满足(hi>=h2i,hi>=2i+1)
* 或(hi<=h2i,hi<=2i+1)(i=1,2,...,n/2)时称为堆。在这里只讨论满足前者条件为堆。由堆的定义可以看出，堆元素
* （即第一个元素）必选为最大顶！完全二叉树可以很直观第表示堆的结构。堆定位根，其它为左子树，右子树。初时
* @param type
*/
void heap_sort(String type){
}
/**
* [五]冒泡排序：
* 要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数
* 依次进行比较和调整，让较大的数往下沉，较小的数据往上冒
* 对n个元素进行冒泡排序，总共需要进行n-1趟。
* 第1趟需要比较n-1次，第2趟需要比较n-2次,......第i趟需要比较n-i次。
* @param a
* @param ac
*/
void bubble_sort(String type){
int[] a={1,54,6,3,78,34,12,45,99};
System.out.println("buble_sort 排序前："+Arrays.toString(a));
int temp=0;
if(type.equals(SMALL_TO_MAX)){//由小到大
for(int i=0;i<a.length-1;i++){//趟数
for(int j=0;j<a.length-1-i;j++){//次数
if(a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
if(type.equals(MAX_TO_SMALL)){//由大到小
for(int i=0;i<a.length-1;i++){//趟数
for(int j=0;j<a.length-1-i;j++){//次数
if(a[j]<a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
System.out.println("buble_sort 排序后："+Arrays.toString(a));
}
/**
*[七]快速排序
*基本思想：选择一个基准元素，通常选择第一个元素或者最后一个元素，通过一趟扫描，将
*待排序列分成两部分，一部分比基准元素小，一部分大于等于基准元素。此时基准元素在其排序好
*后的正确位置，然后再用同样方法递归排序划分两部分。
* @param type
*/
void quick_sort(String type){
int[] a={49,38,65,97,76,13,27,49,78,34,12,64,5,62,99,98,
54,56,17,18,23,34,15,35,25,53,51};
System.out.println("quick_sort 排序前："+Arrays.toString(a));
}
public static void main(String[] args) {
SortClass s=new SortClass();
s.select_sort(MAX_TO_SMALL);
//s.insert_sort("max_to_small");
// System.out.println( Math.ceil(13/2));
}
}
