数据结构初阶 算法的时间复杂度与空间复杂度的讲解 个人随堂笔记
算法的时间复杂度与空间复杂度的讲解
什么是数据结构与算法
数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的
数据元素的集合。
算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为
输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。
算法的复杂度
算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般
是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
推导大O阶方法：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
时间复杂度
算法中的基本操作的执行次数，为算法的时间复杂度。
时间复杂度，计算时为该算法的最坏运行情况，是一个稳健保守预期。
抓大头，取决定性结果的一项，是执行次数的量级，去掉那些对结果影响不大的项。忽略系数（N无限大时，系数对结果的影响可以忽略不计），常数次时（无论常数多大）复杂度为O(1)
常见的时间复杂度的计算
void Func3(int N,int M)
{
int count=0;
for(int k=0;k<3*N;k++)
{
++count;
}
for(int k=0;k<2*M;k++)
{
++count;
}
printf("%d\n",count);
}
因为N，M的量级并不清楚，时间复杂度为O(N+M)，去除系数。
如果N和M一样大，则为O(N)或O(M)，忽略系数
如果N远大于M，则为O(N)
如果N远小于M，则为O(M)
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)
end=mid-1;
else
return mid;
}
return -1;
}
每次查找时，区间数据个数减半，最坏情况，查找区间缩放到只剩一个数据时（开头，结尾，或找不到）为最坏情况，假设查找了x次，则数据个数为2^x=N，则x=log_2 N,时间复杂度为 log_2 N
递归调用函数复杂度的计算
long long Fib(size_t N)
{
if(N<3)
return 1;
return Fib(N-1)+Fib(N-2);
}
执行次数=2 ^ 0 + 2 ^ 1……2^ (N-1) = 2^N-1
时间复杂度O(2^N)
消失的数字
思路一：遍历加排序，下一个数字不等于下一个数+1，则下一个数就是消失的数字。
时间复杂度：排序最快为O(N*log N)（qsort）+遍历O(N)
思路二：计算0到N的总和减去遍历数组的总和，结果为消失的数字。
时间复杂度：遍历O(N)
思路三：遍历异或
时间复杂度：遍历异或O(N)
int missnumber(int *nums,int numsize)
{
int N=numsize;
int sum=N*(N+1)/2; //计算0到N的总和
for(int i=0;iint missnumber(int *nums,int numsize)
{
int N=numsize;
int ret=0;
for(int i=0;i空间复杂度
空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用（额外开辟）存储空间大小的量度 。
递归函数的空间复杂度
long long* Fibonacci(size_t n)
{
if (n==0)
return 0;
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]=fibaarray[i-1]+fibarray[i-2];
}
return fibarray;
}
malloc函数额外开辟了n+1个字节的空间，空间复杂度为O(N)
long long Fac(size_t n)
{
if (n==0)
return 1;
return Fac(n-1)*n;
}
递归调用时，Fac（n）-》Fac（n-1）-》……-》Fac（1）-》Fac（0）在栈上共开辟了n个常数的空间，空间复杂度为O(N)
long long Fib(size_t N)
{
if(N<3)
return 1;
return Fib(N-1)+Fib(N-2);
}
递归最大问题：深度太深，容易栈溢出
时间是累计的，空间是可以重复利用的
从Fib(N)-》Fib（N-1）……Fib(3)-》Fib（2），调用到Fib（2）时返回值时释放空间，返回Fib（3），Fib（3）-》Fib（3-1）时，将原Fib（2）的空间给Fib（3-1）复用
额外的空间开辟为Fib最深的栈帧个数，为O(N)
void func1()
{
int a=0;
printf("%p\n",&a);
}
void func2()
{
int a=0;
printf("%p\n",&a);
}
int main()
{
func1();
func2();
return 0;
}
可以看出打印的地址相同，不同函数使用同一块空间
练习题
轮转数组oj
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k时非负数
要求时间复杂度O(N)，空间复杂度O(1)
方法一：循环右旋1次，合计右旋k%N次（右旋N次数组没有改变）
时间复杂度：最坏情况下右旋N-1次，O(N^2)
空间复杂度O(1)
方法二：创建一个与原数组相同大小的空间temp，将后k个元素放到temp前面，将剩下的k-1个元素放到temp后面
时间复杂度：O(N)，遍历复制数组
空间复杂度：O(N)，开辟N个大小空间的temp数组
方法三：前N-k个数组元素逆置，后k个元素逆置，整体逆置
时间复杂度：O(N)
空间复杂度：O(1)
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
void revolve(int* arr,int numbersize ,int k) //方法一
{
int n=numbersize ;
k %= n;
for (int i = 0; i < k; i++)
{
int temp = arr[n - 1];
for (int j = n-1; j >0; j--)
{
arr[j] = arr[j-1];
}
arr[0] = temp;
}
}
void rotate(int* arr, int numbersize, int k) //方法二
{
k %= numbersize;
int* temp = (int*)malloc(sizeof(int) * numbersize);
memcpy( temp+k, arr, sizeof(int)*(numbersize-k));
memcpy( temp, arr + numbersize - k,sizeof(int)*k);
memcpy(arr, temp, sizeof(int)*numbersize);
}
void reverse(int* arr, int left, int right) //方法三
{
while (left < right)
{
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++;
right--;
}
}
void inverse(int* arr, int numbersize, int k)
{
k %= numbersize;
reverse(arr, 0, numbersize - k-1);
reverse(arr, numbersize-k, numbersize-1);
reverse(arr, 0, numbersize - 1);
}
void print(int* arr, int numbersize) //输出
{
for (int i = 0; i < numbersize; i++)
{
printf("%d", arr[i]);
}
printf("\n");
}
void test1() //测试
{
int arr[] = { 1,2,3,4,5,6,7,8,9 };
revolve(arr, sizeof(arr) / sizeof(arr[0]), 2);
print(arr, sizeof(arr) / sizeof(arr[0]));
}
void test2()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 };
rotate(arr, sizeof(arr) / sizeof(arr[0]), 2);
print(arr, sizeof(arr) / sizeof(arr[0]));
}
void test3()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 };
inverse(arr, sizeof(arr) / sizeof(arr[0]), 2);
print(arr, sizeof(arr) / sizeof(arr[0]));
}
int main()
{
test1();
test2();
test3();
return 0;
}