算法基礎（一）

認識時間複雜度
常數時間的操做：一個操做若是和數據量沒有關係，每次都是 固定時間內完成的操做，叫作常數操做。
時間複雜度爲一個算法流程中，常數操做數量的指標。經常使用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中出現 的數；
三個流程，三種時間複雜度的表達...
如何分析好壞:

流程1：　　o(m*n)

流程2：　　o(mlogn)

流程3：數組B排序：o(mlogm)　　外排：(n+m)　　o(mlogm)+(n+m)

冒泡排序

    public static void maopaosort(int[] arr) {
        if(arr==null||arr.length<2){
            return;
        }
        for (int i = arr.length-1; i>0; i--) {
            for (int j = 0; j <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=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

時間複雜度：等差數列，an^2+bn+1　　o(n^2)

選擇排序

    public static void xuanzesort(int[] arr) {
        if(arr==null||arr.length<2){
            return;
        }
        for (int i = 0; i <arr.length-1 ; i++) {
           int  min=i;
            for (int j = i+1; j <arr.length ; j++) {
                // 每一次尋找都是"在剩餘子數組裏面"最小的那個
                if(arr[j]<arr[min]){
                    min=j;
                }
            }
            swap(arr,min,i);
        }
    }
    public static void swap(int[] arr, int i, int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }

時間複雜度：o(n^2)

插入排序

    public static void charusort(int[] arr) {
        if(arr==null||arr.length<2){
            return;
        }
        //每次先排好j到i範圍的數，慢慢擴大範圍
        for (int i = 1; i <arr.length ; i++) {
            for (int j = i-1; j >=0; j--) {
                if(arr[j+1]<arr[j]){
                    swap(arr,j,j+1);
                }
            }
        }
    }

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

時間複雜度：最壞：o(n^2)　　最好(已經排好序)：o(n)

 

剖析遞歸行爲和遞歸行爲時間複雜度的估算
符合T(N) = a*T(N/b) + O(N^d)，可使用master公式

N:父問題的樣本量

a:過程發生多少次

N/b:子問題的樣本量

d:除去子過程外，剩下的時間複雜度

master公式

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)

歸併排序

T(N)=2(N/2)+O(N)

運用master公式2，算出時間複雜度：o(nlogn)

 

　　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;
        }
        //mid=L+((R-L)>>1);
        int mid=(L+R)/2;
        sortProcess(arr,L,mid);
        sortProcess(arr,mid+1,R);
        merge(arr,L,mid,R);
    }

    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++];
        //p2已經越界，拷貝p1
        while(p1<=mid)
            help[i++]=arr[p1++];
        //p1已經越界，拷貝p2
        while(p2<=R)
            help[i++]=arr[p2++];
        for(int j=0;j<help.length;j++)
            arr[L+j]=help[j];
    }

 

例子：小和問題

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

[1,3,4,2,5]

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

3左邊比3小的數，1；

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

2左邊比2小的數，1；

5左邊比5小的數，一、三、四、2；

因此小和爲1+1+3+1+1+3+4+2=16

public class SmallSum {
    public static void main(String[] args) {
        int[] arr={1,3,4,2,5};
        System.out.println(smallSum(arr));
    }

    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)/2;
        return mergeSort(arr,l,mid)+mergeSort(arr,mid+1,r)+merge(arr,l,mid,r);
    }
    public static int merge(int[] arr,int l,int mid,int r){
        int res=0;
        int[] help=new int[r-l+1];
        int i=0;
        int p1=l;
        int p2=mid+1;
        while(p1<=mid&&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<=mid)
            help[i++]=arr[p1++];
        while(p2<=r)
            help[i++]=arr[p2++];
        for (int j = 0; j <help.length; j++) {
            arr[l+j]=help[j];
        }
        return res;
    }

}