Java学习笔记——排序算法之简单排序

男儿何不带吴钩，收取关山五十州。请君暂上凌烟阁，若个书生万户侯？

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　——南园十三首

三种排序法：

1、冒泡法

2、简单选择法

3、直接插入法

 

上代码：

1、冒泡排序

public class BubbleSort {

    //最简单的排序，从0开始逐个对比往上冒
    public static void bubbleSort(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]) {
                    arr[i] = arr[i]^arr[j];
                    arr[j] = arr[i]^arr[j];
                    arr[i] = arr[i]^arr[j];
                }
            }
        }
    }
    //正宗冒泡，正向
    public static void bubbleSortA(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-i-1; j++) {
                if (arr[j]>arr[j+1]) {
                    arr[j] = arr[j]^arr[j+1];
                    arr[j+1] = arr[j]^arr[j+1];
                    arr[j] = arr[j]^arr[j+1];
                }
            }
        }
    }
    //反向
    public static void bubbleSortB(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = arr.length-1; j > i; j--) {
                if (arr[j-1]>arr[j]) {
                    arr[j] = arr[j]^arr[j-1];
                    arr[j-1] = arr[j]^arr[j-1];
                    arr[j] = arr[j]^arr[j-1];
                }
            }
        }
    }
    //优化冒泡
    public static void bubbleSortA0(int[] arr) {
        boolean flag = true;
        for (int i = 0; i < arr.length-1 && flag; i++) {
            flag = false;
            for (int j = arr.length-1; j > i; j--) {
                if (arr[j-1]>arr[j]) {
                    arr[j] = arr[j]^arr[j-1];
                    arr[j-1] = arr[j]^arr[j-1];
                    arr[j] = arr[j]^arr[j-1];
                    flag = true;//若没有发生交换，说明每对的前一位都不比后一位更大。无需再次排序
                }
            }
        }
    }
}

2、简单选择排序，跟冒泡第一个思路差不多。区别在于不是每次都交换，而是记录最值的下标位置，每趟的最后交换

public class SimpleSelectSort {

    //简单冒泡的升级版，内外层循环不变，赋值n次，交换一次
    public static void simpleSelectSort(int[] arr){
        int min;
        for (int i = 0; i < arr.length-1; i++) {
            min = i;
            for (int j = i+1; j < arr.length; j++) {
                if (arr[min] > arr[j]) {
                    min = j;
                }
            }
            if (min != i) {
                arr[min] = arr[min] ^ arr[i];
                arr[i] = arr[min] ^ arr[i];
                arr[min] = arr[min] ^ arr[i];
            }
        }
    }
}

3、直接插入法，这个思路就很好了，类似于捋牌。

public class StraightInsertionSort {

    //该方法从第二位开始取出，如果比前面小插入，前面的后移，想象理牌5,3,4,6,2，同花顺
    public static void straightinsertionsort(int[] arr){
        int temp;
        for (int i = 1,j = 0; i < arr.length; i++) {
            if (arr[i]<arr[i-1]) {
                temp = arr[i];//取出牌
                j = i-1;//给内层循环赋初值
                while (j>=0 && arr[j] > temp) {
                    arr[j+1] = arr[j];//比牌大的后移
                    j--;
                }
                arr[j+1] = temp;//插入牌
            }
        }
    }
}