1. 排序算法

1.1 选择排序

/**
 * <p>@Description 选择排序 </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2021-01-30 </p>
 **/
public class Code03_SelectionSort {

    /**
     * 先定义一个给数组排序的方法
     * @param arr
     */
    public static void selectSort(int[] arr){
        //先考虑边界值 null 或者 长度小于2 都不需要排序
        if(arr == null || arr.length < 2){
            return;
        }
        /*
            0 ~ N-1 位置选出最小值放到0的位置
            1 ~ N-1 位置选出最小值放到1的位置
            2 ~ N-1 位置选出最小值放到2的位置
            3 ~ N-1 位置选出最小值放到3的位置
            ...
            每次都需要遍历数组的整个长度，所以需要一个值 即数组的长度
            
            28—37行的代码逻辑可以理解为：0~N-1的位置，选出一个最小值进行交换；1~N-1的位置，选出一个最小值进行交换......
         */
        int arr_length = arr.length;
        for (int i = 0; i < arr_length; i++) {
            //i从0的位置出发
            //假设每次出发的i位置数我们先当作最小值（只看到i位置，没看其他位置的数时，本身也是它最小，因为就它自己一个值）
            int minValueIndex = i;
            for (int j = i + 1; j < arr_length; j++) {
                //j从i+1出发（即i的下一个位置），遍历的每一个数都和i位置上的数进行比较，如果j位置小于i位置的数，那最小值的下标索引值变为j
                minValueIndex = arr[j] < arr[minValueIndex] ? j : minValueIndex;//这样一来，最小值的下标就找到了，即为minValueIndex
            }
            //i位置上的数和minValueIndex位置上的数进行交换
            swap(arr, i, minValueIndex);
        }

    }

    /**
     * 将数组i位置和j位置的数进行交换
     * @param arr
     * @param i
     * @param j
     */
    public static void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;

    }

    /**
     * 提供一个方法打印数组
     * @param arr
     */
    public  static void printArr(int[] arr){

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

    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {2,8,1,5,-6,0,1,-4,6,7,5};
        printArr(arr);//先打印排序之前的数组
        selectSort(arr);//从小到大对数组进行排序
        printArr(arr);//再打印排序之后的数组
    }
}

1.2 冒泡排序

/**
 * <p>@Description 冒泡排序 </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2021-01-30 </p>
 **/
public class Code04_BubbleSort {

    /*
        将一个数组冒泡排序
        0和1位置比较，1位置大于0位置，交换
        1和2位置比较，2位置大于1位置，交换
        N-2和N-1位置比较...
        上述比较后，最大的数在N-1位置

        再重复上述步骤，将0至N-2位置比较、交换
     */
    public static void bubbleSort(int[] arr){
        if(arr == null || arr.length < 2){
            return;
        }
        /*
            0~N-1位置 干一坨事
            0~N-2位置 干一坨事
            0~end位置 干一坨事
         */
        int arr_length = arr.length;
        //控制外层每次干事的范围
        for (int end = arr_length-1; end >= 0; end--) {
            //每次都在0~end上干一坨事
            //0和1位置比较，1和2位置比较，end-1和end位置比较
            for(int second = 1; second <= end; second++){
                if(arr[second] < arr[second -1]){
                    swap(arr, second-1, second);
                }
            }
        }

    }

    public static void swap(int[] arr, int i, int j){
        int temp = arr[j];
        arr[j] = arr[i];
        arr[i] = temp;
    }

    //打印数组
    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {4,7,2,4,1,8,2,0,1,6,3,9};
        printArr(arr);
        bubbleSort(arr);
        printArr(arr);
    }
}

1.3 插入排序

/**
 * <p>@Description 插入排序 </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2021-01-30 </p>
 **/
public class Code05_insertSort {

    /**
     * 插入排序大概意思：
     *              0~0位置完成有序 不需要做 已完成
     *              0~1位置完成有序 1位置向前看1个位置(即0位置),如果0位置大于1位置 交换
     *              0~2位置完成有序 2位置向前看1个位置（即1位置），如果1位置大于2位置 交换
     *              0~3位置完成有序
     *              0~N位置完成有序 N位置向前看1个位置（即N-1位置）,如果N-1位置大于N位置 交换
     * @param arr
     */
    public static void insertSort(int[] arr){
        for (int currentIndex = 1; currentIndex < arr.length; currentIndex++) {
            //当前索引的前一个位置；当前索引前一个位置有值 且 前一个位置的值大于后一个位置 交换；前一个位置的索引-1（再继续和左边的进行比较）
            for(int preIndex = currentIndex-1; preIndex >= 0 && arr[preIndex] > arr[preIndex + 1]; preIndex--){
                swap(arr, preIndex, preIndex + 1);
            }
        }
    }

    /**
     * 数组arr的i位置数和j位置数进行交换
     * @param arr
     * @param i
     * @param j
     */
    public static void swap(int[] arr, int i, int j){
        int temp = arr[j];
        arr[j] = arr[i];
        arr[i] = temp;
    }

    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {4,7,2,4,1,8,2,0,1,6,3,9,1};
        printArr(arr);
        insertSort(arr);
        printArr(arr);
    }
}

2. 类型输出

2.1 X类型的数值以Y进制输出

2.1.1 int类型以二进制输出

/**
 * <p>@Description 将一个数已二进制打印 </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2021-01-29 </p>
 **/
public class Code01_PrintBinary {

    public static void printToBinary(int num){
        /*
        * int存储时转换为32位二进制
        * 任何数和1与的结果都为它原本的值，1左移n位再和那个数进行与运算后，如果该数本身位的值为1，那结果就是1，如果该数本身位的值为0，和0进行与运算后结果还是0
        * 理解一下 num & (1 << i)  num 与 左移i位的1 进行与运算； 1左移i位就单纯理解1向左移动了i位，右边用0填补
        * */
        for (int i = 31; i >= 0; i--) {
            System.out.print((num & (1 << i)) == 0 ? "0" : "1");
        }
        System.out.println();
    }

    public static void main(String[] args) {
//        int num = 8;
//        printToBinary(num);
//
//        int max = Integer.MAX_VALUE;
//        printToBinary(max);

        printToBinary(-8);
        printToBinary(8);
    }
}