算法的复杂度O(＜#N#＞)

数据所在的容器器皿坑位。
方法/函数的数学本质从数学角度描述：I/O关系式 ，简单描述为入参及右侧表达式结果(Input/Output)。
y=f(n)=入参n构建的表达式。常量修饰系数+变量占位入参。<#N#>函数表达式的结果即复杂度参考值。

---

算法的复杂度：时间方面的时间复杂度和空间相关的空间复杂度。
时间复杂度：指执行某算法所需要的工作量耗时(时间消耗)；
空间复杂度：指执行某算法所需要的内存空间消耗(空间消耗)；
时间资源和空间资源都属于计算机资源的重要体现，算法的复杂性是体现在运行某算法时计算机所消耗资源的多少。

O(<#N#>)符号Output后面圆括号中函数表达式f(n)=<#N#>，代表某算法的耗时资源/耗空间资源与数据量层级增长之间的关系(n代表输入数据的量)。
时间复杂度为例：

1. 时间复杂度为O(n)：线性阶复杂度代表数据量增大入参n倍，耗时资源增大表达式结果值的倍数n倍
   比如简单的循环遍历算法：

//循环遍历N次即可得结果
count = 0;
for(int i = 0;i < 10 ; i ++){
	count ++;
}

2. 时间复杂度为O(n^2)：平方阶复杂度代表数据量增大入参n倍时，耗时资源增大表达式结果值的倍数即n的平方倍，是比线性阶复杂度消耗资源更多的时间复杂度。
   比如冒泡排序算法O(n^2)：m个数排序，需要循环m*(m-1)/2次。
   

//冒泡算法
- (void)bubleAlgorithm {
    int arr[] = {2,6,3,1,7,10,3,5,8,34,56,0,1,4,9,17,13,15,12,33};
    int cnt = 20;
    int count = 0;
    for (int i=1; i<cnt; i++) {
        for (int j=0; j<cnt-i; j++) {
            //交换操作
            if(arr[j]>arr[j+1]) {
                 int temp = arr[j];
                 arr[j]=arr[j+1];
                 arr[j+1]=temp;
            }
            count++;
        }
    }
    [self printList:arr length:cnt];
}

3. 时间复杂度O(logn):对数阶复杂度代表数据量增大入参n倍时，耗时资源增大表达式结果值的倍数即logn倍(log以2为底，即当数据量增大256倍时，耗时资源只增大log256倍即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;
}

4. 时间复杂度O(nlogn)：线性对数阶复杂度，表达式的结果值是nlogn，当数据量增大到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];
	}
}

5. O(1)：常数阶复杂度，表达式的结果值是1，永远只需要一轮操作就可以寻找到目标，耗时资源最少，最低的时空复杂度，就是耗时与输入数据量多少无关，无论输入数据量增大多少倍，耗时/耗空间都不变，都是一步找到一步映射到。哈希算法是典型的O(1)时间复杂度，无论数据规模多大，都可以在一次映射计算后找到目标。
6. 时间复杂度优劣对比：数量级越小表示算法执行时间频度越短则越优。