前言
今天我们要开始一个新的篇章，初阶数据结构！
目录
1.数据结构前言
本篇博客主要讲述了数据结构和算法的基本知识，最为重要的就是需要懂得复杂度的概念，并且学会判断复杂度以及在平时的日常生活中和学习的过程当中，学会优化代码，使代码的算法复杂度达到最优的状态！好了，话不多说，直接上货！
1.1 数据结构和算法的重要性
数据结构和算法是校园招聘的笔试当中是必考的，这是很重要的。
1.2 数据结构
数据结构(Data Structure)是计算机存储、组织数据的⽅式，指相互之间存在⼀种或多种特定关系的数。据元素的集合。没有⼀种单⼀的数据结构对所有⽤途都有⽤，所以我们要学各式各样的数据结构，如：线性表、树、图、哈希等
关于数据结构的理解：
数据是杂乱无章的，结构就是为了对数据进行管理。
所以数据结构就是对于数据进行管理
数据结构与算法不分家
学习数据结构和算法的秘诀：
死磕代码！！！
画图画图画图+思考！！！
关于数据结构推荐的书籍：
推荐书籍：
1.3 算法
算法(Algorithm):就是定义良好的计算过程，他取⼀个或⼀组的值为输⼊，并产⽣出⼀个或⼀组值作为输出。简单来说算法就是⼀系列的计算步骤，⽤来将输⼊数据转化成输出结果。
关于算法的效率：
如何衡量⼀个算法的好坏呢？
这里有一个案例：你不妨试一试如何解决这个案例中的问题：
案例：旋转数组https://leetcode.cn/problems/rotate-array/description/
在没有学习算法和复杂度之前，或许你会这样写：
思路：循环K次将数组所有元素向后移动⼀位
void rotate(int* nums, int numsSize, int k)
{
while(k--)
{
int end = nums[numsSize-1];
for(int i = numsSize - 1;i > 0 ;i--)
{
nums[i] = nums[i-1];
}
nums[0] = end;
}
}但是当你这样写了之后，会发生什么呢？
代码点击执⾏可以通过，然⽽点击提交却⽆法通过，那该如何衡量其好与坏呢？
这个时候我们就要考虑一下复杂的的问题了，那么说了这么多，复杂度到底是什么呢？不要着急，往下看：
关于复杂度的概念：
算法在编写成可执⾏程序后，运⾏时需要耗费时间资源和空间(内存)资源 。因此衡量⼀个算法的好坏，⼀般是从 时间 和 空间 两个维度来衡量的，即 时间复杂度 和 空间复杂度 。时间复杂度主要衡量⼀个算法的运⾏快慢，⽽空间复杂度主要衡量⼀个算法运⾏所需要的额外空间。 在计算机发展的早期，计算机的存储容量很⼩。所以对空间复杂度很是在乎。但是经过计算机⾏业的迅速发展，计算机的存储容量已经达到了很⾼的程度。所以我们如今已经不需要再特别关注⼀个算法的空间复杂度
总结：
如何去衡量算法的好坏？
要从两方面考虑：时间复杂度和空间复杂度
下边就是关于时间复杂度和空间复杂度的详细解释：
2. 时间复杂度
定义：在计算机科学中，算法的时间复杂度是⼀个函数式T(N)，它定量描述了该算法的运⾏时间。时间复杂度是衡量程序的时间效率，那么为什么不去计算程序的运⾏时间呢？1. 因为程序运⾏时间和编译环境和运⾏机器的配置都有关系，⽐如同⼀个算法程序，⽤⼀个⽼编译器进⾏编译和新编译器编译，在同样机器下运⾏时间不同。2. 同⼀个算法程序，⽤⼀个⽼低配置机器和新⾼配置机器，运⾏时间也不同。3. 并且时间只能程序写好后测试，不能写程序前通过理论思想计算评估。那么算法的时间复杂度是⼀个函数式T(N)到底是什么呢？这个T(N)函数式计算了程序的执⾏次数。通过c语⾔编译链接章节学习，我们知道算法程序被编译后⽣成⼆进制指令，程序运⾏，就是cpu执⾏这些编译好的指令。那么我们通过程序代码或者理论思想计算出程序的执⾏次数的函数式T(N)，假设每 句指令执⾏时间基本⼀样(实际中有差别，但是微乎其微)，那么执⾏次数和运⾏时间就是等⽐正相关， 这样也脱离了具体的编译运⾏环境。执⾏次数就可以代表程序时间效率的优劣。⽐如解决⼀个问题的 算法a程序T(N) = N，算法b程序T(N) = N^2，那么算法a的效率⼀定优于算法b。
通过下边的案例，你可以感受的更加深刻：
请计算⼀下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;
}
}Func1 执⾏的基本操作次数：T ( N ) = N*N + 2 ∗ N + 10• N = 10 T(N) = 130• N = 100 T(N) = 10210• N = 1000 T(N) = 1002010通过对N取值分析，对结果影响最⼤的⼀项是 N*N
实际中我们计算时间复杂度时，计算的也不是程序的精确的执⾏次数，精确执⾏次数计算起来还是很 ⿇烦的(不同的⼀句程序代码，编译出的指令条数都是不⼀样的)，计算出精确的执⾏次数意义也不⼤。因为我么计算时间复杂度只是想⽐较算法程序的增⻓量级，也就是当N不断变⼤时T(N)的差别，上⾯我们已经看到了当N不断变⼤时常数和低阶项对结果的影响很⼩，所以我们只需要计算程序能代表增⻓量级的⼤概执⾏次数，复杂度的表⽰通常使⽤⼤O的渐进表⽰法。
关于大O的渐进表示法：
⼤O符号（Big O notation）：是⽤于描述函数渐进⾏为的数学符号。
推导⼤O阶规则
时间复杂度函数式T(N)中，只保留最⾼阶项，去掉那些低阶项，因为当N不断变⼤时，
低阶项对结果影响越来越⼩，当N⽆穷⼤时，就可以忽略不计了。
如果最⾼阶项存在且不是1，则去除这个项⽬的常数系数，因为当N不断变⼤，这个系数对结果影响越来越⼩，当N⽆穷⼤时，就可以忽略不计了。**
T(N)中如果没有N相关的项⽬，只有常数项，⽤常数1取代所有加法常数。
通过以上⽅法，可以得到 Func1 的时间复杂度为： O(N *N )
接下来让我们通过一些案例来进行巩固和理解吧：
关于大O的渐进法的案例：
案例一：
计算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);
}Func2执⾏的基本操作次数：F ( N ) = 2 N + 10根据推导规则第3条得出Func2的时间复杂度为： 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);
}
Func3执⾏的基本操作次数：F ( N ) = M + N因此：Func2的时间复杂度为： O ( N )
案例三;
计算Func4的时间复杂度？
void Func4(int N)
{
int count = 0;
for (int k = 0; k < 100; ++ k)
{
++count;
}
printf("%d\n", count);
}Func4执⾏的基本操作次数：F ( N ) = 100根据推导规则第1条得出Func2的时间复杂度为： O (1)
案例四：
计算strchr的时间复杂度？
const char * strchr ( const char
* str, int character)
{
const char* p_begin = s;
while (*p_begin != character)
{
if (*p_begin == '\0')
return NULL;
p_begin++;
}
return p_begin;
}strchr执⾏的基本操作次数：1）若要查找的字符在字符串第⼀个位置，则：F ( N ) = 12）若要查找的字符在字符串最后的⼀个位置， 则：F ( N ) = N3）若要查找的字符在字符串中间位置，则：F ( N ) = N /2因此：strchr的时间复杂度分为：最好情况： O (1)最坏情况： O ( N )平均情况： O ( N )
总结
通过上⾯我们会发现，有些算法的时间复杂度存在最好、平均和最坏情况。
最坏情况：任意输⼊规模的最⼤运⾏次数(上界)
平均情况：任意输⼊规模的期望运⾏次数
最好情况：任意输⼊规模的最⼩运⾏次数(下界)
⼤O的渐进表⽰法在实际中⼀般情况关注的是算法的上界，也就是最坏运⾏情况。
案例五：
计算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;
}
}BubbleSort执⾏的基本操作次数：1）若数组有序，则：F ( N ) = N2）若数组有序且为降序，则：F ( N ) = （ N ∗ ( N + 1)）/2因此：BubbleSort的时间复杂度取最差情况为： O ( N 2 )
案例六：
void func5(int n)
{
int cnt = 1;
while (cnt < n)
{
cnt *= 2;
}
}当n=2时，执⾏次数为1当n=4时，执⾏次数为2当n=16时，执⾏次数为4假设执⾏次数为 x ，则 2 的x次方 = n因此执⾏次数： x = log n因此：func5的时间复杂度取最差情况为：O (log n底数为2 )
注意课件中和书籍中 log 2 n 、 log n 、 lg n 的表⽰当n接近⽆穷⼤时，底数的⼤⼩对结果影响不⼤。因此，⼀般情况下不管底数是多少都可以省略不写，即可以表⽰为 log n不同书籍的表⽰⽅式不同，以上写法差别不⼤，我们建议使⽤ log n
案例七：
计算阶乘递归Fac的时间复杂度？
long long Fac(size_t N)
{
if(0 == N)
return 1;
return Fac(N-1)*N;
}调⽤⼀次Fac函数的时间复杂度为 O (1)⽽在Fac函数中，存在n次递归调⽤Fac函数因此：阶乘递归的时间复杂度为： O ( n )
3. 空间复杂度
空间复杂度也是⼀个数学表达式，是对⼀个算法在运⾏过程中因为算法的需要额外临时开辟的空间。空间复杂度不是程序占⽤了多少bytes的空间，因为常规情况每个对象⼤⼩差异不会很⼤，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟实践复杂度类似，也使⽤⼤O渐进表⽰法。注意：函数运⾏时所需要的栈空间(存储参数、局部变量、⼀些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运⾏时候显式申请的额外空间来确定
那么我们既然已经知道空间复杂度的计算规律了，那么接下来就是关于空间复杂度的案例了：
空间复杂度的计算案例：
案例一：
计算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;
}
}函数栈帧在编译期间已经确定好了，只需要关注函数在运⾏时额外申请的空间。BubbleSort额外申请的空间有exchange等有限个局部变量，使⽤了常数个额外空间因此空间复杂度为 O (1)
案例二：
计算阶乘递归Fac的空间复杂度？
long long Fac(size_t N)
{
if(N == 0)
return 1;
return Fac(N-1)*N;
}Fac递归调⽤了N次，额外开辟了N个函数栈帧，每个栈帧使⽤了常数个空间因此空间复杂度为： O ( N )
以上便是时间复杂度和空间复杂度的相关知识点和案例，希望可以给你带来一些收获。
下边便介绍一下我们常见的复杂度对比：
4.常见复杂度对比：
通过以上的两张图片的对比，我们可以清晰的感觉到复杂度之间的不同，所以在我们之后写代码的过程当中，要尽可能的使算法的复杂度降低，可以提高代码的运行效率，提高程序的运行效率！
好了，以上便是本博客最为重要的知识点了，如果你觉得没什么问题的话，那么就试一试下边的这道题吧，回归最初的开始，旋转数组的求解：
复杂度算法题
旋转数组
思路1时间复杂度 O ( n *n )循环K次将数组所有元素向后移动⼀位（代码不通过）上文当中，我们已经了解过代码不通过的问题了，因为时间复杂度太大的问题
void rotate(int* nums, int numsSize, int k)
{
while(k--)
{
int end = nums[numsSize-1];
for(int i = numsSize - 1;i > 0 ;i--)
{
nums[i] = nums[i-1];
}
nums[0] = end;
}
}思路2：空间复杂度 O ( n )申请新数组空间，先将后k个数据放到新数组中，再将剩下的数据挪到新数组中
void rotate(int* nums, int numsSize, int k)
{
int newArr[numsSize];
for (int i = 0; i < numsSize; ++i)
{
newArr[(i + k) % numsSize] = nums[i];
}
for (int i = 0; i < numsSize; ++i)
{
nums[i] = newArr[i];
}
}
可以看得出来实际上是能够通过的，但是用了120ms，那么有没有一种更加方便的，更加有效率的算法来提高运行效率呢？实际上是有的，且看下边的一个非常巧的方法：
思路3：空间复杂度 O (1)• 前n-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* nums,int begin,int end)
{
while(begin<end)
{
int tmp = nums[begin];
nums[begin] = nums[end];
nums[end] = tmp;
begin++;
end--;
}
}
void rotate(int* nums, int numsSize, int k)
{
k = k%numsSize;
reverse(nums,0,numsSize-k-1);
reverse(nums,numsSize-k,numsSize-1);
reverse(nums,0,numsSize-1);
}
由此可以看的出来，时间复杂度变小了之后，运行的时间也会减少，当然，在平时的学习生活当中，写代码的时候，还是尽可能的降低复杂度来提升程序的运行效率的！
总结
好了，以上便是数据结构复杂度的相关知识点了，也是本博客的全部内容，希望可以对你的学习有一些帮助，愿我们在编程的学习路上越走越远，实力越来越强！咱们下期再见！
1075
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
