数据结构之复杂度

数据结构

什么是数据结构？

数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。

什么是算法？

算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

复杂度是什么？

复杂度是用来分析程序和算法运行的时间和空间占用情况的分析

1.时间复杂度（重点关注）

定义：算法的时间复杂度是一个函数（数学里面的计算一个值的表达式，不是计算算法运行时间，因为不同的电脑运行环境不同，计算出来的结果没有意义，它算的是程序执行的大概次数。

// 复制代码

1.时间复杂度为：F(N)=N*N+2*N+10
用大O的渐进表示法以后，Func1的时间复杂度为：：O(N*N)
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);
 }

实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。

推导大O阶方法：

1、用常数1取代运行时间中的所有加法常数。

2、在修改后的运行次数函数中，只保留最高阶项。

3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

另外有些算法的时间复杂度存在最好、平均和最坏情况：

最坏情况：任意输入规模的最大运行次数(上界)

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数(下界)

例如：在一个长度为N数组中搜索一个数据x

最好情况：1次找到

最坏情况：N次找到

平均情况：N/2次找到

在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

3.在数组中查找一个数：复杂度会变

分三种情况：

1.最好：

2.最坏：

3.平均：

时间复杂度是悲观的情况：计算最坏的情况是最能让人容易接受的

4.计算时间复杂度怎么算：算过程如冒泡排序：两项相比将较大的往后交换。

复制代码

 // 计算Func2的时间复杂度？
2.时间复杂度为：F(N)=2*N+10
用大O的渐进表示法以后，Func2的时间复杂度为：：O(N)
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);
}



3.时间复杂度为：F(N)=M+N
用大O的渐进表示法以后，Func3的时间复杂度为：：O(M+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);
}

4.时间复杂度为：F(N)=100
用大O的渐进表示法以后，Func4的时间复杂度为：：O(1)【表示常数次】
// 计算Func4的时间复杂度？
void Func4(int N)
 {
    int count = 0;
    for (int k = 0; k < 100; ++ k)
    {
        ++count;
    }
    printf("%d\n", count);

}

5.时间复杂度为：F(N)=(n*n+n)/2
用大O的渐进表示法以后，时间复杂度为：：O(n*n)
最好的情况：O(n){其中外层循环执行1轮，内层循环虽然执行拿次比较，但未触发任何交换就终止了算法，所以总操作量是O(n)}
// 冒泡排序：计算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;
    }
 }
 依下图：
 F(n)=1+2+...+n-1=(n*n+n)/2

外层循环	1	2	3	...	n
内层循环	0	1	2	...	n-1
总次数	0	1	2	...	n-1

复制代码

6.时间复杂度为：F(N)=log以2为底n的对数
用大O的渐进表示法以后，时间复杂度为：O(log以2为底n的对数)
//二分查找：数组是有序的
// 计算BinarySearch的时间复杂度？
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;
 }
 假设原来数组中有n个元素，经过x次查找后只剩下一个元素，所以就可以得到2的x次方为n，求得x=log以2为底n的对数，所以时间复杂度为x=log以2为底n的对数

// 计算阶乘递归Fac的时间复杂度？
时间复杂度为：F(N)=n
用大O的渐进表示法以后，时间复杂度为：O(n)
递归算法如何计算：递归次数*每次递归函数的次数
long long Fac(size_t N)
 {
    if(0 == N)
        return 1;
    
    return Fac(N-1)*N;
 }

 // 计算斐波那契递归Fib的时间复杂度？
 时间复杂度为：F(N)=n
用大O的渐进表示法以后，时间复杂度为：O(n)
//注：n比较大一点的话，运行会非常慢
long long Fib(size_t N)
 {
    if(N < 3)
        return 1;
    
    return Fib(N-1) + Fib(N-2);
 }
 
 //改进：
 //优化：我们发现：递归去计算会有非常多的重复
 long long * Fibonacci(size_t N)
 {
 	long long * fibArry = malloc(sizeof(long long)*(N+1));//多开辟一个空间避免N为0时数组越界
 	fibArray[0] = 1;
 	if(N == 0)
 		return fibArray;
 	fibArray[1] = 1;
 	//以空间换时间
 	for(int i = 2; i < N; ++i)
 	{
 		fibArray[i] = fibArray[i-1] + fibArray[i-2];
 	}
 }
 //实现
 int main()
 {
 printf("%d\n", FibArray(50));
 return 0;
 }

2.空间复杂度（了解）

空间复杂度不计算其占用字节，也就是不计算空间，计算大概定义的变量个数

复制代码

 // 计算BubbleSort的空间复杂度？
 空间复杂度（定义变量个数：5个）：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;
 	}
 }	

// 计算Fibonacci的空间复杂度？
// 返回斐波那契数列的前n项
空间复杂度（定义变量个数：n+1个）：O(n)
long long* Fibonacci(size_t n)
 {
 	if(n==0)
 	return NULL;
 	//开辟了n+1个空间，+1忽略掉
 	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;
 }

 // 计算阶乘递归Fac的空间复杂度？
 空间复杂度：O(n)
long long Fac(size_t N)
 {
 	if(N == 0)
 		return 1;
 	return Fac(N-1)*N;
 }

//计算斐波那契数列空间复杂度是多少
空间复杂度：O(n)
long long Fib(size_t N)
 {
    if(N < 3)
        return 1;
    
    return Fib(N-1) + Fib(N-2);
 }