文章目录

• 前言
• 效率介绍
• 常见时间复杂度的计算
• • 时间复杂度对照图
• 空间复杂度的计算

先介绍一下效率吧

前言

进入数据结构和深剖C的状态了后续会掺杂着更新.

效率介绍

算法效率

时间效率

空间复杂度

总之就是保留对运行次数影响最大的那个并去除相乘的数一般就是时间复杂度内的表达式(执行次数为常数则为O(1)

下面以事例进行讲解

// 请计算一下Func1基本操作执行了多少次？
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;
    }
    printf("%d\n", count);
}

总执行次数为N^2+2*N+10次

我们规则的第二条里要求只保留最高结束(及在N改变时对结果影响最大的表达式)及N^2所以Func1的时间复杂度为O(N^2)

另外有时我们的程序时间复杂度存在最好情况和最坏情况又要如何表达呢

如:

最好情况: 查找1次

最坏情况: 查找N次

我们在实际中一般情况关注的是算法的最坏运行情况.所以上例时间复杂度为O(N).

二分查找的复杂度就是通过以上原则得到的

// 计算BinarySearch的时间复杂度？
int BinarySearch(int* a, int n, int x) 
{
    assert(a);
    int begin = 0;
    int end = n;
    while (begin < end)
    {
        int mid = begin + ((end - begin) >> 1);
        if (a[mid] < x)
            begin = mid + 1;
        else if (a[mid] > x)
            end = mid;
        else
            return mid;
    }
    return -1;
}

当有两个变量控制运算次数时又要如何表示时间复杂度呢?

如:

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);
}

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

执行次数固定及100所以时间复杂度为O(1)

时间复杂度对照图

空间复杂度的计算

空间复杂度和时间复杂度计算方法类似,都是计算最坏(最大)情况下的复杂度情况.

上事例讲解:

// 计算BubbleSort的空间复杂度？
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;
	}
}

我们建立了int*a,int n,size_t end, int eschange,size_t i5个变量类似于时间复杂度常数的建立都为

O(1)

事例2:

// 计算Fibonacci的空间复杂度？
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;
}

我们看到long long* fibArray = (long long*)malloc((n + 1) * sizeof(long long));

我们创建了longlong类型的N+1的变量和其他常数多少的变量

所以空间复杂度为O(N) (类似只使用对复杂度影响最大的那个)

事例3:

// 计算阶乘递归Factorial的空间复杂度？
long long Factorial(size_t N) 
{
	return N < 2 ? N : Factorial(N - 1) * N;
}

我们每次调用函数都会建立一个变量及size_t N但是我们调用了N次函数及建立了N个size_t N

所以空间复杂度为O(N)