左神基础班第一课

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

下面是对数器。

 

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

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

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

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

posted @ 2018-07-21 16:54  大眼侠  阅读(962)  评论(0)  编辑  收藏  举报