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

news2024/11/28 14:34:40

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

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

🔥专栏：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;
}

后言

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

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

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

相关文章

人工智能对话系统源码 手机版+电脑版二合一 全端支持 前后端分离 带完整的安装代码包以及搭建部署教程

人工智能对话系统源码 手机版+电脑版二合一 全端支持 前后端分离 带完整的安装代码包以及搭建部署教程

系统概述 该系统采用前后端分离的设计模式&#xff0c;前端负责用户界面展示与交互&#xff0c;后端负责数据处理与业务逻辑实现。前后端通过API接口进行通信&#xff0c;实现数据的实时传输与处理。系统支持全端访问&#xff0c;无论是手机还是电脑&#xff0c;都能获得良好的…
阅读更多...
Type-C接口，乱成一锅粥了！

Type-C接口，乱成一锅粥了！

前言 小白第一次接触Type-C接口的时候是2017年的夏天&#xff0c;那时候小白买了小米最新发布的小米5x手机&#xff0c;使用的是相当主流的Type-C接口。 在2017年之前&#xff0c;很多手机还是使用Micro-USB作为手机首选的充电接口。 当同宿舍的小伙伴还在为给手机充电需要分辨…
阅读更多...
Linux卸载RocketMQ教程【带图文命令巨详细】

Linux卸载RocketMQ教程【带图文命令巨详细】

巨详细Linux卸载RocketMQ教程 #查询rocketmq进程 ps -ef | grep rocketmq #杀掉相关进程 kill -9 进程id #查找安装目录 find / -name runbroker.sh #删除rocketMQ目录 rm -rf 安装目录框起来的就是进程id&#xff0c;全部杀掉 这里就是我的安装目录&#xff0c;我的删除命令…
阅读更多...
基于STM32开发的智能语音控制系统

基于STM32开发的智能语音控制系统

目录 引言环境准备智能语音控制系统基础代码实现&#xff1a;实现智能语音控制系统 4.1 语音识别模块数据读取4.2 设备控制4.3 实时数据监控与处理4.4 用户界面与反馈显示应用场景&#xff1a;语音控制的家居设备管理问题解决方案与优化收尾与总结 1. 引言 随着人工智能技术…
阅读更多...
从零开始实现自己的串口调试助手(10) - 优化 收尾 + 打包

从零开始实现自己的串口调试助手(10) - 优化 收尾 + 打包

光标位置优化 在接收槽函数中更新光标位置: // 让光标始终在结尾 ui->textEditRev->moveCursor(QTextCursor::End); ui->textEditRev->ensureCursorVisible(); // 让光标可视化 //记得HEX显示槽函数底下也得加上这两行代码 新的接收槽函数如下: void Wid…
阅读更多...
10秒钟docker 安装Acunetix

10秒钟docker 安装Acunetix

1、拉取镜像&#xff1a; 2、查看镜像&#xff1a; [rootdns-server ~]# docker images REPOSITORY TAG IMAGE ID CREATED SIZE quay.io/hiepnv/acunetix latest f8415551b8f4 2 months ago 1.98GB 3、运行镜像&#xff1a; …
阅读更多...
算法训练营day03--203.移除链表元素+707.设计链表+206.反转链表

算法训练营day03--203.移除链表元素+707.设计链表+206.反转链表

一、203.移除链表元素 题目链接&#xff1a;https://leetcode.cn/problems/remove-linked-list-elements/ 文章讲解&#xff1a;https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html 视频讲解&#xff1a;https://www.bilibili.com…
阅读更多...
CentOS7 MySQL5.7.35主从 不停机搭建 以及配置

CentOS7 MySQL5.7.35主从 不停机搭建 以及配置

如需安装MySQL&#xff0c;参照MySQL 5.7.35 安装教程 https://blog.csdn.net/CsethCRM/article/details/119418841一、主&从 环境信息准备 1.1.查看硬盘信息&#xff0c;确保磁盘够用&#xff08;主&从&#xff09; df -h1.2.查看内存信息 &#xff08;主&从&am…
阅读更多...
11 IP协议 - IP协议头部

11 IP协议 - IP协议头部

什么是 IP 协议 IP&#xff08;Internet Protocol&#xff09;是一种网络通信协议&#xff0c;它是互联网的核心协议之一&#xff0c;负责在计算机网络中路由数据包&#xff0c;使数据能够在不同设备之间进行有效的传输。IP协议的主要作用包括寻址、分组、路由和转发数据包&am…
阅读更多...
Android 应用权限

Android 应用权限

文章目录 权限声明uses-permissionpermissionpermission-grouppermission-tree其他uses-feature 权限配置 权限声明 Android权限在AndroidManifest.xml中声明&#xff0c;<permission>、 <permission-group> 、<permission-tree> 和<uses-permission>…
阅读更多...
shell编程（二）——字符串与数组

shell编程（二）——字符串与数组

本文为shell 编程的第二篇&#xff0c;介绍shell中的字符串和数组相关内容。 一、字符串 shell 字符串可以用单引号 ‘’&#xff0c;也可以用双引号 “”&#xff0c;也可以不用引号。 单引号的特点 单引号里不识别变量单引号里不能出现单独的单引号&#xff08;使用转义符…
阅读更多...
[职场] 缺点范文 #知识分享#经验分享#媒体

[职场] 缺点范文 #知识分享#经验分享#媒体

缺点范文 回答示范1&#xff1a; 我的公开演讲能力比较差&#xff0c;在公共场合讲话的时候我会感到紧张&#xff0c;不过谈论我熟悉的领域我会比较放松。所以当我需要做公开发言的时候&#xff0c;我必须要准备得很充分。我确实羡慕那些无论什么话题都能够高谈阔论的人。 回…
阅读更多...
光伏电站绘制软件的基本方法

光伏电站绘制软件的基本方法

随着可再生能源的快速发展&#xff0c;光伏电站的建设日益受到重视。为了提高光伏电站设计的效率和准确性&#xff0c;光伏电站绘制软件的应用变得至关重要。本文将介绍光伏电站绘制软件的基本方法&#xff0c;包括绘制屋顶、屋脊、障碍物和参照物&#xff0c;铺设光伏板&#…
阅读更多...
Java Web学习笔记24——Vue项目开发流程

Java Web学习笔记24——Vue项目开发流程

import是引入文件。 export是将对象导出为模块。 new Vue({ router, router: h > h(App) }).$mount(#app) App.vue: vue的组成文件以.vue结尾&#xff0c;每个组件由三个部分组成&#xff1a;<template>、<script>、<style>。 <template><d…
阅读更多...
玩游戏时服务器遭到DDOS攻击崩溃，DDOS攻击是什么？

玩游戏时服务器遭到DDOS攻击崩溃，DDOS攻击是什么？

某网游服务器突然崩溃&#xff0c;大量玩家被迫下线。随后该游戏官方出面解释是因服务器遭遇了DDoS攻击&#xff0c;所以导致登录异常。这个DDoS攻击到底是哪里来的鬼怪&#xff0c;敢这么给自己加戏&#xff1f; 什么是DDoS攻击&#xff1f; DDoS攻击&#xff0c;专业表述是“…
阅读更多...
YOLOv5白皮书-第Y5周：yolo.py文件解读

YOLOv5白皮书-第Y5周：yolo.py文件解读

&#x1f368; 本文为&#x1f517;365天深度学习训练营 中的学习记录博客&#x1f356; 原作者&#xff1a;K同学啊 一、环境 语言&#xff1a;Python3、Pytorch开发环境电脑系统&#xff1a;Windows 10语言环境&#xff1a;Python 3.9.2编译器&#xff1a;VS Code显卡&#…
阅读更多...
linux 内核映像差异介绍：vmlinux、zImage、zbImage、image、uImage等

linux 内核映像差异介绍：vmlinux、zImage、zbImage、image、uImage等

一、背景 Linux内核是整个Linux操作系统的核心部分&#xff0c;它是一个负责与硬件直接交互的软件层&#xff0c;并且提供多种服务和接口&#xff0c;让用户程序能够方便地使用硬件资源。 当我们编译自定义内核时&#xff0c;可以将其生成为以下内核映像之一&#xff1a;vmli…
阅读更多...
前端：快捷 复制chrome 控制台打印出来的 数组对象

前端：快捷 复制chrome 控制台打印出来的 数组对象

程序中console.log出来的对象。按照以下步骤操作 1.右键点击需要处理的对象&#xff0c;会出现Store as global variable&#xff0c;点击 2.点击 Store as global variable 控制台会出现 3.在控制台 输入 copy(temp1) 这样对象就复制到了你的黏贴面板里面 在代码中直接 c…
阅读更多...
k8s之deployments相关操作

k8s之deployments相关操作

k8s之deployments相关操作 介绍 官网是这样说明如下&#xff1a; 一个 Deployment 为 Pod 和 ReplicaSet 提供声明式的更新能力。 你负责描述 Deployment 中的目标状态&#xff0c;而 Deployment 控制器&#xff08;Controller&#xff09; 以受控速率更改实际状态&#xf…
阅读更多...
Soildworks学习笔记（二）

Soildworks学习笔记（二）

放样凸台基体&#xff1a; 自动生成连接两个物体两个面的基体&#xff1a; 2.旋转切除&#xff1a; 3.剪切实体&#xff1a; 4.转换实体引用&#xff1a; 将实体的轮廓线转换至当前草图使其成为当前草图的图元,主要用于在同一平面或另一个坐标中制作草图实体或其尺寸的副本。 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023