【回炉重造】-- 复习三种排序

目录

三种排序

选择排序

冒泡排序

插入排序

交换

时间复杂度

---

三种排序

选择排序

首先默认第一位最小，然后从第二位到第n位循环，找到比第一位更小的交换，然后从第二位开始，从第三位到第n位循环，找到比第二位更小的交换，依次循环，因此时间复杂度是O(n2)

    /**
     * 选择排序
     *
     * @param arr
     */
    public static void selectionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                minIndex = arr[j] < arr[minIndex] ? j : minIndex;
            }
            swap(arr, i, minIndex);
        }
    }

冒泡排序

相邻两数之间谁大谁往右，依次将最大数交换到最大下标位置，因此时间复杂度是O(n2)

    /**
     * 冒泡排序
     *
     * @param arr
     */
    public static void sort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

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

插入排序

从左到右，循环到第i位，看左边有没有比自己大的数，如果有则交换，这样循环到哪，这之前都是有序的，依次到最后一位，插入排序和前两个排序不同，如果数本身就是有序的，则只需要循环不需要交换，则时间复杂度是O(n),如果数恰好是逆序的，则最坏的情况下时间复杂度是O(n2)

    /**
     * 插入排序
     *
     * @param arr
     */
    public static void insertionSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
                swap(arr, j, j + 1);
            }
        }
    }

交换

        一种不一样的交换方式

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

^:异或，这个交换无需借助第三个临时变量，实现主要是基于异或运算的如下性质：

        1.任意一个变量X与其自身进行异或运算，结果为0，即X^X=0

        2.任意一个变量X与0进行异或运算，结果不变，即X^0=X

        3.异或运算具有可结合性，即a^b^c=（a^b）^c=a^（b^c）

        4.异或运算具有可交换性，即a^b=b^a

时间复杂度

        时间复杂度就是，算法流程中，假设数据量为N，执行完整个流程，常数操作的数量是一个什么样的关系，确定算法流程的总操作数量与样本数量之间的表达式关系只看表达式最高阶项的部分，所以时间复杂度一定要按最差数据状况来估计。