八大排序算法（Java）

一直在准备面试，但是没有准备自己的博客，也没有写什么东西，写算法的时候顺便把八大排序整理了一下，跟大家分享一下，写的不好，希望大神批评指正。（参考数据结构）

这里是同学推荐的视频（http://www.cnbeta.com/articles/tech/202221.htm），感觉很不错，对于刚学的人来说，看完视频再看代码应该很好理解了，不过就是一下看好几个再加上里面···的音乐，估计有点儿喘不过气，总之还是很清晰的，自己感受吧。

评价算法的指标是：时间、空间和稳定性。

算法特点：

算法名称	时间复杂度	空间复杂度	稳定性
直接插入	O（n2）	O(1)	√
希尔排序	n→∞ O(n(log2n2))	O(1)	×
冒泡排序	O（n2）	O(1)	√
快速排序	O（nlog2n)	好：O（log2n） 坏：O(n)	×
选择排序	O（n2）	O(1)	算法本身是稳定的 采用“交换记录”策略会造成不稳定现象的产生
堆排序	O（nlog2n）	O(1)	×
归并排序	O（nlog2n）	O(n)	√
基数排序	O（d(n+rd)）	O(n+rd)	√

直接插入排序，是当待排序的记录个数比较少并且排序序列的关键字基本有序时，效率较高。

通过构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应的位置并插入。（在具体实现的时候，可以将list[i]从前向后插入比较，也可以从后向前插入比较。这里采用的是从后向前插入比较）

public class Main {

　　/*插入排序*/
　　public static int[] insert_sort(int[] list){    
　　　　int j,temp;
　　　　for (int i = 0; i < list.length; i++) {
　　　　　　j = i - 1;
　　　　　　temp = list[i];
　　　　　　while (j >= 0) {
　　　　　　　　if (temp < list[j]) {
　　　　　　　　　　list[j+1] = list[j];
　　　　　　　　　　list[j] = temp;
　　　　　　　　}
　　　　　　j = j-1;    
　　　　　　}
　　　　}
　　return list;    
　　}

　　public static void main(String[] args) {
　　　　int[] list = new int[]{49,38,65,97,76,13,27,49,55,04};
　　　　int[] result = new int[list.length];
　　　　result = insert_sort(list);
　　　　System.out.println("插入排序：");
　　　　for (int i = 0; i < result.length; i++) {
　　　　　　System.out.print(result[i] + ",");    
　　　　}
　　}
}

注：main函数的调用就写上面的一个，下面就不再写了，毕竟这个大家都可以。

希尔排序又称“缩小增量排序”，也是插入排序的一种。希尔排序实质上是采用分组插入的方法。先将待排序记录序列分割成几组，对每组进行直接插入，然后增加每组的数据量重新分组。就这样经过几次分组排序之后，整个序列基本有序，最后再进行一次直接插入排序。

/*希尔排序*/
public static int[] shell_sort(int[] list){
　　int j,temp,k;
　　int group = list.length/2;

　　while (group>0) {
　　　　for (int i = 0; i < group; i++) {
　　　　　　j = i + group;
　　　　　　while (j <list.length) {
　　　　　　　　temp = list[j];
　　　　　　　　k = j-group;
　　　　　　　　while (k >= 0) {
　　　　　　　　　　if (list[k] > temp) {
　　　　　　　　　　　　list[k+group] = list[k];   //记录后移，直到找到插入位置
　　　　　　　　　　　　list[k] = temp;
　　　　　　　　　　}
　　　　　　　　　　k = k - group;
　　　　　　　　}
　　　　　　j = j + group;    　　    
　　　　　　}    
　　　　}
　　　　group = group / 2;
　　}    
　　return list;    
}

简单选择排序

/*简单选择排序*/
    public static int[] select_sort(int[] list){
        
        int min = list[0],temp;
        
        for (int i = 0; i < list.length; i++) {
            if (list[i] < min) {
                min = list[i];
            }
        }
        
        return list; 
    }

冒泡排序是一种最简单的交换排序方法，是通过两两比较相邻记录的关键词，如果发生逆序，就交换。从而使关键字小的记录就行气泡一样逐渐往上“漂浮”或者是较大的像石块一样“坠落”。当n较大时（数据长度较大）不宜采用此算法。

/*冒泡排序*/
    public static int[] bubble_sort(int[] list){
        int temp;
        for (int i = 0; i < list.length; i++) {
            for (int j = i+1; j < list.length; j++) {
                if (list[i] > list[j]) {
                    temp = list[i];
                    list[i] = list[j];
                    list[j] = temp;    
                }        
            }            
        }        
        return list;
    }

/*快速排序*/
    public static int[] quick_sort(int[] list,int left,int right) {
        int temp,low,high;
        if (left >= right) {
            return list;
        }
        temp = list[left];
        low = left;
        high = right;
        
        while (left < right) {
            while (left < right && list[right] >= temp) {
                right -= 1;                
            }
            list[left] = list[right];
            while (left < right && list[left] <= temp) {
                left += 1;                
            }
            list[right] = temp;
            quick_sort(list, low, left - 1);
            quick_sort(list, left + 1, high);
        }
        return list;        
    }

/*归并排序*/
    public static int[] merge(int[] left,int[] right) {
        
        int i=0,j=0;
        int[] result;
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                result.append(left[i]);
                i += 1;
            }else{
                result.append(right[j]);
                j += 1
            }
            
        }
        
        return result;
        
    }