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

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