数据结构 —— 复杂度讲解
目录
1. 什么是数据结构？
2.什么是算法？
2.1 算法效率
2.1.1 如何衡量一个算法的好坏？
2.2.2 算法的复杂度
2.2 时间复杂度
2.2.1时间复杂度的概念
2.2.2 大O的渐进表示法
2.2.3 常见时间复杂度举例计算
实例1：
实例2：
实例3：
实例4：
实例5：
实例6：
3.复杂度的OJ练习
3.1 思路一
3.2 思路二
1. 什么是数据结构？
数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。
2.什么是算法？
算法(Algorithm):就是定义良好的计算过程，它取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。
2.1 算法效率
2.1.1 如何衡量一个算法的好坏？
算法在实际实现过程中，并不是说越简洁就说算法越好，就比如说斐波那契数列的递归方式实现非常简洁，但它从效率来看，并不是最好的，那么我们怎样衡量一个算法的好坏？
2.2.2 算法的复杂度
算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。
- 时间复杂度主要衡量一个算法的运行快慢
- 空间复杂度主要衡量一个算法运行所需要的额外空间。
在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。
2.2 时间复杂度
2.2.1时间复杂度的概念
一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。即：找到某条基本语句与问题规模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);
}
以上语句执行了 N^2+2N+10，但当我们不断增加N的大小时，我们发现执行次数只取决于N^2。实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用的就是大O的渐进表示法。
2.2.2 大O的渐进表示法
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
推导大O阶方法：
- 用常数1取代运行时间中的所有加法常数。
- 在修改后的运行次数函数中，只保留最高阶项。
- 如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。 使用大O的渐进表示法以后，Func1的时间复杂度为：O（N^2）
但我们在一些算法中，往往要讨论最好，最坏，一般情况，比如说在数组中找一个数字，最好情况就是一次找到，最坏情况找N次，平均情况N/2，但往往我们实际中都按照最坏情况进行计算。所以时间复杂度就是O（N）。
2.2.3 常见时间复杂度举例计算
实例1：
O（N），本来是2N+10，删掉系数和常数项。
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);
}
实例2：
O（M+N），分类讨论：若M远大于N，则为O（M）；若N远大于M，则为O（N）；若M=N，则为O（M）或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);
}
实例3：
O（1） ，1代表常数项，而不是1次。
// 计算Func4的时间复杂度？
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++k)
{
++count;
}
printf("%d\n", count);
}
实例4：
O（N^2），冒泡排序：以最坏情况举例，最差的情况是现在为逆序，要排为升序，那么第一个数，就要交换n-1次，第二个数，就交换了n-2次，那么就是等差数列求和，{【（N-1）+1】*（N-1）} / 2，然后保留最高阶项，删去系数。
//计算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;
}
}实例5：
O（logN），二分查找：以最坏情况为例，最坏就是二分到只剩下一个值，没查找一次除以2，那么假设查找了x次，那就是N/2/2/2/2/2……=1，那么N=2^x，x=logN.在这里，我们通常把以2为底的对数简写成logN.
// 计算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：
O（N），递归调用Fac（N），Fac（N-1），Fac（N-2），……Fac（0），调用了N+1次，所以就是O（N），递归算法的时间复杂度就是多次调用的累加。
// 计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
if (0 == N)
return 1;
return Fac(N - 1) * N;
}
3.复杂度的OJ练习
OJ链接：https://leetcode-cn.com/problems/missing-number-lcci/
3.1 思路一
我们可以把数组用求和公式计算出来，然后减掉数组中已经存在的数，剩下来的自然就是缺失的数字。复杂度为O（N）
代码实现：
int missingNumber(int* nums, int numsize)
{
int N = numsize;
int ret = N * (N + 1) / 2;
for (int i = 0; i < N; i++)
{
ret -= nums[i];
}
return ret;
}3.2 思路二
还记得单身狗问题吗？在这里我们还可以采用异或操作，先创建一个完整的数组，再和缺少一个的数组进行异或，那么就可以找到缺失的值。复杂度为O（N）.
代码实现：
int missingNumber(int* nums, int numsize)
{
int N = numsize;
int x = 0;
int i = 0;
//复制一个完整数组
for (i = 0; i <= N; i++)
{
x ^= i;
}
//和缺失的数组进行异或
for (i = 0; i < N; i++)
{
x ^= nums[i];
}
//找到缺失值
return x;
}