左神基础班第一课

之前一直在犹豫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).

下面是对数器。

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

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

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

归并排序，分成两部分，借组辅助数组，利用外排的方式进行归并。