时间和空间复杂度

1、时间复杂度
一个算法的实现代码最基本的那个原操作执行的次数与问题规模n之间的函数关系。（渐进时间复杂度）
不能以循环嵌套的层次来评判算法的时间复杂度。
规则：
·省略常数项
·取最高的幂这一项
·去掉系数

//时间复杂度：O(n)
void fun(int n)
{
    for(int i=0;i<n;i++)
    {
       printf("hello\n");
    }
}

//时间复杂度：O(n^2)
void Fun(int n) {
    for(int i = 0; i < n; i++) {            // 循环次数为 n
        for(int j = 0; j < n; j++) {        // 循环次数为 n
            printf("Hello, World!\n");      // 循环体时间复杂度为 O(1)
        }
    }
}

//时间复杂度：因为max(O(n^2),O(n)),所以时间复杂度为O(n^2)
void Fun(int n) {
    // 第一部分时间复杂度为 O(n^2)
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            printf("Hello, World!\n");
        }
    }
    // 第二部分时间复杂度为 O(n)
    for(int j = 0; j < n; j++) {
        printf("Hello, World!\n");
    }
}

//时间复杂度：O(m*n)
for(x=1; i<=m; x++)
{
   for(i=1; i<=n; i++)
    {
       j = i;
       j++;
    }
}

//时间复杂度：O(logn)
int i = 1;
while(i<n)
{
    i = i * 2;
}

//时间复杂度：O(logn)
//假设循环次数为t，2^t<n,执行次数t=log(2)(n),时间复杂度就为O(logn)
void Fun(int n) {
    for (int i = 2; i < n; i++) {
        i *= 2;
        printf("%i\n", i);
    }
}

//时间复杂度：O(nlogn)
for(m=1; m<n; m++)
{
    i = 1;
    while(i<n)
    {
        i = i * 2;
    }
}

//时间复杂度：O(2^n)
//T(n)=T(n-1)+T(n-2)+1,加法算一次执行。简化后为：O(2^n)
long Fun(int n) {
    if (n <= 1) {
        return 1;
    } 
    else {
        return aFunc(n - 1) + aFunc(n - 2);
    }
}

2、空间复杂度
算法执行期间所使用的额外空间与问题规模n之间的函数关系。
从两个方面去评判算法的空间复杂度：
（1）算法实现上有没有使用malloc或者new，并且申请空间与n相关。
（2）算法有没有递归实现，并且递归的次数与n有关。

//如果算法执行所需要的临时空间不随着某个变量n的大小而变化，即
//此算法空间复杂度为一个常量，可表示为 O(1)
int i = 1;
int j = 2;
++i;
j++;
int m = i + j;

//这段代码中，第一行new了一个数组出来，这个数据占用的大小为n，
//这段代码的2-6行，虽然有循环，但没有再分配新的空间，因此，这段
//代码的空间复杂度主要看第一行即可，即 S(n) = O(n)
int[] m = new int[n]
for(i=1; i<=n; ++i)
{
   j = i;
   j++;
}