java中各种经典排序（冒泡 选择 插入 希尔等）

import java.util.Arrays;

public class ArraySort {
    public static void main(String[] args) {
        int[] arr = { 12, 23, 14, 5, 64, 35, 42 };
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        // bubbleSort(arr);
        // selectSort(arr);
        // selectSort_2(arr);
        // insertSort(arr);
        // insertSort_2(arr);
        shellSort(arr);
        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 冒泡排序 重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
     * 走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
     * 
     * @param arr
     */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            boolean flag = true;// 定义一个flag标记，用于判断当有序之后就跳出循环，减少外层循环次数。
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
    }

    /**
     * 选择排序 每一次从待排序的数据元素中选出最小(或最大)的一个元素， 存放在序列的起始位置，直到全部待排序的数据元素排完。
     * 
     * @param arr
     * @param a
     * @param b
     */
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    swap(arr, i, j);
                }
            }
        }
    }

    /**
     * 选择排序2 效率高
     * 
     * @param arr
     */
    public static void selectSort_2(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int num = arr[i];
            int index = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (num > arr[j]) {// 把遇到的小的值给num，角标给index，只要index发生了改变
                    num = arr[j]; // 则代表需要交换
                    index = j;
                }

            }
            if (index != i) {
                swap(arr, i, index);
            }
        }
    }

    /**
     * 插入排序 插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。
     * 插入排序方法分直接插入排序和折半（二分）插入排序两种
     * 
     * @param arr
     * @param a
     * @param b
     */
    public static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            if (arr[i - 1] > arr[i]) {
                int temp = arr[i];// 待插入的元素
                int j = i;
                while (j > 0 && arr[j - 1] > temp) {// 将大于temp的往后移一位
                    arr[j] = arr[j - 1];
                    j--;
                }
                arr[j] = temp;
            }
        }
    }

    /**
     * 二分插入排序 二分法插入排序的思想和直接插入一样，只是找合适的插入位置的方式不同， 这里是按二分法找到合适的位置，可以减少比较的次数。
     * 
     * @param arr
     */
    public static void insertSort_2(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int temp = arr[i];
            int left = 0;
            int right = i - 1;
            int mid = 0;
            while (left <= right) {
                mid = (left + right) / 2;
                if (temp < arr[mid]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            }
            for (int j = i - 1; j >= left; j--) {
                arr[j + 1] = arr[j];
            }
            if (left != i) {
                arr[left] = temp;
            }
        }
    }

    /**                        希尔排序
     *  希尔排序(Shell Sort)是插入排序的一种 思想： 先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。
     * 所有距离为dl的倍数的记录放在同一个组中。 先在各组内进行直接插人排序；然后，取第二个增量d2<d1重复上述的分组和排序，
     * 直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
     * 
     * 
     *             //从大到小
     * @param arr
     * @param a
     * @param b
     */

    public static void shellSort(int[] arr) {
        int j = 0;
        int temp = 0;
        for (int increment = arr.length / 2; increment > 0; increment /= 2) {
            for (int i = increment; i < arr.length; i++) {
                temp = arr[i];
                for (j = i; j >= increment; j -= increment) {
                    if (temp > arr[j - increment]) {
                        arr[j] = arr[j - increment];
                    } else {
                        break;
                    }
                }
                arr[j] = temp;
            }
        }
    }
　　

                //从小到大排序
    public static void shellSort_2(int[] arr) {

        int j;
        int len = arr.length;
        for (int val = len >> 1; val > 0; val >>= 1) {//len>>1即len/2
            // 下面是对本次的所有分组做直接插入排序
            for (int i = val; i < len; i++) {
                int temp = arr[i];
                /*
                 * 为什么每次都用temp比较呢？ 因为直接插入就是找到temp的合适位置。
                 * 为什么temp<arr[j-val]这个条件可以放在for内呢？ 因为原来的组内数据已经有序，找到位置就停止便是。
                 * 不甚理解的去看直接插入排序吧。
                 */
                for (j = i; j >= val && temp < arr[j - val]; j -= val) {
                    /*
                     * 为什么是arr[j-val]不是arr[j]呢？
                     * 因为j=i开始的，而且条件是j>=val&&temp<arr[j-val]
                     */
                    arr[j] = arr[j - val];
                }
                /*
                 * 注意不是arr[i] = temp 直接插入排序也是这样的。 为什么呢？ 因为j是位置，i是待插入元素
                 */
                arr[j] = temp;
            }
        }
    }

    private static void swap(int[] arr, int a, int b) {
        int temp;
        temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}