java常用八大排序法

最近查资料发现java排序挺有意思的，其中包含常见八种具有代表性的排序法；笔者觉得排序的功能重要，但更重要的是排序的思想；所以简单叙述一下常见排序方法名称，并用代码举例。

A.插入排序（直接插入排序、希尔排序）;
B.交换排序（冒泡排序、快速排序）;
C.选择排序（直接选择排序、堆排序）;
D.归并排序;
E.分配排序（基数排序）;

所需辅助空间最多：归并排序;
所需辅助空间最少：堆排序;
平均速度最快：快速排序;

不稳定：快速排序，希尔排序，堆排序。

代码块：

package com.sinolife.mtrs.apply.controller;

import java.util.Arrays;

/** 
 * @author  delin Li 
 * @version createTime：2017-12-7下午04:10:37 
 * @Description  
 */
public class TestSort {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] ins = {1,3,53,7,81,2,5,71,9};
//        insertSort(ins);//直接插入排序
//        shellSort(ins);//希尔排序，
//        sampleSelectSort(ins);//简单选择排序
//        heapSort(ins);//堆排序
//        bubbleSort(ins);//冒泡 排序
//        quikSort(ins,0,ins.length-1);//快速排序
//        mergeSort(ins,0,ins.length-1);//归并排序
          radixSort(ins,10,2);//基排序
          print(ins);
    }

    public static void print(int[] data) {  
        for (int i = 0; i < data.length; i++) {  
            System.out.print(data[i] + "  ");  
        }   
    }  
  
    //直接插入排序
    /*public static void insertSort(int arg[]){
        for(int i=1;i<arg.length;i++){//将第一个数当做已经排好序的值，然后将后边无序数依次插入到已经排好的列表中
            int j;
            int temp = arg[i];//插入的数值
            for(j=i;temp<arg[j-1]&&j>0;j--){
                arg[j] = arg[j-1];////通过循环，逐个后移一位找到要插入的位置。    
            }
            arg[j]=temp;//插入
        }
    }*/
    
    //希尔
    /*public static void shellSort(int a[]){
        int n = a.length;
        for(int i = n/2;i>0; i /=2){
            for(int j = i;j<n;j++){//每个元素与自己组内的数据进行直接插入排序  
                if(a[j]<a[j-i]){
                    int temp = a[j];
                    int k = j-i;
                    while(k>=0&&a[k]>temp){
                        a[k+i] = a[k];
                        k -=i;
                    }
                    a[k+i] = temp;
                }
            }
        }
    }*/
     
    //简单选择排序
    /*public static void sampleSelectSort(int[] a){
        int minV;//临时保存最小值
        int minI;//临时保存最小值下标
        for(int i= 0;i<a.length-1;i++){
            minV = a[i];
            minI = i;
            for(int j = i+1;j<a.length;j++){
                if(a[j]<minV){
                    minV = a[j];
                    minI = j;
                }
            }
            if(minV != a[i] && minI !=i){
                a[minI] = a[i];
                a[i] = minV;
            }
        }
    }*/
    
    //堆排序
    /*public static void swap(int[] data, int i, int j) {  
        if (i == j) {  
            return;  
        }  
        data[i] = data[i] + data[j];  
        data[j] = data[i] - data[j];  
        data[i] = data[i] - data[j];  
    }  
  
    public static void heapSort(int[] data) {  
        for (int i = 0; i < data.length; i++) {  
            createMaxdHeap(data, data.length - 1 - i);  
            swap(data, 0, data.length - 1 - i);  
            print(data);  
        }  
    }  
  
    public static void createMaxdHeap(int[] data, int lastIndex) {  
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {  
            // 保存当前正在判断的节点  
            int k = i;  
            // 若当前节点的子节点存在  
            while (2 * k + 1 <= lastIndex) {  
                // biggerIndex总是记录较大节点的值,先赋值为当前判断节点的左子节点  
                int biggerIndex = 2 * k + 1;  
                if (biggerIndex < lastIndex) {  
                    // 若右子节点存在，否则此时biggerIndex应该等于 lastIndex  
                    if (data[biggerIndex] < data[biggerIndex + 1]) {  
                        // 若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的值  
                        biggerIndex++;  
                    }  
                }  
                if (data[k] < data[biggerIndex]) {  
                    // 若当前节点值比子节点最大值小，则交换2者得值，交换后将biggerIndex值赋值给k  
                    swap(data, k, biggerIndex);  
                    k = biggerIndex;  
                } else {  
                    break;  
                }  
            }  
        }  
    }*/  
    
     //冒泡排序
     /*public static void bubbleSort(int[] a){
         for (int i = 0; i < a.length-1; i++) {
            for (int j = i; j < a.length-i-1; j++) {
                if(a[j]>a[j+1]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
     }*/
     
    //快速排序
    /*public static void quikSort(int data[], int start, int end) {  
        
            if (end - start <= 0) {  
                return;  
            }  
            int last = start;  
            for (int i = start + 1; i <= end; i++) {  
                if (data[i] < data[start]) {  
                    int temp = data[++last];  
                    data[last] = data[i];  
                    data[i] = temp;  
                }  
            }  
            int temp = data[last];  
            data[last] = data[start];  
            data[start] = temp;  
            quikSort(data, start, last - 1);  
            quikSort(data, last + 1, end);  
        }*/
    
    //归并排序
    /*public static void mergeSort(int data[], int start, int end) {  
            if (start < end) {  
                int mid = (start + end) / 2;  
                mergeSort(data, start, mid);  
                mergeSort(data, mid + 1, end);  
                merge(data, start, mid, end);  
            }  
        }  
      
        public static void merge(int data[], int start, int mid, int end) {  
            int temp[] = new int[end - start + 1];  
            int i = start;  
            int j = mid + 1;  
            int k = 0;  
            while (i <= mid && j <= end) {  
                if (data[i] < data[j]) {  
                    temp[k++] = data[i++];  
                } else {  
                    temp[k++] = data[j++];  
                }  
            }  
      
            while (i <= mid) {  
                temp[k++] = data[i++];  
            }  
            while (j <= end) {  
                temp[k++] = data[j++];  
            }  
      
            for (k = 0, i = start; k < temp.length; k++, i++) {  
                data[i] = temp[k];  
            }  
        }*/ 
        
      //基排序
        public static void radixSort(int[] data, int radix, int d) {  
            // 缓存数组  
            int[] tmp = new int[data.length];  
            // buckets用于记录待排序元素的信息  
            // buckets数组定义了max-min个桶  
            int[] buckets = new int[radix];  
      
            for (int i = 0, rate = 1; i < d; i++) {  
      
                // 重置count数组，开始统计下一个关键字  
                Arrays.fill(buckets, 0);  
                // 将data中的元素完全复制到tmp数组中  
                System.arraycopy(data, 0, tmp, 0, data.length);  
      
                // 计算每个待排序数据的子关键字  
                for (int j = 0; j < data.length; j++) {  
                    int subKey = (tmp[j] / rate) % radix;  
                    buckets[subKey]++;  
                }  
                for (int j = 1; j < radix; j++) {  
                    buckets[j] = buckets[j] + buckets[j - 1];  
                }  
                // 按子关键字对指定的数据进行排序  
                for (int m = data.length - 1; m >= 0; m--) {  
                    int subKey = (tmp[m] / rate) % radix;  
                    data[--buckets[subKey]] = tmp[m];  
                } 
                rate *= radix;  
            }  
        } 
}

如有错误，请朋友们提出！