【数据结构初阶】一. 复杂度讲解

news2024/10/7 10:13:49

=========================================================================

相关代码gitee自取：

C语言学习日记: 加油努力 (gitee.com)

 =========================================================================

接上期：

学C的第三十四天【程序环境和预处理】_高高的胖子的博客-CSDN博客

 =========================================================================

                     

1 . 算法效率

（1）. 什么是数据结构：

               

数据结构(Data Structure)是计算机存储、组织数据的方式，

指相互之间存在一种或多种特定关系的数据元素的集合。

                     

                    

（2）. 什么是算法：

                

算法(Algorithm)就是定义良好的计算过程，

它取一个或一组的值为输入，并产生出一个或一组值作为输出。

简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

                     

                    

（3）. 算法的复杂度：

                     

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源。

因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，

即时间复杂度和空间复杂度。

                      

时间复杂度主要衡量一个算法的运行快慢，

而空间复杂度主要衡量一个算法运行所需要的额外空间。

在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。

但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。

所以我们如今已经不需要再特别关注一个算法的空间复杂度。

               

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                   

2 . 时间复杂度

（1）. 时间复杂度的概念：

               

在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。

一个算法执行所耗费的时间，从理论上说，是不能算出来的，

只有你把你的程序放在机器上跑起来，才能知道。

但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，

所以才有了时间复杂度这个分析方式。

            

一个算法所花费的时间与其中语句的执行次数成正比例，

算法中的基本操作的执行次数，为算法的时间复杂度。

                       

即：

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

             

图例：Func1执行的基本操作次数

                 

上图得到的Func1执行的基本次数为：

F(N) = N^2 + 2*N +10

但实际我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，

而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

                     

                    

（2）. 大O的渐进表示法：

          

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

            

推导大O阶方法：

1、用常数1取代运行时间中的所有加法常数。

2、在修改后的运行次数函数中，只保留最高阶项。

3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

            

使用大O的渐进表示法以后，

F(N) = N^2 + 2*N +10

第一步：+10 变为 +1

第二步：保留最高阶项 N^2

第三步：最高项相乘常数为1，不用去除

            

所以Func1的时间复杂度：O(N^2)

N = 10             F(N) = 100        

N = 100           F(N) = 10000    

N = 1000         F(N) = 1000000

通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，

简洁明了的表示出了执行次数。

大O的渐进表示法本质计算的是算法属于哪个量级。

           

另外有些算法的时间复杂度存在最好、平均和最坏情况：

（可查看下方案例四）

最坏情况：任意输入规模的最大运行次数(上界)

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数(下界)

                

例如：在一个长度为N数组中搜索一个数据x

最坏情况：N次找到

平均情况：N/2次找到

最好情况：1次找到

在实际操作下一般情况关注的是算法的最坏运行情况，

所以数组中搜索数据时间复杂度为O(N)

                     

                    

（3）. 常见时间复杂度计算案例：

          

案例一：

//示例一：
//计算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);
}

图示：

               

               

案例二：

//示例二：
//计算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);
}

图示：

               

               

案例三：

//示例三：
//计算Func4的时间复杂度：
void Func4(int N)
{
	int count = 0;
	for (int k = 0; k < 100; ++k)
	{
		++count;
	}

	printf("%d\n", count + N);
}

图示：“cpu技术太强了”

               

               

案例四：

//示例四：
//计算strchr的时间复杂度：
const char* strchr(const char* str, int character);
//strchr库函数：在str字符数组中查找一个字符

图示：

               

               

案例五：

//示例五：
#include <stdio.h>
//计算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;
		}
	}
}

图示：

               

               

案例六：

//示例六：
//计算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;
}

图示：

               

               

案例七：

//示例七：
//计算阶乘递归Fac的时间复杂度：
long long Fac(size_t N)
{
	if (0 == N)
	{
		return 1;
	}

	return Fac(N-1)*N;
}

图示：

               

               

案例八：

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

图示：

                     

                    

（4）. 常见时间复杂度对比

             

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

5201314O(1)常数阶
3n + 4O(n)线性阶
3n^2 + 4n + 5O(n^2)平方阶
3log(2)n + 4O(logn)对数阶
2n + 3nlog(2)n + 14O(nlogn)nlogn阶
n^3 + 2n^2 + 4n + 6O(n^3)立方阶
2^nO(2^n)指数阶

         

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

             

3 . 空间复杂度

（1）. 空间复杂度的概念：

                     

空间复杂度也是一个数学表达式，

是对一个算法在运行过程中额外临时占用存储空间大小的量度。

                

空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，

所以空间复杂度算的是变量的个数。

空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。

                   

注意：

函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)

在编译期间已经确定好了，

因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

                     

                    

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

图示：

           

           

案例二：

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

图示：

           

           

案例三：

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

	return Fac(N-1)*N;
}

图示：

         

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

             

4 . 复杂度的oj练习

（1）. 时间复杂度练习：消失的数字

                   

对应链接：

面试题 17.04. 消失的数字 - 力扣（LeetCode）

              

题目：

           

解决思路一：使用等差数列公式

             

假设数组nums包含从0到n的所有整数，

那么就可以使用 0+N等差公式 计算出一个结果，

该结果就等于 0~n的各数相加总和，

再用这个结果 减去 数组中的值，

结果就是消失的数字的值

              

图示：

对应代码：
int missingNumber(int* nums, int numsSize){
    int N = numsSize;

    int ret = N*(N+1)/2;

    for(int i = 0; i < N; i++)
    {
        ret -= nums[i];
    }

    return ret;
}

              

解决思路二：异或法

             

先用 0 异或 完整的0~N各值，

再用该异或的结果来 异或 nums数组（少一个值）

因为异或后相同为0，相异为1，

此时两对值中相同的值就会异或为0，

nums少的一个值异或后就会得到该值

              

图示：

对应代码：
int missingNumber(int* nums, int numsSize){

    int N = numsSize;

    int x = 0; //用来保存异或后的结果

    for(int i = 0; i <= N; ++i)
    {
        x ^= i;
    }

    for(int i = 0; i < N; ++i)
    {
        x ^= nums[i];
    }

    return x;
}

                      

                    

（2）. 空间复杂度练习：轮转数组

                   

对应链接：

189. 轮转数组 - 力扣（LeetCode）

               

题目：要求时间复杂度为O(N)，空间复杂度为为O(1)

           

解决思路一：整体右旋

             

将原数组分为两部分，

假设需要右旋k个数字，

以原数组末尾k个数字为一组，剩下其他数字为一组，

两组进行调换，即可实现

              

图示：

对应代码：
void rotate(int* nums, int numsSize, int k){
    
    //用空间换时间：

    int n = numsSize; //数组长度

    int* tmp = (int*)malloc(sizeof(int)*n);

    k %= n; //确保要右旋个数小于数组大小
    
    //直接使用memcpy函数进行调换：

    memcpy(tmp, nums+n-k, sizeof(int)*k); //把后k个值移到前面
    // tmp : 起始位置
    // nums+n-k : 数组nums后k个值的起始位置
    // sizeof(int)*k ：拷贝k个int大小的数据

    memcpy(tmp+k, nums, sizeof(int)*(n-k)); //把后k个值移到前面
    // tmp+k : 拷贝到tmp+k的位置，因为上面把后k个值放在了前面
    // nums : 数组nums开始位置
    // sizeof(int)*(n-k) ：拷贝(n-k)个int大小的数据

    //再赋给数组nums：
    memcpy(nums, tmp, sizeof(int)*n);

    //释放开辟的动态空间：
    free(tmp);
}

           

解决思路二：逆置

             

将原数组的前 n-k 个数逆置，

后 k 个数也逆置，

最后再整体逆置，即可实现

              

图示：

对应代码：
//逆置函数：
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){
    k %= numsSize;

    //逆置前 n-k 个数：
    reverse(nums, 0, numsSize-k-1);

    //逆置后 k 个数：
    reverse(nums, numsSize-k, numsSize-1);

    //最后整体逆置：
    reverse(nums, 0, numsSize-1);
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/973871.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MyBatis Plus 学习笔记

MyBatis Plus 学习笔记

MyBatis Plus 国产的开源框架&#xff0c;基于 MyBatis 核心功能就是简化 MyBatis 的开发&#xff0c;提高效率。 MyBatis Plus 快速上手 Spring Boot(2.3.0) MyBatis Plus&#xff08;国产的开源框架&#xff0c;并没有接入到 Spring 官方孵化器中&#xff09; 1、创建 …
阅读更多...
Grad-CAM 小陈读paper系列（摘要加引言）

Grad-CAM 小陈读paper系列（摘要加引言）

Abstract 我们提出了一种基于卷积神经网络 (CNN) 的模型的决策生成“视觉解释”的技术&#xff0c;使它们更加透明。我们的方法——梯度加权类激活映射&#xff08;Grad-CAM&#xff09;&#xff0c; 使用任何目标概念的梯度&#xff08;例如“狗”甚至标题的 logits&#xf…
阅读更多...
新品登场！雅特力发布AT32F402与AT32F405高速USB2.0 OTG MCU

新品登场！雅特力发布AT32F402与AT32F405高速USB2.0 OTG MCU

因应高速USB市场需求&#xff0c;产品技术不断推陈出新&#xff0c;USB2.0发展带来的高速连接能力&#xff0c;优化消费者的产品使用体验&#xff0c;且由于支持即插即用和热插拔&#xff0c;提高设备易用性&#xff0c;USB接口在各项设备中成为主流通用接口。在USB2.0标准中&a…
阅读更多...
网站做SEO为什么见效慢?都有哪些原因导致？

网站做SEO为什么见效慢?都有哪些原因导致？

SEO是一种具有一定运营周期的网络营销模式&#xff0c;与其他网络营销方式不同&#xff0c;它在短时间内可能不会产生营销效果&#xff0c;因为网站SEO优化是一项依赖于积累和坚持的工作。一般来说&#xff0c;搜索引擎优化的结果在一年左右会更加稳定。之所以在一些情况下见效…
阅读更多...
【⑰MySQL】 变量 | 循环 | 游标 | 处理程序

【⑰MySQL】 变量 | 循环 | 游标 | 处理程序

前言 ✨欢迎来到小K的MySQL专栏&#xff0c;本节将为大家带来MySQL变量 | 循环 | 游标 | 处理程序的分享✨ 目录 前言1. 变量1.1系统变量1.2 用户变量 2. 定义条件与处理程序2.1 案例分析2.2 定义条件2.3 定义处理程序2.4 案例解决 3. 流程控制3.1 分支结构3.2 循环结构3.3 跳转…
阅读更多...
leaflet · 初体验

leaflet · 初体验

首先关于地图的组件有很多&#xff0c;leaflet就是其一&#xff0c;Leaflet 是一个开源的 JavaScript 库&#xff0c;用于在网页上创建交互式地图。它提供了一系列易于使用的函数和方法&#xff0c;使开发者可以轻松地添加地图、标记、图层和交互功能。 通过命令下载插件l…
阅读更多...
Astro建站教程：安装nodejs，npm下载Astro，安装扩展

Astro建站教程：安装nodejs，npm下载Astro，安装扩展

下载Nodejs LTS版&#xff1a;https://nodejs.org/en 安装步骤全默认即可&#xff0c;安装路径可以根据自己的爱好更改在桌面右键打开cmd或powershell&#xff0c;输入node -v和npm -v测试是否安装成功 浏览器打开https://docs.astro.build/en/install/auto/ 复制里面的npm cre…
阅读更多...
Sigrity Power DC 19 导入translator转换后文件显示unsupported file

Sigrity Power DC 19 导入translator转换后文件显示unsupported file

Sigrity Power DC 19 导入translator转换后文件显示unsupported file的解决办法 先create New Workspace&#xff0c;然后load Layout 选择Load an existing Layout 选择spd文件 List item
阅读更多...
Transform和小写transform的关系

Transform和小写transform的关系

1.为什么Transform类是保护的不能通过new 来实例化对象，也没有静态函数，而Rotate()这种方法却属于它，该如何访问？ Transform 类还是被保护的不允许用户修改！ protected Transform(); 是一个受保护的构造函数，不能直接实例化 Transform 类。 2.为甚么transform可以访问Tr…
阅读更多...
华为数通方向HCIP-DataCom H12-821题库(单选题：281-300)

华为数通方向HCIP-DataCom H12-821题库(单选题：281-300)

第281题 OSPF 协议对邻居路由器之间交换的所有数据包都具有认证能力，在VRP系统中，OSPF支持以下哪一种算法? A、DES B、MD5 C、AES D、RSA 答案：B 解析: 在VRP系统中，OSPF协议支持的认证算法是MD5。 第282题 以下关于堆叠拓扑连接方式的描述，错误的是哪一项? A、根…
阅读更多...
Meta AI 多语言阅读理解数据集 Belebele

Meta AI 多语言阅读理解数据集 Belebele

Meta AI 宣布推出一款涵盖 122 种语言变体的多语言阅读理解数据集&#xff0c;名为 Belebele。“我们希望这项工作能够引发围绕 LLM 多语言性的新讨论”。 BELEBELE 是首个跨语言并行数据集&#xff0c;可以直接比较所有语言的模型性能。该数据集涵盖了 29 种脚本和 27 个语系中…
阅读更多...
2.4 PE结构：节表详细解析

2.4 PE结构：节表详细解析

节表&#xff08;Section Table&#xff09;是Windows PE/COFF格式的可执行文件中一个非常重要的数据结构&#xff0c;它记录了各个代码段、数据段、资源段、重定向表等在文件中的位置和大小信息&#xff0c;是操作系统加载文件时根据节表来进行各个段的映射和初始化的重要依据…
阅读更多...
百度自研高性能ANN检索引擎，开源了

百度自研高性能ANN检索引擎，开源了

作者 | Puck项目组 导读 Puck是百度自研的开源ANN检索引擎。Puck开源项目包含两种百度自研的检索算法&#xff0c;以高召回、高准确、高吞吐为目标&#xff0c;适用于多种数据规模和场景。随着业务发展不断的优化和迭代&#xff0c;进行充分的技术开发和测试&#xff0c;确保了…
阅读更多...
深入剖析计算机网络和操作系统：面试必备知识解析

深入剖析计算机网络和操作系统：面试必备知识解析

深入剖析计算机网络和操作系统的核心概念和面试题&#xff0c;帮助大家全面理解和掌握这两个重要领域的关键知识&#xff0c;为面试做好准备。 计算机网络 什么是TCP拥塞控制&#xff1f;它的目的是什么&#xff1f; TCP拥塞控制是一种机制&#xff0c;用于在网络中控制数据流…
阅读更多...
简述电子企业MES管理系统解决方案的实施策略

简述电子企业MES管理系统解决方案的实施策略

引言&#xff1a;在电子制造企业中&#xff0c;随着产品种类的增多和订单数量的增长&#xff0c;传统的手工管理方式已经无法满足企业的生产需求。为了提高生产效率&#xff0c;降低成本&#xff0c;提高订单的履行速度和准确性&#xff0c;电子企业需要实施MES管理系统。本文将…
阅读更多...
【C++】STL-函数对象 + 谓词

【C++】STL-函数对象 + 谓词

1.函数对象使用 #include <iostream> using namespace std;//STL-函数对象&#xff08;仿函数&#xff09;class MyAdd { public:int operator()(int v1, int v2){return v1 v2;} }; //1、函数对象在使用时&#xff0c;可以像普通函数那用调用&#xff0c;可以有参数&am…
阅读更多...
NineData 中标移动云数据库传输项目

NineData 中标移动云数据库传输项目

导读近日&#xff0c;玖章算术 NineData 智能数据管理平台成功中标《2023 年移动云数据库传输服务软件项目》&#xff0c;中标金额为 406 万。这标志着玖章算术 NineData 平台已成功落地顶级运营商行业&#xff0c;并在数据管理方面实现了大规模应用实践。 NineData 中标 2023 …
阅读更多...
2023年Python依然是霸主？十大企业编程语言揭秘！

2023年Python依然是霸主？十大企业编程语言揭秘！

计算机编程语言是现代企业和科技领域不可或缺的一部分&#xff0c;它们为程序员提供了与计算机进行交流的工具。就像人类有多种交流语言一样&#xff0c;计算机编程语言也多种多样&#xff0c;每种语言都有其独特的特点和用途。随着数字化时代的来临&#xff0c;企业在选择编程…
阅读更多...
ChatGPT AIGC 一键总结SQL优化所有知识点

ChatGPT AIGC 一键总结SQL优化所有知识点

SQL优化一直是程序员非常关注的内容，使用ChatGPT AIGC结合思维导图进行总结SQL优化的所有知识点内容。 非常简单实用的操作，就得到了如何进行SQL优化的所有细节。 更多内容见： AIGC ChatGPT ，BI商业智能， 可视化Tableau, PowerBI, FineReport， 数据库Mysql Oracle， Off…
阅读更多...
Cyber RT学习---5.Cyber RT通信机制解析与实践

Cyber RT学习---5.Cyber RT通信机制解析与实践

5.Cyber RT通信机制解析与实践 5.1 通信机制简介 5.1.1 话题通信 模式&#xff1a; 以发布订阅的方式实现不同节点之间数据交互的通信模式。 如图1-1所示&#xff0c;Listener-Talker通信首先创建了两个Node&#xff0c;分别是Talker Node和 Listener Node。 每个Node实例化…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023