Java排序算法

冒泡排序

升序：首先从数组第一个元素开始，和相邻元素比较，如果索引比较小的元素大于索引比较大的元素，则两个数据交换位置，一轮过后，最后一个元素是最大的。第二轮和第一轮一样，只是最后一个元素因为已经确定是最大的，所以不用比较。以此类推，降序参考升序。

        int[] arr = {0, 6, 3, 8, 11, 2, 9, 1};
        int n = arr.length;
        for (int i = n - 1; i > 0; i--) {//每一轮比较和交换的无序数组的最大索引递减
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + "\t ");
        }
    }

选择排序

升序：首先从数据第一个元素开始扫描待排序数组，选出最小的元素，放到数组的第一个元素。第二轮从第二个元素开始扫描。以此类推，降序参考升序。

public static void main(String[] args) {
        int[] arr = {0, 6, 3, 8, 11, 2, 9, 1};
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {//每一轮被选择出来的最小值应该被放置的位置索引递增，最大是倒数第二个
            int min = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[min] > arr[j]) {
                    min = j;
                }
            }
            if (min != i) {
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }

        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + "\t ");
        }
    }

选择排序比冒泡排序交换次数少，但是比较次数是一样的，所以效率稍高。

插入排序

首先把数组第二个元素当作标记元素，标记元素用临时变量保存，假设标记元素和它右边的是未排序的，左边的是已排序的，将标记元素插入到它左边的已排序数组中正确的位置上。然后标记元素索引递增，再进行下一轮。

升序：将标记元素和它左边的第一个元素比较，如果标记元素比较小，就将它左边的元素右移，接着比较标记元素和左边的第二个元素，以此类推，直到找到标记元素应该放置的位置。

public static void main(String[] args) {
        int[] arr = {0, 6, 3, 8, 11, 2, 9, 1};
        int n = arr.length;
        for (int i = 1; i < n; i++) {//标记元素的索引递增
            int temp = arr[i];
            int j = i;
            while (j > 0 && arr[j - 1] > temp) {
                arr[j] = arr[j - 1];
                j--;
            }
            arr[j] = temp;
        }

        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + "\t ");
        }
    }

快速排序

选取一个关键数据，选取方法有多种，为了简单，直接取第一个元素，我们将其值放入到临时变量中。设置两个索引low和high，low表示下一个比关键数据小的数据可以放入的位置，初始是第一个位置，high表示下一个比关键数据大的数据可以放入的位置，初始是最后一个位置。初始low是0，其值保存在临时变量中，所以想象现在low的位置是空的，先从high开始和关键数据比较，如果high比关键数据大，high--，继续比较，如果high比关键数据小，就把high的值放到low的位置上。因为high的值被放在low的位置上，因此想象现在high的位置为空的，从low开始和关键数据比较，如果low比关键数据小，low++，继续比较，如果low比关键数据大，就把low的值放到high的位置上。现在l想象ow的位置又是空的，如果low小于high，就继续上面描述的比较和置换，直到low等于high，将临时变量的值放在low=high的位置上，返回关键数据保存的位置，在这个两端又各自递归进行快速排序。

    private static int getMiddle(int[] ints, int low, int high) {
        int key = ints[low];
        while (low < high) {
            while (low < high && ints[high] >= key) {
                high--;
            }
            ints[low] = ints[high];
            while (low < high && ints[low] <= key) {
                low++;
            }
            ints[high] = ints[low];
        }
        ints[low] = key;
        return low;
    }

     private static void sort(int[] ints, int low, int high) {
        if (low < high) {
            int middle = getMiddle(ints, low, high);
            sort(ints, middle + 1, high);
            sort(ints, low, middle - 1);
        }
    }

    public static void main(String[] args) {
        int[] arr = {0, 6, 3, 8, 11, 2, 9, 1};
        sort(arr, 0, arr.length - 1);

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t ");
        }
    }