时间复杂度和空间复杂度

时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。

时间复杂度

定义：

一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法

的时间复杂度。

// 请计算一下Func1中++count语句总共执行了多少次？
void Func1(int N)
{
    int count = 0;
    for (int i = 0; i < N ; ++ i)
    {
        for (int j = 0; j < N ; ++ j)
        {
            ++count;
        }
    }
    for (int k = 0; k < 2 * N ; ++ k)
    {
        ++count;
    }
    int M = 10;
    while (M--)
    {
        ++count;
    }
}

func1一共执行了N^2+2N+10次

实际中我们计算时间复杂度时，不一定要计算精确的执行次数，而只需要大概执行次数，那么这

里我们使用大O的渐进表示法。

大O渐进表示法

1. 运算次数函数中只保留最高次的项

2. 最高次的项系数不为1时，改写为1

3. 当运算次数函数只有常数项时，运算次数用1取代

因此，上面func1的时间复杂度是O(N^2)

实例分析

实例一：

void Func2(int N)
{
    int count = 0;
    for (int k = 0; k < 2 * N ; ++ k)
    {
        ++count;
    }
    int M = 10;
    while (M--)
    {
        ++count;
    }
    printf("%d\n", count);
}

运行次数为2n+10，时间复杂度为O(n)

实例二：

// 计算Func3的时间复杂度？
void Func3(int N, int M)
{
    int count = 0;
    for (int k = 0; k < M; ++ k)
    {
        ++count;
    }
    for (int k = 0; k < N ; ++ k)
    {    
        ++count;
    }
    printf("%d\n", count);
}

执行次数为m+n,时间复杂度是O(m+n)。如果m<<n，则时间复杂度是O(n)。

实例三:

void Func4(int N)
{
    int count = 0;
    for (int k = 0; k < 100; ++ k)
    {
        ++count;
    }
    printf("%d\n", count);
}

执行次数是100，时间复杂度是O(1)。

实例四：

void BubbleSort(int* a, int n)
{
    assert(a);
    for (size_t end = n; end > 0; --end)
    {
        int exchange = 0;
        for (size_t i = 1; i < end; ++i)
        {
            if (a[i-1] > a[i])
            {
                Swap(&a[i-1], &a[i]);
                exchange = 1;
            }
        }
        if (exchange == 0)
        break;
    }
}

冒泡排序最好的情况是执行了N-1次，最坏的情况是执行(1+2+…+N-1)次，时间复杂度是O(N^2)。

实例五：

int BinarySearch(int* a, int n, int x)
{
    assert(a);
    int begin = 0;
    int end = n-1;
// [begin, end]：begin和end是左闭右闭区间，因此有=号
    while (begin <= end)
    {
        int mid = begin + ((end-begin)>>1);
        if (a[mid] < x)
        begin = mid+1;
        else if (a[mid] > x)
        end = mid-1;
        else
        return mid;
    }
    return -1;
}

二分查找最好的情况是执行一次，最坏的情况是执行logN次，时间复杂度是O(logN)

实例六：

long long Fac(size_t N)
{
    if(0 == N)
        return 1;
    return Fac(N-1)*N;
}

阶乘函数递归了N次，时间复杂度是O(N)

实例七：

long long Fib(size_t N)
{
    if(N < 3)
        return 1;
    return Fib(N-1) + Fib(N-2);
}

斐波那契数列函数递归了O(2^n)次，时间复杂度是O(2^n)

空间复杂度

定义：

空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。

函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因

此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

实例分析：

实例一：

void BubbleSort(int* a, int n)
{
    assert(a);
    for (size_t end = n; end > 0; --end)
    {
        int exchange = 0;
        for (size_t i = 1; i < end; ++i)
        {
            if (a[i-1] > a[i])
            {
                Swap(&a[i-1], &a[i]);
                exchange = 1;
            }
        }
        if (exchange == 0)
        break;
    }
}

冒泡排序只使用了常数个额外空间，空间复杂度为O(1)

实例二:

long long Fac(size_t N)
{
    if(0 == N)
        return 1;
    return Fac(N-1)*N;
}

阶乘函数共调用了N次，没调用一次就会建立一个栈帧，空间复杂度为O(N)

实例三：

long long* Fibonacci(size_t n)
{
    if(n==0)
        return NULL;
    long long * fibArray = (long long *)malloc((n+1) * sizeof(long long));
    fibArray[0] = 0;
    fibArray[1] = 1;
    for (int i = 2; i <= n ; ++i)
    {
        fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
    }
    return fibArray;
}

非递归型的斐波那契数列函数，一共向内存申请了N+1个空间，空间复杂度是O(n)

实例四:

long long Fib(size_t N)
{
    if(N < 3)
        return 1;
    return Fib(N-1) + Fib(N-2);
}

递归型的斐波那契数列函数，一共调用了O(2^N)次函数，建立O(2^N)个栈帧，空间复杂度是O(2^N)