数据结构（一） 复杂度讲解

前言：

C语言的基本知识和内容我们已经更新完了，现在开始我会为大家带来数据结构的相关知识。由于是初级的数据结构知识我会使用C语言为大家呈现，后续会为大家持续更新。在没有特殊情况下，我尽最大努力坚持每天更新一篇。写博客也有一个多月了，自己也懂了一点方法，更好的为大家呈现更多的知识。我呢还是一名学生，但不影响我对于这份知识的渴望。望与大家共同进步。

Lesson1--数据结构前言

1. 什么是数据结构

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

2.什么是算法？

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

3.数据结构和算法的重要性

在校园招聘的笔试中：

目前校园招聘笔试一般采用Online Judge形式， 一般都是20-30道选择题+2道编程题，或者3-4道
编程题。

这是我们可以找的一些资料

可以看出，现在公司对学生代码能力的要求是越来越高了，大厂笔试中几乎全是算法题而且难度
大，中小长的笔试中才会有算法题。算法不仅笔试中考察，面试中面试官基本都会让现场写代
码。而算法能力短期内无法快速提高了，至少需要持续半年以上算法训练积累，否则真正校招时
笔试会很艰难，因此算法要早早准备。

好了废话不多说，我们直接开始进入正文

4.算法的时间复杂度和空间复杂度

4.1算法效率

1.1 如何衡量一个算法的好坏：我们列举一个列子

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

斐波那契数列的递归实现方式非常简洁，但简洁一定好吗？那该如何衡量其好与坏呢？

这里我们就引入了时间复杂度，与空间复杂度的概念

1.2 算法的复杂度

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

1.3 复杂度在校招中的考察

可见复杂度是我们数据结构的入门，我们现在来逐一认识它们。

5.时间复杂度 

时间复杂度的概念：

时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

即：找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

// 请计算一下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;
}
printf("%d\n", count);
}

大家肯定会有疑问表达式是怎么计算出来的呢？  我们一点一点来，在上面的代码中一共有三个for循环（其中有两个for循环是嵌套的）加上一个while循环，那么我们计算程序运行的次数进行。

第一个和第二个for循环运行次数：N*N

第三个for循环运行次数：2*N

while循环：10

那么我们把它们相加就可以得到整个程序运行的次数：N*N+2*N+10

我们可以观察到随着 N 的不断增大，有些值对结果的影响在不断减小，那么我们该如何做呢？

其实很简单我们只需要取出影响最大的项（即占绝对性因素的项） 那么我们就可以的出结论

Func1的时间复杂度就是（N*N）。

时间复杂度就是看最高次方，且不保留系数。

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

大O的渐进表示法（简单来说就相当于--估算）

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

推导大O阶方法：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
使用大O的渐进表示法以后，Func1的时间复杂度为：
N = 10 F(N) = 100
N = 100 F(N) = 10000
N = 1000 F(N) = 1000000
通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。
另外有些算法的时间复杂度存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)
例如：在一个长度为N数组中搜索一个数据x
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N）。

常见时间复杂度计算举例（我们有几道例题大家一起来算）

// 计算Func2的时间复杂度？
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);
}

我们先观察循环（for，while） 其中for循环：2*N

                                                    while循环：10

相加即：2*N+10  使用上面教的方法，只保留影响大的项（2*N）=2N

在这里当N不断增大，达到一个很大的值是常数2对项的影响也在不断减小

打个比方 1000000000000000000000000

                2000000000000000000000000  都是很大的数字我们就可以把2也给忽略，那么

不难得出时间复杂度是（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但是又有一个问题，它们都是未知的，那么该如何计算呢？

我们在不知道具体值的情况下，可以直接使用M与N来计算。

第一个 for 循环执行了M次

第二个 for 循环执行了N次

那么我们之间把它们相加起来得到：M+N

基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M).

实例3: 

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

这道题有点特殊：在这里N的值并不会给复杂度带来任何的变化。

由于k是一个常数，所有的常数时间复杂度都是1.

基本操作执行了100次，通过推导大O阶方法，时间复杂度为 O(1)。

// 计算strchr的时间复杂度

const char * strchr ( const char * str, int character );

在这里我们使用上面提到的内容 ：

另外有些算法的时间复杂度存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)
例如：在一个长度为N数组中搜索一个数据x
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N）。

基本操作执行最好1次，最坏N次，时间复杂度一般看最坏，时间复杂度为 O(N)。

实例5:

// 计算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;
}
}

有一定基础的同学，一眼就可以看出来这是一个冒泡排序 。

那么时间复杂度该如何计算呢？

冒泡排序的思想：两两进行交换，把最大的始终换到最后一位。

那么我们计算出的趟数就是程序运行的次数，趟数是一个等差数列我们求和（我们化简得到最大项 1/2N*N）我们去掉系数得到时间复杂度  N*N

实例6:

// 计算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;
}

实例6基本操作执行最好1次，最坏O(logN)次，时间复杂度为 O(logN) ps：logN在算法分析中表示是底数为2，对数为N。有些地方会写成lgN。（建议通过折纸查找的方式讲解logN是怎么计算出来的 )。

6.常见复杂度对比

一般算法常见的复杂度如下：

感谢你的观看，后续为大家带来更多 数据结构知识

请大家持续关注