数据结构 | 算法的时间复杂度和空间复杂度【详解】

news2024/11/15 13:00:42

数据结构 | 算法的时间复杂度和空间复杂度【详解】

1. 什么是数据结构？

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

2. 什么是算法？

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

3. 算法效率

  • 算法效率是指算法执行的时间，算法执行时间需通过依据该算法编制的程序在计算机上运行时所消耗的时间来度量。在现在的计算机硬件环境中，比较少需要考虑这个问题了，特别是pc机的编程，内存空间越来越大，所以被考虑得也越来越少，不过一个好的程序员，都应该对自己的程序有要求，每一个for比别人少一次判断1000个for就能够少掉很多的运行时间。所以能够理解，能够大概的去运用"效率度量"还是有很大意义的。

  • 算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。 时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算 机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

4. 时间复杂度

4.1 时间复杂度的概念

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

即：找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。
实际中我们计算时间复杂度的时候其实并不需要计算精确的执行次数，而只需要知道大概执行次数，所以这里我们引入了大O的渐进表示法。其中大O符号是用于描述函数渐进行为的数学符号。

案例1：

请计算一下Func1中++count语句总共执行了多少次？

  • 如果用一个函数F(N)来解释的话，怎么解释？【F(N) = N*N + 2N + 10】这是一个函数式
    这并不方便我们进行比较，能不能简化一下？

这里的时间复杂度是要取影响最大的项
大O渐进表示法：估算–>O(N^2)–>O(N)
我们这里不关心硬件，相同的配置N比N^2的程序要快

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;
	}
	printf("%d\n", count);
}

Func1 执行的基本操作次数 ：
在这里插入图片描述

  • N = 10 F(N) = 130
  • N = 100 F(N) = 10210
  • N = 1000 F(N) = 1002010

实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

4.2 推导大O阶的方法：

大 O 表示法是一种计算机科学和算法分析中常用的渐进表示法，用于描述算法的时间复杂度和空间复杂度。它帮助我们衡量算法在输入规模增加时，运行时间或内存使用的增长趋势，而不需要精确地测量或比较具体的运行时间。

大 O 表示法使用 “O(f(n))” 的形式，其中 “f(n)” 表示输入规模 “n” 的函数。这意味着当输入规模足够大时，算法的运行时间或内存使用将以 “f(n)” 函数的方式增长。以下是一些常见的大 O 表示法及其含义：

  • O(1)：常数时间复杂度
    表示算法的运行时间不受输入规模的影响，无论输入有多大，运行时间都是固定的。
  • O(log n)：对数时间复杂度
    表示算法的运行时间以对数方式增长，通常见于二分查找等分治算法。
  • O(n)：线性时间复杂度
    表示算法的运行时间与输入规模线性增长，随着输入规模增加，运行时间也会线性增加。
  • O(n log n)：线性对数时间复杂度
    表示算法的运行时间随着输入规模的对数线性增加，常见于快速排序和归并排序等算法。
  • O(n^2)：二次时间复杂度
    表示算法的运行时间与输入规模的平方成正比，通常见于嵌套循环等情况。
  • O(n^k)：多项式时间复杂度
    表示算法的运行时间与输入规模的 k 次方成正比，其中 k 为常数。
  • O(2^n)：指数时间复杂度
    表示算法的运行时间随着输入规模的指数级增长，通常表示算法的效率非常低。
  • O(n!)：阶乘时间复杂度
    表示算法的运行时间随着输入规模的阶乘级增长，通常表示算法的效率非常低。
  • 大 O 表示法的目的是为了提供算法效率的一种抽象概念，让人们能够更容易比较不同算法的性能，并估计它们在大规模输入下的行为。通过了解算法的大 O 复杂度，开发者可以选择合适的算法来解决问题，以便在实际应用中获得更好的性能。
    在这里插入图片描述

使用大O的渐进表示法以后，Func1的时间复杂度为：在这里插入图片描述

  • N = 10 F(N) = 100
  • N = 100 F(N) = 10000
  • N = 1000 F(N) = 1000000

4.3 常见时间复杂度计算举例：

接下来就看看下面这几个案例，相信你看完就有一定的了解

实例2：

计算Func2的时间复杂度？

  • 我们前期就一点一点的算，F(N) = 2N + 10
  • 时间复杂度是什么?【O(N)】
  • 就是取最大的那一项，当N无限大的时候N和2N没有区别，所以系数要去掉
  • 时间复杂度不是算次数，是算量级
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);
}

实例3：

计算Func3的时间复杂度？

  • 如果不确定M和N的关系，可能M很大，可能N很大–> O(M+N)或者O(max(M,N))
  • 如果N远大于M–>O(N)
  • 如果M远大于N–>O(M)
  • 如果N和M差不多大–>O(N) or O(M)
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);
}

实例4：

计算Func4的时间复杂度？

  • 这里可以看到k循环了100次，那么他是O(100)吗？【不是！】是O(1)

注意： O(1)并不是代表一次，而是常数次！

void Func4(int N)
{
	int count = 0;
	for (int k = 0; k < 100; ++k)
	{
		++count;
	}
	printf("%d\n", count);
}

小结一下：

  • 大O阶的方法：
    • 用常数1取代运行时间中的所有加法常数
    • 在修改后的运行次数函数中，只保留最高阶项，取决定性的那一项
    • 如果最高阶项存在且系数是不唯1的常系数，则去除最高项的系数，得到的结果就是大O阶
    • 如果最终结果是O(1)，则表示常数次，并不是代表一次
    • 还有就是没有小o阶~~

实例5：

计算strchr的时间复杂度？

const char* strchr(const char* str, int character);

while (*str) {
	if (*str == character)
		return str;
	++str;
}
  • 这个函数有可能有的同学没有见过，这是C语言库里面的一个函数strchr，是定位字符串中出现的第一个字符
  • 可能在前面的位置找到了（最好），肯在中间的位置找到了（平均），还有肯在最后的位置找到了（最坏）
    在这里插入图片描述

小结一下：

  • 最坏情况：

    • 任意输入规模的最大运行次数（上界）

  • 平均情况：

    • 任意输入规模的期望运行次数

  • 最好情况：

    • 任意输入规模的最小运行次数（下界）
    • 一般我们比较关心的是一个算法的最坏情况

  • 如果有最好，最坏，平均，那么时间复杂度是一个保守的估算，是取最坏，这是最好的！！！

实例6：

计算BubbleSort的时间复杂度？

  • 很多同学一眼看他是O(N^2)，那么他是O(N^2)吗？接下来接着看
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(N^2),它是O(N^2)吗？–>继续接着往下看！
int PartSort1(int* a, int left, int right) {
	int keyi = left;
	while (left < right) {
		while (left < right && a[right] >= a[keyi]) {
			--right;
		}
		while (left < right && a[left <= a[keyi]]) {
			++left;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[right]);
}

我们上面都是看的循环，但是我们要看思想，不能只看循环，第一个是–>O(N^2)第二个是O(N)

你算对了吗？

  • 首先我们先看第一个冒泡排序的时间复杂度，如图：

在这里插入图片描述

  • 再来看第二个 PartSort1，当left和right相遇时，时间复杂度是O(N)

在这里插入图片描述
小结一下：

  • 时间复杂度不能数代码中的循环
  • 而是需要根据思想进行灵活计算！！！

实例7：
计算BinarySearch的时间复杂度？

  • 这里一眼看就是一个二分查找~~
  • 我们这里的是不是复杂度数O(N)?
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;
}
  • 首先先说结论，这里是O(logN)，我们这里看代码是看不出来的，要看思想~~
  • 首先二分查找的前提是有序

在这里插入图片描述

  • 这个数组假设有n个值

  • n/2/2/…/2 = 1（最坏的情况~~）

  • 我们这里除了多少个2？找了多少次就除了多少个2

  • 假设找了x次–>2^x = N --> x = logN
    在这里插入图片描述

我们这里的这个以2为底的logN是不是很不好写…我们平时就可以不写了~~，直接写成O(logN)
但是有的书或者博客上面写成O(lgN)，我们不建议~~，和我们数学里面是有些混淆的

学了复杂度我们要指定O(logN)是一个很腻害的算法我们下面进行对照~~

  • 这里对应的有暴力查找（数组过一遍查找）：O(N)
  • 二分查找：O(logN)

比如：
在这里插入图片描述

  • 如果我把中国所有人的信息放到一个数组中，我们要找多少次？

我们就只需要找31次，是不是很厉害~~

  • 我们这里前提是要有序，有序是要有代价的，需要排序，如果有一个新生儿出生了，就要插入，如果有人离世了，就要删除了，这就很难~~
  • 这里有更好的数据结构，有：AVL树，红黑树，哈希表，这些我们后面都会讲解~~

实例8：

计算阶乘递归Fac的时间复杂度？

  • 首先来看这是一个阶乘，很多同学肯一看是O(1)，又不太敢确认
  • 我们先说结论—>O(N)
long long Fac(size_t N)
{
	if (0 == N)
		return 1;

	return Fac(N - 1) * N;
}

在这里插入图片描述

  • 阶乘是不是有多次函数的调用，每次调用是常数次O(N)，有N次调用就是O(N)~~

我们再来变一下形~~，我们来看下面，这个的时间复杂度是多少呢？

  • 我们先说结果–>O(N^2)，然后我们进行分析~~
long long Fac(size_t N)
{
	if (0 == N)
		return 1;
	for (size_t i = 0; i < N; ++i)
	{
		//....
	}
	return Fac(N - 1) * N;
}
  • 这里是咋算的？
  • 每次递归走了一次循环，递归计算的是多次调用累加，多少次调用？N次调用，每次调用多少趟？这不是N，每次都在变化，当N为10时，循环走10次，当N是9时，循环走9次
  • 递归次数累加是一个等差数列 （0~N）的等差数列
  • 所以就是O(N^2)~~

实例9：

计算斐波那契递归Fib的时间复杂度？

  • 斐波那契数列类似于细胞分裂，一个分裂成两个，两个分裂成4个…
long long Fib(size_t N)
{
	if (N < 3)
		return 1;

	return Fib(N - 1) + Fib(N - 2);
}
  • 这里仔细看，这是一个等比数列和~~

在这里插入图片描述

  • 这里可以用到错位相减法，如图：

在这里插入图片描述

  • 根据大O渐进表示法，时间复杂度也就是O(2^N)，这是一个成指数增长的~~

5.空间复杂度

  • 空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时额外占用存储空间大小的量度。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
  • 空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。
  • 注意： 函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

案例1：

计算BubbleSort的空间复杂度？

  • 这里的这个空间复杂度是多少？—>>O(N)还是O(1)
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)

下面这种算法是经典的O(N)

案例2：

计算Fibonacci的空间复杂度？

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;
}
  • 这里我们malloc了·n+1·个空间
  • 其他的都忽略掉，所以就是O(N)

案例3：

计算阶乘递归Fac的空间复杂度？

long long Fac(size_t N)
{
	if (N == 0)
		return 1;
	return Fac(N - 1) * N;
}
  • 这里递归空间复杂度计算，也是空间累加，但是不同的是空间可以重复利用
  • 所以这里就是O(N)

6.复杂度的oj练习

6.1 消失的数字

OJ链接

  • 这里题目要求在时间复杂度上O(n)我们介绍三种方法，看看哪种方法适合这道题~~

在这里插入图片描述

方法一：

  1. 先冒泡排序
  2. 遍历，当前值+1，不等于下一个数

这个时间复杂度是O(N^2)

方法二：

  1. 将数组的每个元素异或0
  2. 遍历，再将异或出来的结果每个再异或

这个时间复杂度是O(N)

方法三：

  1. 0到n等差数列公式计算和((首项 + 尾项) * 项数)/2
  2. 依次减掉数据中的值，剩下的就是消失的数字

这个时间复杂度是O(N)

  • 可见只有方法二和方法三符合题目要求，下面我们就写一下这个代码

方法二的代码：

int missingNumber(int* nums, int numsSize){
    int N = numsSize;
    int sum = ((0+N)*(N+1))/2;
    for(int i= 0;i<numsSize;i++){
        sum-=nums[i];
    }
    return sum;
}

方法三的代码：

int missingNumber(int* nums, int numsSize){
    int x = 0;
    for(int i = 0;i<numsSize;i++){
        x^=nums[i];
    }
    for(int i = 0;i<=numsSize;i++){
        x^=i;
    }
    return x;
}

6.2 旋转数组

OJ链接

在这里插入图片描述

  • 我们这个题肯有些同学在C语言的时候做过

我们先来看思路一：

在这里插入图片描述

  • 思路一的时间复杂度是多少？
    • 可能有的同学算出来的是O(N*K)，不完全正确~~
  • 最好的情况：k % N = 0，k = 7，旋转0次！！！是O(1)。k是N的倍数时，不需要旋转~~
  • 最坏的情况：k % N = N - 1时，比如13次旋转的最多，20次最多…
  • 所以这个题的真正复杂度是O（N*(N-1)）—>O(N^2)

那么我们要求时间复杂度是O(N)，那么我们怎么优化呢？

我们这里就要看思路二：

在这里插入图片描述

  • 这里很明显是O(N)

代码如下：

void reverse(int* nums,int left,int right){
    while(left<right){
        int tmp = nums[left];
        nums[left] = nums[right];
        nums[right] = tmp;
        left++;
        right--;
    }
}
void rotate(int* nums, int numsSize, int k){
    if(k>numsSize){
        k %=numsSize;
    }
    reverse(nums,0,numsSize-1);
    reverse(nums,0,k-1);
    reverse(nums,k,numsSize-1);
}
  • 注意这里k一定要%numsSize，否则会报错~~

思路三：

空间换时间

在这里插入图片描述

  • 这里的时间复杂是O(N)，空间复杂度是O(N)

代码如下：

void rotate(int* nums, int numsSize, int k) {
	k %= numsSize;
	int tmp[numsSize];
	int j = k;
	//拷贝前n-k个
	for (int i = 0; i < numsSize - k; i++) {
		tmp[j++] = nums[i];
	}
	//拷贝后k个
	j = 0;
	for (int i = numsSize - k; i < numsSize; i++) {
		tmp[j++] = nums[i];
	}
	//拷贝回原数组
	for (int i = 0; i < numsSize; i++) {
		nums[i] = tmp[i];
	}
}

好了，数据结构的算法的时间复杂度和空间复杂度到这里就结束了~~
如果有什么问题可以私信我或者评论里交流~~
感谢大家的收看，希望我的文章可以帮助到正在阅读的你🌹🌹🌹

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

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

相关文章

C++前缀和算法的应用：预算内的最多机器人数目

C++前缀和算法的应用：预算内的最多机器人数目

本文涉及的基础知识点 C算法&#xff1a;前缀和、前缀乘积、前缀异或的原理、源码及测试用例 包括课程视频 单调双向队列 滑动窗口 题目 你有 n 个机器人&#xff0c;给你两个下标从 0 开始的整数数组 chargeTimes 和 runningCosts &#xff0c;两者长度都为 n 。第 i 个机器…
阅读更多...
Maven - no main manifest attribute（SpringBoot 多模块）

Maven - no main manifest attribute（SpringBoot 多模块）

问题描述 no main manifest attribute 解决方案 一个主项目下&#xff0c;多个业务模块&#xff0c;假设 starter 模块作为启动器&#xff0c;以及主项目&#xff08;project&#xff09;最外层父 pom.xml 最关键要关注这 2 个 pom.xml&#xff08;starter - pom.xml & p…
阅读更多...
python画气泡标尺图

python画气泡标尺图

目录 渐变气泡图彩色气泡图 在进行实验结果分析的时候&#xff0c;气泡标尺图能非常清晰对不同的结果进行多维度的比较&#xff0c;特别是在深度学习模型大小和精度进行比较的时候非常合适使用&#xff0c;以下是几个例子。 渐变气泡图 import seaborn as sns import matplotl…
阅读更多...
正点原子嵌入式linux驱动开发——Linux 串口RS232/485/GPS 驱动

正点原子嵌入式linux驱动开发——Linux 串口RS232/485/GPS 驱动

串口是很常用的一个外设&#xff0c;在Linux下通常通过串口和其他设备或传感器进行通信&#xff0c;根据 电平的不同&#xff0c;串口分为TTL和RS232。不管是什么样的接口电平&#xff0c;其驱动程序都是一样的&#xff0c;通过外接RS485这样的芯片就可以将串口转换为RS485信号…
阅读更多...
RZMO-A-030/210、HZMO-A-030/315电控比例压力阀控制器

RZMO-A-030/210、HZMO-A-030/315电控比例压力阀控制器

RZMO-A-030/50、RZMO-A-030/210、RZMO-A-030/350、RZMO-A-030/100、RZMO-A-030/315、HZMO-A-030/50、HZMO-A-030/210、HZMO-A-030/350、HZMO-A-030/100、HZMO-A-030/315滑阀型先导式数字型比例溢流阀&#xff0c;用于压力开环控制&#xff0c;可提供板式或叠加式安装。A型&…
阅读更多...
web - 前段三剑客

web - 前段三剑客

目录 前言 一. HTML 常用标签演示 图片标签 ​编辑 表格标签(重点) ​编辑 表单标签 (重点) 布局标签 其余标签 二. CSS 2.1 . css的三种引入方式 2.2 . 三大选择器 2.3 . css样式 - 浮动 2.4 . css样式 - 定位 1.static 2.absolute(绝对位置) 3.relavite(相…
阅读更多...
Binder机制总结笔记

Binder机制总结笔记

Binder机制总结笔记 什么是Binder&#xff1f; Binder的Android特有的IPC通信机制。Android的四大组件Activity、Service、Broadcast、ContentProvider&#xff0c;不同的App等都运行在不同的进程内&#xff0c;他们之间的通信都需要依靠Binder完成。因此Binder在整个Android系…
阅读更多...
好用的ps滤镜插件Portraiture2024

好用的ps滤镜插件Portraiture2024

Photoshop 是最常用到的综合性的设计工具&#xff0c;虽然PS一直在迭代升级&#xff0c;但是在细节功能上&#xff0c;PS总是无法完全满足全部所有的用户需求&#xff0c;今天coco玛奇朵推荐一个个截至目前最受欢迎的免费的PS插件&#xff0c;有了这些功能扩展的插件后PS如虎添…
阅读更多...
OpenCV C++ 图像处理实战 ——《缺陷检测》

OpenCV C++ 图像处理实战 ——《缺陷检测》

OpenCV C++ 图像处理实战 ——《缺陷检测》 一、结果演示二、缺陷检测算法2.1、多元模板图像2.2、训练差异模型三、图像配准3.1 功能源码3.1 功能效果四、多元模板图像4.1 功能源码五、缺陷检测5.1 功能源码六、源码测试图像下载总结一、结果演示
阅读更多...
拓世大模型 | 立足行业所需，发力终端，缔造智能无限可能

拓世大模型 | 立足行业所需，发力终端，缔造智能无限可能

蒸汽机的发明为人类工业革命揭开序幕&#xff0c;引领了近现代产业变革。众所周知&#xff0c;而今AI技术的革命性突破&#xff0c;站在了时代舞台的中心&#xff0c;特别是大模型的崛起&#xff0c;无疑是第四次产业革命的焦点&#xff0c;它的地位可与当年的“蒸汽机”相提并…
阅读更多...
AndroidSDK下载及安装（Windows）

AndroidSDK下载及安装（Windows）

下载地址&#xff1a;https://www.androiddevtools.cn/ 找到SDK工具并下载安装 都是傻瓜式一键安装 除了注意安装路径应避免选择中文或特殊字符路径&#xff0c;应该没什么大问题。 下载安装Android SDK Android SDK Tools安装后&#xff0c;启动SDK Manager.exe&#xff1a;…
阅读更多...
综合OA管理系统源码 OA系统源码

综合OA管理系统源码 OA系统源码

综合OA管理系统源码 OA系统源码 功能介绍&#xff1a; 编号&#xff1a;LQ10 一&#xff1a;系统管理 系统配置&#xff0c;功能模块&#xff0c;功能节点&#xff0c;权限角色&#xff0c;操作日志&#xff0c;备份数据&#xff0c;还原数据 二&#xff1a;基础数据 审批…
阅读更多...
Linux-组管理和权限管理

Linux-组管理和权限管理

一、组管理—基本介绍 在linux中的每个用户必须属于一个组&#xff0c;不能独立于组外。在linux中每个文件有所有者、所在组、其它组的概念。 1)所有者 2)所在组 3)其它组 4)改变用户所在的组 二、组管理—文件/目录所有者 1、查看文件或者目录的所有者和所在组的指令 所有…
阅读更多...
文件加密，数据防泄密软件

文件加密，数据防泄密软件

文件加密和数据防泄密软件成为了保护信息安全的重要工具&#xff0c;它们可以有效地防止敏感数据的泄露和非法访问。 发展历史 文件加密和数据防泄密软件的发展历程可以追溯到上世纪90年代&#xff0c;当时随着互联网的普及和信息技术的不断发展&#xff0c;人们开始意识到信息…
阅读更多...
考虑温度影响的vumat子程序在木材受火后强度分析中的应用

考虑温度影响的vumat子程序在木材受火后强度分析中的应用

木结构在火灾作用下&#xff0c;木材的化学成分及物理特性会发生复杂的变化&#xff0c;导致其力学性能的改变&#xff0c;木构件承载能力降低。本文编写了考虑温度影响的木材本构vumat子程序&#xff0c;并对子程序的正确性进行了验证。 木材是一种复杂的各向异性复合材料&am…
阅读更多...
JavaScript综合案例五

JavaScript综合案例五

目录 一、实战案例&#xff1a;轮播图案例-完整版 代码实现 二、实战案例&#xff1a;tab栏切换 1.普通版本 代码实现 2.事件委托版本 代码实现 三、实战案例&#xff1a;表单全选反选 代码实现 四、实战案例&#xff1a;哔哩哔哩导航滑动 代码实现 五、实战案例&am…
阅读更多...
win10安装Tensorflow(2.10-)使用最新cuda(12+),cudnn(8.9+)

win10安装Tensorflow(2.10-)使用最新cuda(12+),cudnn(8.9+)

# tensorflow在2.11版本后不再支持原生windows的GPU&#xff1a; https://blog.tensorflow.org/2022/09/whats-new-in-tensorflow-210.html# 1、首先&#xff0c;在windows安装好最新的GPU环境&#xff1a; https://blog.csdn.net/sinat_20174131/article/details/121781420?s…
阅读更多...
可以实时监控屏幕的电脑监控软件

可以实时监控屏幕的电脑监控软件

电脑已经成为了人们工作和生活不可或缺的工具。然而&#xff0c;这也带来了诸多安全问题。一些人可能会利用电脑进行不恰当的操作&#xff0c;如聊天、游戏、观看视频等&#xff0c;甚至会泄露公司的商业机密。 电脑监控软件的定义 电脑监控软件是一种用于监控电脑使用情况的软…
阅读更多...
2.22每日一题（含绝对值的定积分+极值+凹凸区间+单调区间）

2.22每日一题（含绝对值的定积分+极值+凹凸区间+单调区间）

阅读更多...
【CSDN 每日一练 ★★☆】【数学】字符串相乘

【CSDN 每日一练 ★★☆】【数学】字符串相乘

###【CSDN Daily Practice】【数学】字符串相乘 数学 模拟 题目 给定两个以字符串形式表示的非负整数 num1 和 num2&#xff0c;返回 num1 和 num2 的乘积&#xff0c;它们的乘积也表示为字符串形式。 示例 示例 1: 输入: num1 “2”, num2 “3” 输出: “6” 示例 2: …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023