【数据结构】初识数据结构之复杂度与链表

【数据结构】初识数据结构之复杂度与链表

🔥个人主页：大白的编程日记

🔥专栏：C语言学习之路

文章目录

  • 【数据结构】初识数据结构之复杂度与链表
    • 前言
    • 一.数据结构和算法
      • 1.1数据结构
      • 1.2算法
      • 1.3数据结构和算法的重要性
    • 二.时间与空间复杂度
      • 2.1算法效率
      • 2.2算法的复杂度
      • 2.3时间复杂度的概念
      • 2.4大O的渐进表示法
      • 2.5时间复杂度计算举例
    • 三.空间复杂度
    • 四.链表
      • 4.1链表的概念及结构
      • 4.2链表的分类
      • 4.3单链表的实现
    • 后言

前言

哈喽，各位小伙伴大家好！今天我们开启全新的篇章，数据结构。简单来说数据结构就是数据在内存中的管理。今天给大家带来的是数据结构中的复杂度和链表的知识。话不多说，咱们进入正题！向大厂冲锋！

一.数据结构和算法

1.1数据结构

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

1.2算法

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

1.3数据结构和算法的重要性

目前校园招聘笔试一般采用Online Judge形式， 一般都是20-30道选择题+2道编程题，或者3-4道编程题。
2020奇安信秋招C/C++
美团2021校招笔试
网易2021校招笔试C++开发工程师



可以看出，现在公司对学生代码能力的要求是越来越高了，大厂笔试中几乎全是算法题而且难度大，中小长的笔试中才会有算法题。算法不仅笔试中考察，面试中面试官基本都会让现场写代码。而算法能力短期内无法快速提高了，至少需要持续半年以上算法训练积累，否则真正校招时笔试会很艰难，因此算法要早早准备。

二.时间与空间复杂度

2.1算法效率

如何衡量一个算法的好坏呢？比如对于以下斐波那契数列：

long long Fib(int N)
{
 if(N < 3)
 return 1;
 return Fib(N-1) + Fib(N-2);
}

斐波那契数列的递归实现方式非常简洁，但简洁一定好吗？那该如何衡量其好与坏呢？这就涉及到算法的复杂度了。

2.2算法的复杂度

复杂度分为空间复杂度和时间复杂度。算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。
因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。

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

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

在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。所以我们现在更关注算法的时间复杂度。

  • 复杂度在校招中的考察


2.3时间复杂度的概念

时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一
个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

  • 运行时间衡量
    为啥不用运行时间衡量。因为算法运行的环境不同，跑出来的时间性能自然不同。我的电脑性能更好，相同因素下，表现的性能自然更好，但是我们衡量的是代码本身。

即：找到某条基本语句与问题规模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;
}

我们计算出来的函数就是：


那如果现在我们要比较这三个算法的优略，该怎么比呢？

大家发现其实不太好比较，因为除了N可能还有一些系数和常数。那咋办呢？ 这时就可以用我们的大O的渐进表示法进行函数简化。

2.4大O的渐进表示法

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

推导大O阶方法：

  • 用常数1取代运行时间中的所有加法常数。
    我们想对函数进行大概的估算，那我们就需要保留影响最大的项，所以我们对常数项进行忽略。因为当N很大时，常数项对整个函数式结果的影响不大。

    可是当N很小时，常数项的影响反而时更大的。

但是当N很小时，我们认为这三个的性能时一样的，因为CPU的运算速度太快了。每秒至少在上亿次。所以当 N很小时，我们认为他们的性能都一样，所以我们只关注影响最大的一项。忽略常数项。

  • 验证：
    clock函数可以捕捉程序启动到某处执行的时间，单位时毫秒。
#include<stdio.h>
#include<time.h>
int main()
{
	int sum = 0;
	int begin = clock();//程序启动开始执行到这里的时间，单位时毫秒
	for (int i = 0; i < 100000000; i++)
	{
		sum++;
	}
	int end = clock();
	printf("%d time:%d", sum,end-begin);
}


大家发现我们循环一亿次只用了40ms。

  • 在修改后的运行次数函数中，只保留最高阶项。
    忽略常数项后，我们只保留最高阶的项，也就是影响最大的项。

  • 如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
    因为当N趋向于无穷大的时候，系数可以忽略。我们只关注N很大的情况，N很小的时候没有意义，因为CUP运算速度太快了。可以理解为无穷的倍数还是无穷大。

通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。

另外有些算法的时间复杂度存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)

  • 在一个长度为N数组中搜索一个数据x
    最好情况：1次找到
    最坏情况：N次找到
    平均情况：N/2次找到

在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

2.5时间复杂度计算举例

  • 题目一
// 计算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);
}

这里我们看两个循环分别是N和M次，所以用大O的渐进表示法就是O(N+M).如果一个远远小于另外一个未知数，可以忽略掉。

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

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

这里我们要分最好情况和最坏情况看：
在这里插入图片描述
最好遍历一遍，最坏遍历n-1遍。而我们只关注最坏情况，所以就是（n-1）*n/2。再用大O的渐进表示法即可。

  • 题目四：
// 计算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;
}

三.空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度 。
空间复杂度不是程序占用了多少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;
  }
}

使用了常数个额外空间，所以空间复杂度为 O(1)

  • 题目二：
// 计算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;
}

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

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

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

常见复杂度对比：

四.链表

4.1链表的概念及结构

概念：链表是⼀种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加⼏节。只需要将火车里的某节车厢去掉/加上，不会影响其他车厢，每节车厢都是独力存在的。
车厢是独立存在的，且每节车厢都有车门。想象⼀下这样的场景，假设每节⻋厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从车头走到车尾？
最简单的做法：每节车厢里都放⼀把下⼀节车厢的钥匙。

在链表里，每节“车厢”是什么样的呢？

与顺序表不同的是，链表里的每节"车厢"都是独立申请下来的空间，我们称之为“结点/节点”节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。图中指针变量 plist保存的是第⼀个节点的地址，我们称plist此时“指向”第⼀个节点，如果我们希望plist“指向”第二个节点时，只需要修改plist保存的内容为0x0012FFA0。

  • 为什么还需要指针变量来保存下⼀个节点的位置？
    链表中每个节点都是独立申请的（即需要插入数据时才去申请⼀块节点的空间），我们需要通过指针变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。

结合前面学到的结构体知识，我们可以给出每个节点对应的结构体代码：

struct SListNode
{
 int data; //节点数据假设当前保存的节点为整型：
 struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};

当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。

当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个节点的钥匙）就可以了。这就是链表的遍历。

  • 链表在逻辑上是连续的，在物理结构上不⼀定连续
  • 节点⼀般是从堆上申请的，动态开辟的。
  • 从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续
  • 哨兵位节点
    哨兵位时一个链表的节点，但是这个链表什么也不用做，相当于一个放哨的，可以方便我们头插。

4.2链表的分类

链表的结构非常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：

  • 单向或双向
  • 带头或不带头
  • 循环不循环

虽然有这么多的链表的结构，但是我们实际中最常⽤还是两种结构：
单链表和双向带头循环链表

  1. 无头单向非循环链表：结构简单，⼀般不会单独⽤来存数据。实际中更多是作为其他数据结
    构的⼦结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
  2. 带头双向循环链表：结构最复杂，⼀般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使⽤代码实现以后会发现结构会带 来很多优势，实现反而简单了，后⾯我们代码实现了就知道了。

4.3单链表的实现

  • 定义链表节点
    定义链表节点，同时重命名节点结构体和数据类型。
typedef int SLDataType;
typedef struct SListNode
{
	int SLDataType;
	struct SListNode* next;
}SLTNode;
  • 链表节点开辟

我们malloc开辟一个节点，然后判空。

SLTNode* SLTBuyNode(SLDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//创建新节点
	if (newnode)//判断是否为空
	{
		newnode->next = NULL;//置空
		newnode->SLDataType = x;//赋值
		return newnode;
	}
	else
	{
		perror("malloc fail!");//开辟空间失败
		exit(1);
	}
  • 链表尾插
    我们开辟一个节点后，对链表判空。
    如果链表为空，则让新链表成为头节点。
    否则遍历链表找到尾节点，然后让尾节点对接新节点。
void SLTPushbak(SLTNode** phead, SLDataType x)
{
	assert(phead);//断言
	SLTNode* newnode = SLTBuyNode(x);//创建节点
	if (*phead == NULL)//头节点为空
		*phead = newnode;//新节点就是头节点
	else//头节点不为空
	{
		SLTNode* pcur = *phead;//保存头节点
		while (pcur->next)//找尾
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;//尾节点对接
	}
}
  • 链表头插

开辟新节点，让新节点指针指向头节点。修改新节点为头节点。

void SLTPushPrin(SLTNode** phead, SLDataType x)
{
	assert(phead);//断言
	SLTNode* newnode = SLTBuyNode(x);//开辟新结点
	newnode->next = *phead;//指向头节点
	*phead = newnode;//成为新结点
}
  • 链表指定位置之后插入
    开辟新节点，让新节点指向pos位置后的节点，
    再让pos节点指向新节点。
void STLInserafter(SLTNode* pos, SLDataType x)
{
	assert(pos);//断言
	SLTNode* newnode = SLTBuyNode(x);//开辟新空间
	newnode->next = pos->next;//新节点指向pos后的节点
	pos->next = newnode;//pos节点指向新节点
}
  • 链表尾删
    断言检测链表时否为空。
    如果只有一个节点，直接free删除后让头节点指向空
    否则遍历链表找到倒数第二个节点，free删除尾节点，
    再让倒数第二个节点指向空。
void STLPopback(SLTNode** phead)
{
	assert(phead && *phead);//断言，链表不能为空
	SLTNode* pcur = *phead;//复制头节点
	if ((pcur)->next == NULL)//只有一个节点
	{
		free(pcur);
		*phead= NULL;//删除节点
	}
	else
	{
		while (pcur->next->next)//找尾的前一个结点
		{
			pcur = pcur->next;
		}
		free(pcur->next);//删除尾节点
		pcur->next = NULL;//置空
		pcur = NULL;
	}
}
  • 链表头删

断言检测链表为空。
先保存当前头节点。
先让头节点的下一个节点成为头节点。
再free释放保存的头节点

void STLPopPrin(SLTNode** phead)
{
	assert(phead&&*phead);//断言
	SLTNode** pcur = *phead;//复制头节点
	*phead = (*phead)->next;//指向下一个节点
	free(pcur);//删除头节点
	pcur = NULL;//置空
}
  • 链表指定位置删除

断言检测链表是否为空
如果pos位置时头节点，直接头删。
否则遍历找到pos的前节点，让pos前节点指向pos后节点，free删除pos节点

void STLErase(SLTNode** phead, SLTNode* pos)
{
	assert(phead && *phead);//断言
	assert(pos);
	SLTNode* pcur = *phead;//复制头节点
	if (pcur== pos)//pos节点就是头节点
	{
		STLPopPrin(phead);//头删
	}
	else
	{
		while (pcur->next != pos)//找pos前节点
		{
			pcur = pcur->next;
		}
		pcur->next = pos->next;//pos前节点指向pos后节点
		free(pos);//删除pos节点
		pos = NULL;//置空
	}
}
  • 链表指定位置之后删除

断言检测链表是否为空
保存pos后的节点，让pos节点指向pos的后后节点
free删除保存的pos后节点。

void STLEraseafter(SLTNode* pos)
{
	assert(pos && pos->next);//断言
	SLTNode* pcur = pos->next;//保存pos后节点
	pos->next = pcur->next;//pos指向pos后后节点
	free(pcur);//删除pos后节点
	pcur=NULL;
}
  • 链表指定位置前插入

断言检测链表是否为空，开辟新结点
如果pos位置时头节点，直接头插
否则遍历找到pos前节点，让新节点指向pos节点
让pos前节点指向新节点。

void STLInser(SLTNode** phead, SLTNode* pos, SLDataType x)
{
	assert(phead&&*phead);//断言
	assert(pos);//断言
	SLTNode* newnode = SLTBuyNode(x);//开辟空间
	SLTNode* pcur = *phead;//复制头节点
	if (pos == pcur)//头节点位前插
	{
		SLTPushPrin(phead, x);//头插
	}
	else
	{
		while (pcur->next != pos)//找pos前节点
		{
			pcur = pcur->next;//移动
		}
		newnode->next = pos;//新节点指向pos节点
		pcur->next = newnode;//pos前节点指向新节点
	}
}
  • 链表的查找
    遍历链表每次判断是否要查找的节点即可。
SLTNode* STLFind(SLTNode* phead, SLDataType x)
{
	SLTNode* pcur = phead;//复制头节点
	while (pcur)//循环遍历
	{
		if (pcur->SLDataType == x)//判断是否为目标值
			return pcur;//返回目标节点
		pcur = pcur->next;//不是继续遍历
	}
	return NULL;
}

后言

这就是数据结构中的的复杂度和链表，这些是数据结构的基础，正所谓“基础不牢 地动山摇”。我们要对这些基础多加巩固。今天就分享到这里！感谢各位小伙伴垂阅！咱们下期见！拜拜~

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

[AIGC] Springboot 自动配置的作用及理由

[AIGC] Springboot 自动配置的作用及理由

在详细解释SpringBoot的自动配置之前&#xff0c;先介绍以下背景知识。在创建现代复杂的应用程序时&#xff0c;一个困难的部分是正确地设置您的开发环境。这个问题尤其在Java世界中尤为突出&#xff0c;因为您必须管理和配置许多独立的标准和技术。 当我们谈论Spring Boot的自…
阅读更多...
[NOVATEK] NT96580行车记录仪功能学习笔记(持续更新~

[NOVATEK] NT96580行车记录仪功能学习笔记(持续更新~

一、u-Boot升级灯 运行u-Boot程序时LED灯闪烁，找到运行过程中一直在运行的函数在里面进行LED引脚电平的翻转 宏定义 Z:\SunFan\AHD580\pip\na51055_PIP\BSP\u-boot\include\configs\nvt-na51055-evb.h Z:\SunFan\AHD580\pip\na51055_PIP\BSP\u-boot\drivers\mtd\nvt_flash_…
阅读更多...
HTTP协议分析实验：通过一次下载任务抓包分析

HTTP协议分析实验：通过一次下载任务抓包分析

HTTP协议分析 问&#xff1a;HTTP是干啥用的&#xff1f; 最简单通俗的解释&#xff1a;HTTP 是客户端浏览器或其他程序与Web服务器之间的应用层通信协议。 在Internet上的Web服务器上存放的都是超文本信息&#xff0c;客户机需要通过HTTP协议传输所要访问的超文本信息。 一、…
阅读更多...
btstack协议栈实战篇--GAP Link Key Management

btstack协议栈实战篇--GAP Link Key Management

btstack协议栈---总目录-CSDN博客 目录 1.GAP 链接密钥逻辑 2.蓝牙逻辑 3.主应用程序设置 4.log信息 展示了如何遍历存储在 NVS 中的经典链接密钥&#xff0c;链接密钥是每个设备-设备绑定的。如果蓝牙控制器可以交换&#xff0c;例如在桌面系统上&#xff0c;则每个控制器都需…
阅读更多...
Shell脚本学习_环境变量深入

Shell脚本学习_环境变量深入

目录 1.Shell环境变量深入&#xff1a;自定义系统环境变量 2.Shell环境变量深入&#xff1a;加载流程原理介绍 3.Shell环境变量深入&#xff1a;加载流程测试 4.Shell环境变量深入&#xff1a;识别与切换Shell环境类型 1.Shell环境变量深入&#xff1a;自定义系统环境变量 …
阅读更多...
8.3 Go 包的组织结构

8.3 Go 包的组织结构

&#x1f49d;&#x1f49d;&#x1f49d;欢迎莅临我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:「stormsha的主页」…
阅读更多...
WPS JS宏获取自动筛选后的行数

WPS JS宏获取自动筛选后的行数

//WPS JS宏获取自动筛选后的行数 function getFilterRowCnt(shtRng)//shtRng表示筛选目标工作表范围 {let lngRowCnt 0;for(let rngCell of shtRng.SpecialCells(xlCellTypeVisible).Areas)//获取自动筛选后的单元格行数{lngRowCnt lngRowCnt rngCell.Rows.Count;}return ln…
阅读更多...
从0到1：企业办公审批小程序开发笔记

从0到1：企业办公审批小程序开发笔记

可行性分析 企业办公审批小程序&#xff0c;适合各大公司&#xff0c;企业&#xff0c;机关部门办公审批流程&#xff0c;适用于请假审批&#xff0c;报销审批&#xff0c;外出审批&#xff0c;合同审批&#xff0c;采购审批&#xff0c;入职审批&#xff0c;其他审批等规划化…
阅读更多...
关于音乐播放器与系统功能联动功能梳理

关于音乐播放器与系统功能联动功能梳理

主要实现功能&#xff1a; 一、通知栏播放显示和控制 二、系统下拉栏中播放模块显示同步 三、与其他播放器状态同步&#xff1a;本应用播放时暂停其他应用播放&#xff0c;进入其他应用播放时&#xff0c;暂停本应用的后台播放 通知栏播放的显示和控制&#xff1a; 通过Not…
阅读更多...
RTKLIB之RTKPLOT画图工具

RTKLIB之RTKPLOT画图工具

开源工具RTKLIB在业内如雷贯耳&#xff0c;其中的RTKPLOT最近正在学习&#xff0c;发现其功能之强大&#xff0c;前所未见&#xff0c;打开了新的思路。 使用思博伦GSS7000卫星导航模拟器,PosApp软件仿真一个载具位置 1&#xff0c;RTKPLOT支持DUT 串口直接输出的NMEA数据并…
阅读更多...
基于深度学习的中文标点预测模型-中文标点重建（Transformer模型）【已开源】

基于深度学习的中文标点预测模型-中文标点重建（Transformer模型）【已开源】

基于深度学习的中文标点预测模型-中文标点重建&#xff08;Transformer模型&#xff09;提供模型代码和训练好的模型 前言 目前关于使用深度学习对文本自动添加标点符号的研究并不多见&#xff0c;已知的开源项目也较少&#xff0c;而对该领域的详细介绍更是稀缺。然而&#x…
阅读更多...
苹果手机微信如何直接打印文件

苹果手机微信如何直接打印文件

在快节奏的工作和生活中&#xff0c;打印文件的需求无处不在。但你是否曾经遇到过这样的困扰&#xff1a;打印店价格高昂&#xff0c;让你望而却步&#xff1f;今天&#xff0c;我要给大家介绍一款神奇的微信小程序——琢贝云打印&#xff0c;让你的苹果手机微信直接变身移动打…
阅读更多...
React Hooks路由传参

React Hooks路由传参

场景&#xff1a;如何把想要的参数带到跳转过去的页面里呢&#xff1f;很简单 上代码&#xff1a; 在你需要跳转的页面上 引入 Link用来跳转使用 Link跳转并携带参数 然后需要什么参数就带什么过去喽 这里record里面存的就是我的数据 我只需要id和state然后到你跳转过去的页面…
阅读更多...
MySQL-备份（三）

MySQL-备份（三）

备份作用&#xff1a;保证数据的安全和完整。 一 备份类别 类别物理备份 xtrabackup逻辑备份mysqldump对象数据库物理文件数据库对象&#xff08;如用户、表、存储过程等&#xff09;可移植性差&#xff0c;不能恢复到不同版本mysql对象级备份&#xff0c;可移植性强占用空间占…
阅读更多...
【C语言】详解函数(上)（庖丁解牛版）

【C语言】详解函数(上)（庖丁解牛版）

文章目录 1. 前言2. 函数的概念3.库函数3.1 标准库和头文件3.2 库函数的使用3.2.1 头文件的包含3.2.2 实践 4. 自定义函数4.1 自定义函数的语法形式4.2 函数的举例 5. 形参和实参5.1 实参5.2 形参5.3 实参和形参的关系 6. return 语句6. 总结 1. 前言 一讲到函数这块&#xff…
阅读更多...
算法—字符串操作

算法—字符串操作

394. 字符串解码 - 力扣&#xff08;LeetCode&#xff09; class Solution { public:string longestCommonPrefix(vector<string>& strs) { string retstrs[0];//***1***记得先要初始化ret&#xff0c;作为第一个比较值for(int i0;i<strs.size();i){retfoundcom…
阅读更多...
聪明人社交的基本顺序：千万别搞反了，越早明白越好

聪明人社交的基本顺序：千万别搞反了，越早明白越好

聪明人社交的基本顺序&#xff1a;千万别搞反了&#xff0c;越早明白越好 国学文化 德鲁克博雅管理 2024-03-27 17:00 作者&#xff1a;方小格 来源&#xff1a;国学文化&#xff08;gxwh001&#xff09; 导语 比一个好的圈子更重要的&#xff0c;是自己优质的能力。 唐诗宋…
阅读更多...
视觉SLAM十四讲：从理论到实践（Chapter9：后端1）

视觉SLAM十四讲：从理论到实践（Chapter9：后端1）

前言 学习笔记&#xff0c;仅供学习&#xff0c;不做商用&#xff0c;如有侵权&#xff0c;联系我删除即可 一、目标 1.理解后端的概念。 2.理解以EKF为代表的滤波器后端的工作原理。 3.理解非线性优化的后端&#xff0c;明白稀疏性是如何利用的。 4.使用g2o和Ceres实际操作…
阅读更多...
代码随想录算法训练营第36期DAY49

代码随想录算法训练营第36期DAY49

DAY49 139单词拆分 没有思路。 回溯法 回溯怎么做呢&#xff1a;拼接str&#xff0c;看能不能拼出来。注意每个单词能用多次&#xff0c;不是用了就没。 但是语法还是难写。 自己的思路不好&#xff0c;题解思路&#xff1a;枚举所有分割字符串&#xff0c;判断是否在字典…
阅读更多...
史上最有趣嫁妆：晋公盘的传奇

史上最有趣嫁妆：晋公盘的传奇

在遥远的春秋时代&#xff0c;晋国的晋文公为他的女儿用心打造了一件独特的嫁妆——晋公盘。 晋公盘由青铜制成&#xff0c;形状独特&#xff0c;工艺精湛。在晋公盘内底中央&#xff0c;一对精美的浮雕龙盘绕成圆形&#xff0c;盘上饰有鸟、龟、鱼、蛙等多种动物&#xff0c;最…
阅读更多...
最新文章

Copyright @ 2022~2023