基础排序之选择、插入、冒泡

基础排序之选择、插入、冒泡

打印一个整数二进制

public class Code01_PrintB {
    public static void main(String[] args) {
        int num = 5;
        print(num);
    }

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

执行结果：

00000000000000000000000000000101

---

一个数的负数的二进制就是这个数(取反+1)之后的数字：

验证：

public class Code01_PrintB {
    public static void main(String[] args) {
        int a = 5;
        int b = -5;
        print(b);
        print(~a + 1);

        System.out.println("=========");
        System.out.println(b);
        System.out.println(~a + 1);
    }

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

执行结果：

11111111111111111111111111111011
11111111111111111111111111111011
=========
-5
-5

选择排序

所谓选择排序就是在给定序列里面选择一个最大的数字，放到最后面，之后这个数字就不参与比较了；再在剩余的序列里面选择一个最大的放在倒数第二位，按照这个规则依次走完整个序列即可。

public class Code02_SelectSort {
    public static void main(String[] args) {
        int[] arr = {7, 4, 5, 6, 3, 2, 4, 1};
        printArray(arr);
        selectSort(arr);
        printArray(arr);
    }

    private static void selectSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        // 0~N-1
        // 0~N-2
        // 0~N-3
        // 0~0
        int N = arr.length;
        for (int i = N - 1; i >= 0; i--) {
            int maxValueIndex = 0;
            for (int j = 0; j <= i; j++) {
                if (arr[maxValueIndex] < arr[j]) {
                    maxValueIndex = j;
                }
            }
            swap(arr, maxValueIndex,i );
        }
    }

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

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

分析一下：

前提：假设数组arr的长度为 N ，那么最后一位的下标就是 N-1

① 第一轮：在0~N-1下标里面，选择一个值最大的数字，把这个数字的下标记为 maxValueIndex，把这个数字和N-1下标的数字做交换

② 第二轮：在0~N-2下标里面，选择一个值最大的数字，把这个数字的下标记为 maxValueIndex，把这个数字和N-2下标的数字做交换

③ 第三轮：在0~N-3下标里面，选择一个值最大的数字，把这个数字的下标记为 maxValueIndex，把这个数字和N-3下标的数字做交换

…

依次进行下去，

最后一轮就是：在0~1下标里面，选择一个值最大的数字，把这个数字的下标记为 maxValueIndex，把这个数字和1下标的数字做交换

冒泡排序

相邻的两个数字进行比较，如果第一个数字比第二个是最大，则交换，直到比较到最后一个元素，这个时候也就找到了最大的数字了。

public class Code03_BubbleSort {
    public static void main(String[] args) {
        int[] arr = {7, 4, 5, 6, 3, 2, 4, 1};
        printArray(arr);
        bubbleSort(arr);
        printArray(arr);
    }

    private static void bubbleSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        int N = arr.length;
        for (int i = N - 1; i >= 1; i--) {
            for (int j = 1; j <= i; j++) {
                if (arr[j - 1] > arr[j]) {
                    swap(arr, j - 1, j);
                }
            }
        }
    }

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

    private static void printArray(int[] arr) {
        for (int j : arr) {
            System.out.print(j + " ");
        }
        System.out.println();
    }
}

分析一下：

前提：假设数组arr的长度为 N ，那么最后一位的下标就是 N-1

① 第一轮：0~N-1，相邻的两个依次比较，找到最大的数字，放到 N-1 位置上

② 第二轮：0~N-2，相邻的两个依次比较，找到最大的数字，放到 N-2 位置上

② 第三轮：0~N-3，相邻的两个依次比较，找到最大的数字，放到 N-3 位置上

…

依次进行下去，

最后一轮就是：在0~1下标里面，相邻的两个依次比较，找到最大的数字，放到 1 位置上

插入排序

在有序序列里面，插入数字，使得新的序列变得有序。

public class Code04_InsertSort {
    public static void main(String[] args) {
        //int[] arr = {7, 4, 5, 6, 3, 2, 4, 1};
        //int[] arr = {1,2,3,4};
        int[] arr = {5,4,3,2,1};
        printArray(arr);
        insertSort(arr);
        printArray(arr);
    }

    private static void insertSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        int N = arr.length;
        // 0~1  位置是需要变成有序的，需要插入   1
        // 0~2  位置是需要变成有序的，需要插入   2
        // 0~N-1位置是需要变成有序的，需要插入   N-1
        for (int i = 1; i < N; i++) {
            int newValueIndex = i;
            for (int j = i - 1; j >= 0; j--) {
                if (arr[newValueIndex] < arr[j]) {
                    swap(arr, newValueIndex, j);
                    newValueIndex--;
                }else {
                    break;
                }
            }
        }
    }

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

    private static void printArray(int[] arr) {
        for (int j : arr) {
            System.out.print(j + " ");
        }
        System.out.println();
    }
}

分析一下：

前提：假设数组arr的长度为 N ，那么最后一位的下标就是 N-1

① 第一轮：0-0为有序序列，需要插入的是1位置的数字，0~1是插入后需要变得有序

② 第二轮：0-1为有序序列，需要插入的是2位置的数字，0~2是插入后需要变得有序

② 第三轮：0-2为有序序列，需要插入的是3位置的数字，0-3是插入后需要变得有序

…

依次进行下去，

最后一轮就是：0-N-1为有序序列，需要插入的是N-1位置的数字，0~N-1是插入后需要变得有序