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); 
}



}

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