1、位运算

public static void print(int nums){
    for (int i = 31; i >= 0 ; i--) {
        System.out.print( (nums & (1 << i )) == 0 ? "0" : "1" );
    }
}

2、选择排序

/**
 * @description: 选择排序
 * @params: arr 传入的数组
 * 思路：
 *  1. 在数组中找到最小的值，放到索引为 0 的位置
 *  2. 接着从 1 - n-1 的范围寻找最小值，放到索引为 1 的位置
 *  3. 接着从 2 - n-1 的范围寻找最小值，放到索引为 2 的位置
 *  4. 依次遍历
 *  
 */
public static void selectSort(int[] arr){
    if(arr == null || arr.length < 2)
        return;
    int N = arr.length;
    for (int i = 0; i < N; i++) {
        int minValue = i;
        for (int j = i + 1; j < N; j++) {
            if(arr[i] > arr[j])  swap(arr, i, j);
        }
    }

}

3、冒泡排序

public static void bubbleSort(int[] arr){
    /**
     * @description 冒泡排序
     * @param 需要排序的数组
     * 思路：
     *  1. 从后往前依次扫描，遇到小的就交换
     */

    if(arr.length < 2 || arr == null)
        return;

    int N = arr.length;
    for (int j = 0; j < N - 1; j++) {
        for (int i = N - 1; i > 0; i--) {
            if(arr[i] < arr[i - 1]){
                swap(arr, i, i - 1);
            }
        }
    }
}

4、插入排序

/**
 * @description: 插入排序
 * @parms：arr 需要排序的数组
 * 算法思想
 *      1. 使 0 - 1 索引范围内的数有序
 *      2. 使 0 - 2 索引范围内的数有序
 *      3. 使 0 - 3 索引范围内的数有序
 *      4. 依次类推  0 - n
 */
public static void insertSort(int[] arr){
    int N = arr.length;

    for (int i = 1; i < N; i++) {
        int newNumIndex = i;
        while(newNumIndex - 1 >= 0 && arr[newNumIndex - 1] > arr[newNumIndex]){
            swap(arr,newNumIndex - 1, newNumIndex);
            newNumIndex--;
        }
    }
}

5、插入排序（优化）

public static void insertSort(int[] arr){
    int N = arr.length;
    for (int i = 1; i < N; i++) {
        for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
            swap(arr, j, j + 1);
        }
    }
}