几种见的排序:冒泡排序、快速排序、希尔排序、插入排序、二分插入排序、选择排序

1.冒泡排序：
 

/**
     * 冒泡排序
     * 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。
     * 走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
              这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），
              就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
     */
    public static void sort(int[] a){
        int temp;
        for (int i = 0; i < a.length; i++) {
            for (int j = i+1; j < a.length; j++) {
                if (a[i] > a[j]) {
                     temp = a[i];
                     a[i] = a[j];
                     a[j] = temp;
                }
                continue;
            }

        }
        for (int i : a) {
            System.out.println(i);
        }

    }

2. 选择排序

/**
     * 选择排序
     * 它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，
     * 然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方
     * @param a
     */
    public static void selectionSort(int[] a){
        int min; int temp;
        for (int i = 0; i < a.length; i++) {
            min = a[i];
            for (int j = i+1; j < a.length; j++) {
                if (a[i] > a[j]) {
                    temp = a[j];
                    a[j] = min;
                    a[i] = temp;
                    min = temp;
                }

            }
        }
        for (int i : a) {
            System.out.println(i);
        }
    }

 

3.插入排序

    /**
     * 直接插入排序
     * 其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列
     * @param a
     */
    public static void insertSort(int[]a){
        int temp;int j ;//待插入数据
        for (int i = 1; i < a.length; i++) {
            temp = a[i];
            for (j = i-1; j >= 0; j--) {
                if (temp < a [j]) {
                    a[j+1] = a[j];
                }else {
                    break;
                }
            }
            a[j+1] = temp;
        }
        for (int i : a) {
            System.out.println(i);
        }
    }

4.二分插入排序

    /**
     *  二分插入排序；
     *  具体思想是 ，待插入数据 i  遍历 i之前 的数据。找到插入的位置，其他排好序的 后移，按照 二分法来查找插入的位置。
     * @author wangwenzhao
     * @param a
     */
    public static void binaryInsertSort(int[] a){

        int temp;

        for (int i = 0; i < a.length; i++) {
            temp = a[i];
            int left = 0;
            int right = i-1;

            while(left <= right) {
                int mid = (left + right)/2;
                if (temp <= a[mid]) {
                    right = mid-1;
                }else {
                    left = mid+1;
                }

            }

            for (int j = i-1; j >= left; j--) {
                a[j+1] = a[j];
            }
            a[left] = temp;

        }

        for (int i : a) {
            System.out.println(i);
        }

    }

5.希尔排序

/**
     * 希尔排序，设置 增量   按照增量分组比较
     * 希尔排序是把记录按下标的一定增量分组，
     * 对每组使用直接插入排序算法排序；
     * 随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
     * @param a
     */
    public static void ShellSort(int[] a){

        int zl = a.length/2;
        int temp;
        while(true) {
        for (int i = 0; i < a.length; i++) {
            temp = a[i];
           for (int j = i+zl; j < a.length; j+=zl) {
               if (a[j] < a[i] ) {
                   a[i] = a[j];
                   a[j] = temp;

        }

        }
        }
        if (zl == 1) {
            break;
        }
        zl--;

        }
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }

    }

6. 快速排序：

    /**
     * 快速排序：
     * 它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分
     * ，其中一部分的所有数据都比另外一部分的所有数据都要小，
     * 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
     * @param a
     */
    private static void quickSort(int[] a, int low, int high) {
        if(low<high){
            int middle = getMiddle(a,low,high);
            quickSort(a, 0, middle-1);
            quickSort(a,middle+1,high);
        }
    }

/**
 * 获取中间下标
 * @param a
 * @param low
 * @param high
 * @return
 */
private static int getMiddle(int[] a, int low, int high) {
    int temp = a[low];//基准元素
    while(low<high){
        while(low<high&&a[high]>=temp){
            high--;
        }
        a[low] = a[high];
        while(low<high&&a[low]<=temp){
            low++;
        }
        a[high] = a[low];
    }
    a[low] = temp;//插入到排序后正确的位置
    return low;
}