左程雲Java算法(1)

認識時間復雜度

• 常數時間的操作：一個操作如果和數據量沒有關系，每次都是固定時間內完成的操作，叫做常數操作。
• 時間復雜度為一個算法流程中，常數操作數量的指標。常用O（讀作big O）來表示。具體來說，在常數操作數量的表達式中，只要高階項，不要低階項，也不要高階項的系數，剩下的部分如果記為f(N)，那么時間復雜度為O(f(N))。
• 評價一個算法流程的好壞，先看時間復雜度的指標，然后再分析不同數據樣本下的實際運行時間，也就是常數項時間。

 

例子一

• 一個簡單的理解時間復雜度的例子
• 一個有序數組A，另一個無序數組B，請打印B中的所有不在A中的數，A數組長度為N，B數組長度為M。
• 算法流程1：對於數組B中的每一個數，都在A中通過遍歷的方式找一下；
• 算法流程2：對於數組B中的每一個數，都在A中通過二分的方式找一下；
• 算法流程3：先把數組B排序，然后用類似外排的方式打印所有在A中出現的數；
• 三個流程，三種時間復雜度的表達...
• 如何分析好壞？

 

例子二

對數器的概念和使用

0，有一個你想要測的方法a，

1，實現一個絕對正確但是復雜度不好的方法b，

2，實現一個隨機樣本產生器

3，實現比對的方法

4，把方法a和方法b比對很多次來驗證方法a是否正確。

5，如果有一個樣本使得比對出錯，打印樣本分析是哪個方法出錯

6，當樣本數量很多時比對測試依然正確，可以確定方法a已經正確。

    public static void bubbleSort(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-1-i; j++){
                if (arr[j] > arr[j+1]){
                    swap(arr, j, j+1);
                }
            }
        }
    }
    
    public static void swap(int[] arr, int i, int j){
        //交換方法
        int temp;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void rightMathod(int[] arr){
        //系統提供的排序方法
        Arrays.sort(arr);    
    }
    
    public static int[] generateRanddomArray(int size, int value){
        //Math.random() -> double[0,1); 左閉右開
        //(int)((size+1) * Math.random()) -> [0, size]; 左閉右閉整數
        //size為數組長度
        
        //生成長度隨機的數組
        int[] arr = new int[(int)((size+1) * Math.random())];
        for (int i = 0; i < arr.length; i++){
            arr[i] = (int)((value + 1) * Math.random() - (int)(value * Math.random()));
        }        
        return arr;
    }
    
    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;
    }
    
    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;
    }
    
    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();
    }
    
    public static void main(String[] args) {
        int testTime = 500000;
        int size = 10;
        int value = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++){
            int[] arr1 = generateRanddomArray(size, value);
            int[] arr2 = copyArray(arr1);
            int[] arr3 = copyArray(arr1);
            bubbleSort(arr1);
            rightMathod(arr2);
            if (!isEqual(arr1, arr2)){
                succeed = false;
                printArray(arr3);
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");
        
        int[] arr = generateRanddomArray(size, value);
        printArray(arr);
        System.out.println("數組長度為："+arr.length);    
    }

 

例子三

冒泡排序細節的講解與復雜度分析

時間復雜度O(N^2)，額外空間復雜度O(1)　

    public static void bubbleSort(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-1-i; j++){
                if (arr[j] > arr[j+1]){
                    swap(arr, j, j+1);
                }
            }
        }
    }
    
    public static void swap(int[] arr, int i, int j){
        int temp;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    public static void show(int[] arr){
        for (int i=0; i<arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }
    
    public static void main(String[] args) {
        int arr[] = {6,4,2,5,8,9};
        bubbleSort(arr);
        show(arr);
    }

 

例子四

選擇排序的細節講解與復雜度分析

時間復雜度O(N^2)，額外空間復雜度O(1)

    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);
        }
    }
    
    public static void swap(int[] arr, int i, int j){
        int temp = 0;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    public static void show(int[] arr){
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }

    public static void main(String[] args) {
        int arr[] = {6,4,1,2,9,3};
        selectionSort(arr);
        show(arr);
    }

 

例子五

　　插入排序的細節講解與復雜度分析

　　時間復雜度O(N^2)，額外空間復雜度O(1)

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){
        int temp = 0;
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    public static void show(int[] arr){
        for (int i = 0; i < arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }
    
    public static void main(String[] args) {
        int arr[] = {7,3,4,1,9,2,5};
        insertionSort(arr);
        show(arr);
    }

 

例子六

刨析遞歸行為和遞歸行為時間復雜度的估算

master公式的使用

T(N) = a*T(N/b) + O(N^d)

分析：

T(N)：樣本量為 N 的情況下，時間復雜度
N：父問題的樣本量
a：子問題發生的次數（父問題被拆分成了幾個子問題，不需要考慮遞歸調用，只考慮單層的父子關系）
b：被拆成子問題，子問題的樣本量（子問題所需要處理的樣本量），比如 N 被拆分成兩半，所以子問題樣本量為 N/2
O(N^d)：剩余操作的時間復雜度，除去調用子過程之外，剩下問題所需要的代價（常規操作則為 O(1)）

1) log(b, a) > d　->　復雜度為O(N^log(b, a))

2) log(b, a) = d　->　復雜度為O(N^d * logN)

3) log(b, a) < d　->　復雜度為O(N^d)

 

例子七

　　歸並排序的細節講解與復雜度分析

　　時間復雜度O(N*logN)，額外空間復雜度O(N)　

    public static void mergeSort(int[] arr){
        if (arr == null || arr.length < 2){
            return;
        }
        sortProcess(arr, 0, arr.length-1);
    }
    
    public static void sortProcess(int[] arr, int L, int R){
        if (L == R){
            return;
        }
        int mid = (L + R) / 2;    //中點下標
        sortProcess(arr, L, mid);    //T(n/2)
        sortProcess(arr, mid+1, R);    //T(N/2)
        merge(arr, L, mid, R);    //O(N)
        //T(N) = 2 T(N/2) + O(N)
    }
    
    public static void merge(int[] arr, int L, int mid, int R){
        int[] help = new int[R - L + 1];
        int i = 0;
        int p1 = L;    //左側區域的第一個數
        int p2 = mid+1;    //右側區域的第一個數
        while (p1 <= mid && p2 <= R){
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        //兩個必有且只有一個越界
        while (p1 <= mid){
            help[i++] = arr[p1++];
        }
        while (p2 <= R){
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++){
            arr[L+i] = help[i];
        }
    }
    
    public static void show(int[] arr){
        for (int i=0; i<arr.length; i++){
            System.out.print(arr[i]+" ");
        }
    }
    
    public static void main(String[] args) {
        int[] arr = {5,3,2,6,4,1};
        mergeSort(arr);
        show(arr);
    }

 

例子八

　　小和問題和逆序對問題

　　小和問題

　　在一個數組中，每一個數左邊比當前數小的數累加起來，叫做這個數組的小和。求一個數組的小和。

　　例子：

　　[1,3,4,2,5]

　　1左邊比1小的數，沒有；

　　3左邊比3小的數，1；

　　4左邊比4小的數，1、3；

　　2左邊比2小的數，1；

　　5左邊比5小的數，1、3、4、2；

　　所以小和為 1+1+3+1+1+3+4+2=16

    public static int smallSum(int[] arr){
        if (arr == null || arr.length < 2){
            return 0;
        }
        return mergeSort(arr, 0, arr.length-1);
    }
    
    public static int mergeSort(int[] arr, int l, int r){
        if (l == r){
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        return mergeSort(arr, l, mid) + mergeSort(arr, mid+1, r) + merge(arr, l, mid, r);
    }
    
    public static int merge(int[] arr, int l, int m, int r){
        int[] help = new int[r - l + 1];
        int i = 0;
        int p1 = l;
        int p2 = m+1;
        int res = 0;
        while (p1 <= m && p2 <= r){
            res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= m){
            help[i++] = arr[p1++];
        }
        while (p2 <= r){
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++){
            arr[l + i] = help[i];
        }
        return res;
    }
    
    public static void main(String[] args) {
        int[] arr = {1,3,4,2,5};
        System.out.println(smallSum(arr));
    }

 

　　逆序對問題

　　在一個數組中，左邊的如果比右邊的數打，則折兩個數構成一個逆序對，請打印所有逆序對。