先来看看8种排序之间的关系：

 

一、直接插入排序

代码如下

 1 public void inerrtSort(int[] a) {
 2         int len = a.length;
 3         for (int i = 1; i < len; i++) {
 4             int tem = a[i];
 5             int j;
 6             for ( j = i - 1; j >= 0 && tem < a[j]; j--) {
 7                 // tem < a[j]只能在for里面判断 否则就算找tem >= a[j]也会一直到j=0，错误移动元素
 8                 a[j+1 ] = a[j];//向后移动
 9             }
10             a[j+1] =tem;
11         }
12     }
//看起来简单 实则有太多细节

 

二、希尔排序

 public  void shellSort(int[] list) {
        int len = list.length ;
        // 取增量
        int gap = len / 2;

        while (gap >= 1) {
            // 无序序列
            for (int i = gap; i < len; i++) {
                int temp = list[i];
                int j;

                // 有序序列
                for (j = i - gap; j >= 0 && list[j] > temp; j = j - gap) {
                    list[j + gap] = list[j];
                }
                list[j + gap] = temp;
            }

            // 缩小增量
            gap = gap / 2;
        }
    }

 

第三、简单选择排序

public void selectSort(int[] a) {
        for (int i = 0; i < a.length ; i++) {
            int min= i;
            for (int j = i+1; j <a.length ; j++) {
               if(a[min] > a[j]) min = j;
            }
            if(min != i){
                int tem = a[min];
                a[min] = a[i];
                a[i] = tem;
            }

        }

    }

　　

 

第四、堆排序

 

 

 

 

第五、冒泡排序

public  void bubbleSort(int[] a) {
        int len = a.length-1;

        for (int i = 0; i < len; i++) {
            for (int j = 0; j <len-i ; j++) {
                if (a[j] > a[j+1]){
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }

 

　第六、快排

 public static void quickSort(int[] list, int left, int right) {
        if (left < right) {
            // 分割数组，找到分割点
            int point = partition(list, left, right);

            // 递归调用，对左子数组进行快速排序
            quickSort(list, left, point - 1);
            // 递归调用，对右子数组进行快速排序
            quickSort(list, point + 1, right);
        }
    }

    /**
     * 分割数组，找到分割点
     */
    public static int partition(int[] list, int left, int right) {
        // 用数组的第一个元素作为基准数
        int first = list[left];
        while (left < right) {
            while (left < right && list[right] >= first) {
                right--;
            }
            // 交换
            swap(list, left, right);

            while (left < right && list[left] <= first) {
                left++;
            }
            // 交换
            swap(list, left, right);
        }
        // 返回分割点所在的位置
        return left;
    }

    /**
     * 交换数组中两个位置的元素
     */
    public static void swap(int[] list, int left, int right) {
        int temp;
        if (list != null && list.length > 0) {
            temp = list[left];
            list[left] = list[right];
            list[right] = temp;
        }
    }

 

第七、归并排序

 

第八、基数排序

 

参考：https://blog.csdn.net/jiangwei0910410003/article/details/38261783