时间复杂度和空间复杂度

一.什么是数据结构？

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

1.什么是算法？

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

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

在校园招聘的笔试中：
当前校园招聘笔试一般采用Online Judge形式， 一般都是20-30道选择题，3-4道编程题。
在校园招聘的面试中：

某公司的面试题：

1、自我介绍
2、学习STL具体是怎么开展的？
3、如果一款产品给你怎么检测内存泄露？
4、进程间通信方式，共享内存是怎么实现的，会出现什么问题，怎么解决？
5、TCP为什么是可靠的？可靠是怎么保证的？为什么要三次握手？为什么三次握手就可以可靠？
6、Http数据分包问题；
7、Vector相关；
8、Hashmap相关；
9、红黑树的原理、时间复杂度等；
10、Memcpy和memmove的区别；
11、客户端给服务器发送数据，意图发送aaa，然后再发bbb，但是可能会出现aaabbb这种情况，如何处理？
12、游戏的邮件服务器中每天会有玩家频繁的创建邮件和删除邮件，海量数据、大小不一，会有哪些场景，怎么存储，邮件是怎么到内存的？
13、写一道算法题

百度面试算法题：

1.手写五道题，三道编程题，一道数据库，一道linux
2.数据库的题两问；
3.算法了解的如何，插入排序编程；
4.说一下IP,TCP,ARP；
5.内核是什么；
6.IP层主要功能；
7.map和set底层；
8.bootstrap的用法,html,html的全称；
9.你觉得框架和库有啥区别；
10.代码优化；
11.哈希表；
12.shell脚本；
13.快速排序思想；
14.递归是什么；
15.分治是什么，与递归区别是什么；
16.web平台是怎么做的；
17.linux命令；
18.了解些什么前沿的技术，英语怎么样，了解过什么英语的文献；

通过上述的面试题数据结构和算法在校招中占很大的地位！
在未来的工作中：
数据结构与算法对一个程序员来说的重要性？
学好算法对一个程序员来说是必须的吗？如果是，至少应该学到哪种程度？

3.数据结构和算法书籍及资料推荐

数据结构学习得差不多了，推荐把《剑指offer》和《程序员代码面试指南》上的题做一遍。

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

1.算法的复杂度

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

2. 复杂度在校招中的考察

3.时间复杂度

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

对于给定的程序，分析 count 的时间复杂度如下：

1. 首先看第一个嵌套循环：
   外层循环执行 N 次。

• 内层循环在每次外层循环时也执行 N 次。
  所以这个嵌套循环中 count 的增加次数为 N * N 。

2. 接着看第二个循环：
   循环执行 2 * N 次，每次循环 count 增加 1。
   所以这里 count 的增加次数为 2 * N 。
3. 最后看 while 循环：
   M 初始为 10，每次循环减 1，循环执行 10 次。
   每次循环 count 增加 1，所以这里 count 增加次数为 10。
   综合以上三个部分，总的 count 增加次数为 N * N +2*N+10。

Func1 执行的基本操作次数 ：
N = 10 F(N) = 130
N = 100 F(N) = 10210
N = 1000 F(N) = 1002010
F(N)=N^2+2*N+10
实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

2 大O的渐进表示法

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

N = 10 F(N) = 100
N = 100 F(N) = 10000
N = 1000 F(N) = 1000000

通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。另外有些算法的时间复杂度存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)

例如：在一个长度为N数组中搜索一个数据x
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

实例1：

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

实例1基本操作执行了2N+10次，通过推导大O阶方法知道，时间复杂度为 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);

实例2基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M)，因为M和N的比重差不多所以不能忽略其中一个。
实例3:

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

实例3基本操作执行了10次，通过推导大O阶方法，时间复杂度为 O(1）
实例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;
}
}

时间复杂度计算时以最坏情况为准，则假设数组开始是逆序的，那么第一次排序执行 n-1 次，第二次排序执行 n-2 次，第三次执行 n-3 次 … …，直到最后达成有序，所以冒泡排序的具体执行次数是一个等差数列，具体次数 = (首项+尾项)/2*项数 = (N^2-N)/2\n\n 用大O的渐进表示法得出时间复杂度O(N^2)

实例6:

/ 计算BinarySearch的时间复杂度？
int BinarySearch(int* a, int n, int x)
{
assert(a);
int begin = 0;
int end = n-1;
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;
}

考虑最坏情况，即数组中没有想找的元素，数组会从中间开始查找，每次排除掉一半的元素，直到把所有元素排除完，第一次排除后剩下 1/2 的元素，第二次排除后剩下 1/4 元素，第三次排除后剩下 1/8 元素 … …，设元素个数为N，查找次数为X，则 X * (½)^N = 1 -> (½)^N = X -> 具体次数：X = log2N

实例7:

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

实例7通过计算分析发现基本操作递归了N次，时间复杂度为O(N)。这里 n 调用 n-1 , n-1 调用 n-2 …，直到 n = 1，所以一共执行了 n-1 次。

实例8:

long long Fac(size_t N)
{
if(0 == N)
return 1;
for(int i=0;i<n;i++)
{

}
return Fac(N-1)*N;
}

实例7通过计算分析发现基本操作递归了N次，但每一次内部又运行了N次，时间复杂度为O(N平方)。这里 n 调用 n-1 , n-1 调用 n-2 …，直到 n = 1，所以一共执行了 n-1 次，每一次又n次循环，所以n-1+n-2+n-3+…+1=n方，所以时间复杂度为n方。

实例9:

// 计算斐波那契递归Fib的时间复杂度？
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}

以上图为例，我们可以看到在数值大于2的时候，每一层的调用次数是以2的指数形式增长的，是一个等比数列。用大O的渐进表示法得出时间复杂度为：O(2^N)

3.空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度 。
空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟实践复杂度类似，也使用大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;
}
}

实例1使用了常数个额外空间，所以空间复杂度为 O(1)。因为int*a 本身是原来的数组，只需要排序即可。额外开辟空间的变量是end,exchange 有限个变量，所以时间复杂度为O(1)。

实例2：

// 计算Fibonacci的空间复杂度？
// 返回斐波那契数列的前n项
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;
}

实例2动态开辟了N个空间，空间复杂度为 O(N)

实例3：

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

3. 实例3递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)

实例4：

/ 计算斐波那契递归Fib的空间复杂度？
long long Fib(size_t N)
{
if(N < 3)
return 1;
return Fib(N-1) + Fib(N-2);
}

斐波那契递归函数 Fib 的空间复杂度分析较为复杂。可将其开辟空间的行为想象成一棵二叉树，此过程类似于二叉树的前序遍历。首先进入根节点第一层时开辟空间，接着调用 Fib(N - 1) 和 Fib(N - 2) ，相当于进入第二层并开辟新空间。此后不断重复调用，如 Fib(N - 2) 、 Fib(N - 3) 等，持续开辟新空间。依次类推，总共会开辟空间 N 次。把整个过程想象成一棵二叉树，根节点首先开辟空间，然后在前序遍历中进入左孩子节点，进入树的第二层，第二层同样需要开辟空间。左孩子调用完成后返回根节点，再调用右孩子，由于左孩子和右孩子共用一块空间，所以每一层实际上只有一块空间。而树的高度为 N，因此总共开辟了 N 块空间，故该函数的空间复杂度为 O(N)。
总结：时间是一去不返的，空间可以重复利用。

4. 常见复杂度对比

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

三.复杂度oj练习

题目一：消失的数字

c语言阶段学过，0^a = a;a^a=0;让 0^nums[i] = mid,再让mid^(1到numsize+1)的数字，得到消失的数字。

int missingNumber(int* nums, int numsSize) {
    int mid = 0;
    for(int i=0;i<numsSize;i++)
    {
        mid ^=nums[i];

    }
    for(int i=0;i<numsSize+1;i++)
    {
        mid ^=i;

    }
    return mid;
}

题目2：旋转数组

分析，先逆置前k个，在逆置k后面的，最后所有逆置。如，1，2,3，4,5，6,7 。k=3时，第一步旋转前k个为4， 3,2，1,5,6，7在逆置k后面的为,4，3,2，1,7，6,5最后全部逆置为 5,6，7,1，2,3，4.

void reverse(int * a, int left,int right)
{
    while(left<right)
    {
        int tmp=a[left];
        a[left] = a[right];
        a[right]=tmp;
        left++;
        right--;
    }
}
void rotate(int* nums, int numsSize, int k) {
            if(k>numsSize)
            {
                k=k%numsSize;
            }
    reverse(nums,0,numsSize-k-1);
    reverse(nums,numsSize-k,numsSize-1);
    reverse(nums,0,numsSize-1);
}

时间复杂度o(n),空间复杂度o(1)。