• 左神基础班第一课

    之前一直在犹豫ACM，要不要走下去，一些课程也没有成体系，东一榔头，西一棒槌。加油吧，学到的技术就是自己的。

    左神首先讲了时间复杂度的概念，很通俗易懂，

    简单来说，就是看变化的趋势幅度，突出主要因素，忽略次要因素。

    接下来，便是冒泡排序，代码如下。

    1. package basic_class_01;
    2. import java.util.Arrays;
    3. public class Code_00_BubbleSort {
    4.     public static void bubbleSort(int[] arr) {
    5.         if (arr == null || arr.length < 2) {
    6.             return;
    7.         }
    8.         for (int e = arr.length - 1; e > 0; e--) {
    9.             for (int i = 0; i < e; i++) {
    10.                 if (arr[i] > arr[i + 1]) {
    11.                     swap(arr, i, i + 1);
    12.                 }
    13.             }
    14.         }
    15.     }
    16.     public static void swap(int[] arr, int i, int j) {
    17.         arr[i] = arr[i] ^ arr[j];
    18.         arr[j] = arr[i] ^ arr[j];
    19.         arr[i] = arr[i] ^ arr[j];
    20.     }
    21.     // for test
    22.     public static void comparator(int[] arr) {
    23.         Arrays.sort(arr);
    24.     }
    25.     // for test
    26.     public static int[] generateRandomArray(int maxSize, int maxValue) {
    27.         int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
    28.         for (int i = 0; i < arr.length; i++) {
    29.             arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
    30.         }
    31.         return arr;
    32.     }
    33.     // for test
    34.     public static int[] copyArray(int[] arr) {
    35.         if (arr == null) {
    36.             return null;
    37.         }
    38.         int[] res = new int[arr.length];
    39.         for (int i = 0; i < arr.length; i++) {
    40.             res[i] = arr[i];
    41.         }
    42.         return res;
    43.     }
    44.     // for test
    45.     public static boolean isEqual(int[] arr1, int[] arr2) {
    46.         if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
    47.             return false;
    48.         }
    49.         if (arr1 == null && arr2 == null) {
    50.             return true;
    51.         }
    52.         if (arr1.length != arr2.length) {
    53.             return false;
    54.         }
    55.         for (int i = 0; i < arr1.length; i++) {
    56.             if (arr1[i] != arr2[i]) {
    57.                 return false;
    58.             }
    59.         }
    60.         return true;
    61.     }
    62.     // for test
    63.     public static void printArray(int[] arr) {
    64.         if (arr == null) {
    65.             return;
    66.         }
    67.         for (int i = 0; i < arr.length; i++) {
    68.             System.out.print(arr[i] + " ");
    69.         }
    70.         System.out.println();
    71.     }
    72.     // for test
    73.     public static void main(String[] args) {
    74.         int testTime = 500000;
    75.         int maxSize = 100;
    76.         int maxValue = 100;
    77.         boolean succeed = true;
    78.         for (int i = 0; i < testTime; i++) {
    79.             int[] arr1 = generateRandomArray(maxSize, maxValue);
    80.             int[] arr2 = copyArray(arr1);
    81.             bubbleSort(arr1);
    82.             comparator(arr2);
    83.             if (!isEqual(arr1, arr2)) {
    84.                 succeed = false;
    85.                 break;
    86.             }
    87.         }
    88.         System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    89.         int[] arr = generateRandomArray(maxSize, maxValue);
    90.         printArray(arr);
    91.         bubbleSort(arr);
    92.         printArray(arr);
    93.     }
    94. }

    冒泡排序的复杂度是O(N^2),分析是 0--n-1 , 0--n-2,  0---n-3,........根据等差数列公式，可得，根据复杂度分析方式。

    下面是选择排序

    1. package basic_class_01;
    2. import java.util.Arrays;
    3. public class Code_02_SelectionSort {
    4.     public static void selectionSort(int[] arr) {
    5.         if (arr == null || arr.length < 2) {
    6.             return;
    7.         }
    8.         for (int i = 0; i < arr.length - 1; i++) {
    9.             int minIndex = i;
    10.             for (int j = i + 1; j < arr.length; j++) {
    11.                 minIndex = arr[j] < arr[minIndex] ? j : minIndex;
    12.             }
    13.             swap(arr, i, minIndex);
    14.         }
    15.     }
    16.     public static void swap(int[] arr, int i, int j) {
    17.         int tmp = arr[i];
    18.         arr[i] = arr[j];
    19.         arr[j] = tmp;
    20.     }
    21.     // for test
    22.     public static void comparator(int[] arr) {
    23.         Arrays.sort(arr);
    24.     }
    25.     // for test
    26.     public static int[] generateRandomArray(int maxSize, int maxValue) {
    27.         int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
    28.         for (int i = 0; i < arr.length; i++) {
    29.             arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
    30.         }
    31.         return arr;
    32.     }
    33.     // for test
    34.     public static int[] copyArray(int[] arr) {
    35.         if (arr == null) {
    36.             return null;
    37.         }
    38.         int[] res = new int[arr.length];
    39.         for (int i = 0; i < arr.length; i++) {
    40.             res[i] = arr[i];
    41.         }
    42.         return res;
    43.     }
    44.     // for test
    45.     public static boolean isEqual(int[] arr1, int[] arr2) {
    46.         if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
    47.             return false;
    48.         }
    49.         if (arr1 == null && arr2 == null) {
    50.             return true;
    51.         }
    52.         if (arr1.length != arr2.length) {
    53.             return false;
    54.         }
    55.         for (int i = 0; i < arr1.length; i++) {
    56.             if (arr1[i] != arr2[i]) {
    57.                 return false;
    58.             }
    59.         }
    60.         return true;
    61.     }
    62.     // for test
    63.     public static void printArray(int[] arr) {
    64.         if (arr == null) {
    65.             return;
    66.         }
    67.         for (int i = 0; i < arr.length; i++) {
    68.             System.out.print(arr[i] + " ");
    69.         }
    70.         System.out.println();
    71.     }
    72.     // for test
    73.     public static void main(String[] args) {
    74.         int testTime = 500000;
    75.         int maxSize = 100;
    76.         int maxValue = 100;
    77.         boolean succeed = true;
    78.         for (int i = 0; i < testTime; i++) {
    79.             int[] arr1 = generateRandomArray(maxSize, maxValue);
    80.             int[] arr2 = copyArray(arr1);
    81.             selectionSort(arr1);
    82.             comparator(arr2);
    83.             if (!isEqual(arr1, arr2)) {
    84.                 succeed = false;
    85.                 printArray(arr1);
    86.                 printArray(arr2);
    87.                 break;
    88.             }
    89.         }
    90.         System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    91.         int[] arr = generateRandomArray(maxSize, maxValue);
    92.         printArray(arr);
    93.         selectionSort(arr);
    94.         printArray(arr);
    95.     }
    96. }

    选择排序和冒泡排序类似 时间复杂度都是O（N^2），不做过多分析 。

    最后是插入排序，冒泡排序的升级版。

    package basic_class_01;

    import java.util.Arrays;

    public class Code_01_InsertionSort {

        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];
        }

        // for test
        public static void comparator(int[] arr) {
            Arrays.sort(arr);
        }

        // for test
        public static int[] generateRandomArray(int maxSize, int maxValue) {
            int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
            }
            return arr;
        }

        // for test
        public static int[] copyArray(int[] arr) {
            if (arr == null) {
                return null;
            }
            int[] res = new int[arr.length];
            for (int i = 0; i < arr.length; i++) {
                res[i] = arr[i];
            }
            return res;
        }

        // for test
        public static boolean isEqual(int[] arr1, int[] arr2) {
            if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
                return false;
            }
            if (arr1 == null && arr2 == null) {
                return true;
            }
            if (arr1.length != arr2.length) {
                return false;
            }
            for (int i = 0; i < arr1.length; i++) {
                if (arr1[i] != arr2[i]) {
                    return false;
                }
            }
            return true;
        }

        // for test
        public static void printArray(int[] arr) {
            if (arr == null) {
                return;
            }
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();
        }

        // for test
        public static void main(String[] args) {
            int testTime = 500000;
            int maxSize = 100;
            int maxValue = 100;
            boolean succeed = true;
            for (int i = 0; i < testTime; i++) {
                int[] arr1 = generateRandomArray(maxSize, maxValue);
                int[] arr2 = copyArray(arr1);
                insertionSort(arr1);
                comparator(arr2);
                if (!isEqual(arr1, arr2)) {
                    succeed = false;
                    break;
                }
            }
            System.out.println(succeed ? "Nice!" : "Fucking fucked!");

            int[] arr = generateRandomArray(maxSize, maxValue);
            printArray(arr);
            insertionSort(arr);
            printArray(arr);
        }

    }
     

     插入排序很有意思，对于一组数，进行比较，如果后一个数比前一个数小那么就交换，并且和前一个数之前的数进行比较，一直往前比较，直到当前的数比前一个数大。

    插入排序的时间复杂度是和数据状况是有关系的，存在最好情况和最差情况，还有平均情况。平常情况下，一律按最差情况估计。所以插入排序是O(N^2).

    下面是对数器。

    就是笨方法保证正确，聪明的方法不能保证正确。和笨方法比较，如果和笨方法的结果一致。那么就可以说明笨方法正确。

    大样本测试数据。尽可能的测试各种情况。

    递归函数就是系统帮忙压栈，先入后出。

    归并排序，分成两部分，借组辅助数组，利用外排的方式进行归并。
  • 相关阅读:
    Kafka 核心 API ==> AdminClient
    Kafka ==> 简介
    设计模式之 ==> 代理设计模式
    设计模式之 ==> 工厂设计模式
    设计模式之 ==> 模板设计模式
    设计模式之 ==> 单例模式
    Linux目录【持续更新中】
    Python 目录【持续更新中】
    kafka-eagle部署
    ES集群部署
  • 原文地址：https://www.cnblogs.com/bianzhuo/p/9463294.html
Copyright © 2020-2023  润新知