java 常用排序算法总结

排序问题一直是计算机技术研究的重要问题，排序算法的好坏直接影响程序的执行速度和辅助存储空间的占有量，项目中也会经常用到排序，一个集合的展示顺序按照不同的规则重排等，好的排序算法可以提高执行效率，也可以在代码走读的时候不会让别人看起来好low的感觉。

一、冒泡排序

基本上我们接触排序的时候，第一个都是接触的冒泡排序，而且最后记得比较清楚的还是冒泡，说明冒泡排序是最利于理解的经典排序算法，效率另说。

冒泡排序的基本思想是对响铃的元素进行比较，顺序相反的进行交换，这样每一轮都会将一个最大的或者最小的数移到最顶部，直到最后完全有序。



根据冒泡排序的思想，假设升序，第一次冒泡的比较，需要比较九次，而下一此把8冒出来只需要比较八次，没冒泡一下，下一次就少比较一次。第一次冒泡如下：

list[0],list[1]比（不换）：3,5,8,7,2,6,9,0,1,4；

list[1],list[2]比（不换）：3,5,8,7,2,6,9,0,1,4；

list[2],list[3]比（换）：3,5,7,8,2,6,9,0,1,4;

list[3],list[4]比（换）：3,5,7,2,8,6,9,0,1,4；

list[4],list[5]比（换）：3,5,7,2,6,8,9,0,1,4；

list[5],list[6]比（不换）：3,5,7,2,6,8,9,0,1,4；

list[6],list[7]比（换）：3,5,7,2,6,8,0,9,1,4；

list[7],list[8]比（换）：3,5,7,2,6,8,0,1,9,4；

list[8],list[9]比（换）：3,5,7,2,6,8,0,1,4,9；

java代码转换还是比较简单，如下：

二、插入排序

对于给定的一组记录，初始时假设第一个记录自成一个有序序列，其余记录为无序序列，接着从第二个记录开始，按照记录的大小一次将当前处理的记录插入到其之前的有序序列中，直到最后一个记录插入到有序序列为止。



为了方便理解插入排序，可以假设有一个新的数组（但是实现的时候还是在原本的数组中），里面只有原数组的第一个数据，然后每来一个按照自己的大小插到对应的位置，比如

5来了：3，5

8来了：3，5，8

7来了：3，5，7，8

2来了：2，3，5，7，8

6来了：2，3，5，6，7，8

9来了：2，3，5，6，7，8，9

0来了：0，2，3，5，6，7，8，9

1来了：0，1，2，3，5，6，7，8，9

4来了：0，1，2，3，4，5，6，7，8，9

java代码实现，如下：

三、选择排序

选择排序是一种简单直观的排序算法，其基本原理如下：对给定的一组记录，经过第一轮比较后得到最小的记录，然后将该记录与第一个记录的位置进行交换，接着对不包括第一个记录以外的其他记录进行第二轮比较，得到最小的记录并于第二个记录位置交换；重复改过程，知道进行比较的记录只有一个为止。选择排序是简单，粗暴，但是很有效的一个排序算法；



第一轮找到最小的0，放到list[0],第二轮比较，找到1，放到list[1];

这个转换java代码应该是最简单的吧：

四、快速排序

快速排序是一种非常高效的排序算法，它采用“分而治之”的思想，把大的拆分为小的，小的拆分为更小的，其原理如下：对于一组给定的记录，通过一趟排序后，将原序列分为两部分，其中一部分的所有记录均比后一部分的记录小，然后再依次对前后两部分的记录进行快速排序，递归该过程，直到序列中所有的记录均有序为止。

public class FastSort {

/**
* @param args
*/
public static void main(String[] args) {
/*需要进行排序的数组*/
int[] list = {3,5,8,7,2,6,9,0,1,4};
int len = list.length;
int start = 0;
int end = len-1;
FastSort.sort(list, start, end);
System.out.println(Arrays.toString(list));
}
/**
*
* @param list 需要快速排序的集合
* @param start 快速排序的起点
* @param end 快速排序的终点
*/
public static int partition(int []array,int lo,int hi){
//固定的切分方式,设置一个基准值
int key=array[lo];
while(lo<hi){
//从后半部分向前扫描，如果比基准值大，就再往前移
while(array[hi]>=key&&hi>lo){
hi--;
}
array[lo]=array[hi];
//从前半部分向后扫描，如果比基准值小，就往后移比较
while(array[lo]<=key&&hi>lo){
lo++;
}
array[hi]=array[lo];
}
array[hi]=key;
return hi;
}
/**
* 通过递归调用排序
* @param array
* @param lo
* @param hi
*/
public static void sort(int[] array,int lo ,int hi){
/*如果到达重合点，或者单独一个元素的时候则不比较*/
if(lo>=hi){
return ;
}
/*获得切点坐标*/
int index=partition(array,lo,hi);
sort(array,lo,index-1);
sort(array,index+1,hi);
}

}

快速排序还是比较难理解的，可以多看一下，必要时断点查看一下，如果真的理解了，排序的时候还是快速排序效率高