算法復雜度O(1),O(n),O(logn),O(nlogn)的含義

o(1), o(n), o(logn), o(nlogn)是用來表示對應算法的時間復雜度,這是算法的時間復雜度的表示。不僅僅用於表示時間復雜度，也用於表示空間復雜度。

算法復雜度分為時間復雜度和空間復雜度。其作用：

時間復雜度是指執行這個算法所需要的計算工作量；

空間復雜度是指執行這個算法所需要的內存空間；

       時間和空間都是計算機資源的重要體現，而算法的復雜性就是體現在運行該算法時的計算機所需的資源多少；

       O后面的括號中有一個函數，指明某個算法的耗時/耗空間與數據增長量之間的關系。其中的n代表輸入數據的量。

       時間復雜度為O(n)—線性階，就代表數據量增大幾倍，耗時也增大幾倍。比如常見的遍歷算法。
//循環遍歷N次即可得到結果

//循環遍歷N次即可得到結果
count = 0;
for(int i = 0;i < 10 ; i ++){
    count ++;
}

       時間復雜度O(n^2)—平方階, 就代表數據量增大n倍時，耗時增大n的平方倍，這是比線性更高的時間復雜度。比如冒泡排序，就是典型的O(n x n)的算法，對n個數排序，需要掃描n x n次。

for(int i =1;i<arr.length;i++) { //遍歷n次
    for(int j=0;j<arr.length-i;j++) {//遍歷n-1次
       if(arr[j]>arr[j+1]) {
              int temp = arr[j];
              arr[j]=arr[j+1];
              arr[j+1]=temp;
         }
     }    
}
//整體復雜度n*(n-1)

       時間復雜度O(logn)—對數階，當數據增大n倍時，耗時增大logn倍（這里的log是以2為底的，比如，當數據增大256倍時，耗時只增大8倍，是比線性還要低的時間復雜度）。二分查找就是O(logn)的算法，每找一次排除一半的可能，256個數據中查找只要找8次就可以找到目標。

int binarySearch(int a[], int key) {
    int low = 0;
    int high = a.length - 1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (a[mid] > key)
            high = mid - 1;
        else if (a[mid] < key)
            low = mid + 1;
        else
            return mid;
    }
    return -1;
}

       時間復雜度O(nlogn)—線性對數階，就是n乘以logn，當數據增大256倍時，耗時增大256*8=2048倍。這個復雜度高於線性低於平方。歸並排序就是O(nlogn)的時間復雜度。

public void mergeSort(int[] arr, int p, int q){
    if(p >= q) {
        return
    };
    int mid = (p+q)/2;
    mergeSort(arr, p, mid);
    mergeSort(arr, mid+1,q);
    merge(arr, p, mid, q);
}
private void merge(int[] arr, int p, int mid, int q){
    int[] temp = new int[arr.length]; //此處將數組設為全局變量，否則每次都要創建一遍。
    int i = p, j = mid+1，iter = p;
    while(i <= mid && j <= q){
        if(arr[i] <= arr[j]) {
            temp[iter++] = arr[i++]；
        } else{
            temp[iter++] = arr[j++];
        } 
    }
    
    while(i <= mid) {
        temp[iter++] = arr[i++];
    }
    
    while(j <= q){
         temp[iter++] = arr[j++];
    }
    
    for(int t = p; t <= q; t++) {
        arr[t] = temp[t];
    }
}

       O(1)—常數階：最低的時空復雜度，也就是耗時與輸入數據大小無關，無論輸入數據增大多少倍，耗時/耗空間都不變。 哈希算法就是典型的O(1)時間復雜度，無論數據規模多大，都可以在一次計算后找到目標。

index = a;
a = b;
b = index;
//運行一次就可以得到結果

時間復雜度的優劣對比
常見的數量級大小：越小表示算法的執行時間頻度越短，則越優；

O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n3)<O(2n)//2的n方<O(n!)<O(nn)//n的n方