算法复杂度的计算

数据结构的复杂度

时间复杂度

大O符号(Big O notation)：是用于描述函数渐进行为的数学符号.
推号大O阶方法：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到咖的结果就是大0阶。

1.嵌套的时间复杂度

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

整体的时间复杂度，F(N) = NN + 2N +10。
整体的时间复杂度O（N^2）

2.双重循环的时间复杂度

void Func2(int N)
{
    
    
	int count = 0 ;
	for(int k = 0;k < 2*N ;++k)
	{
    
    
		++count;
	}
	int M =10;
	while(M--)
	{
    
    
		++count;
	}
}

时间的复杂度：O（N）

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

时间的复杂度是：O（M+N），书写为O(N)

3.常数循环的时间复杂度

void Func4(int N)
{
    
    
	int count = 0;
	for(int k= 0; k<100 ; ++k)
	{
    
    
		++count;
	}
}

时间的复杂度为：O(1)，代表的算法运行常次数。

4.冒泡法的时间复杂度

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(N^2)

5.二分法查找的时间复杂度

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

时间复杂度： O（log2(N)）

6.递归的时间复杂度

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

时间复杂度： O（N）

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

T(N)=2⁰+ 2¹ +2²+ …+2^(N-1)
时间的复杂度： O(2^N)