初阶数据结构—算法的时间复杂度和空间复杂度

【数据结构和算法】时间复杂度和空间复杂度 一、前言 数据结构和算法是程序的灵魂,这是某位程序员大佬所言,学习了这门,我们便可以在 编程之路越走越远。时间复杂度一般是我们所关心的。 二、时间复杂度 时间复杂度简单的说就是一个程序运行所消耗的时间,叫做时间复杂度,我们无法目测 一个程序具体的时间复杂度,但是我们可以估计大概的时间复杂度。 一段好的代码的就根据算法的时间复杂度,即使在大量数据下也能保持高效的运行速率,这也是 我们学习算法的必要性。 2.1时间复杂度表示形式 一般用O()来表示算法的时间复杂度,我们叫做大O记法。 阅读详情

第一章:数据结构前言(Lesson 1)

1. 什么是数据结构?

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

2. 什么是算法?

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

第一章:算法的时间复杂度和空间复杂度(Lesson 2)

1. 算法效率

1.1 如何衡量一个算法的好坏
long long Fib(int N)
{
	if (N < 3)
		return 1;

	return Fib(N - 1) + Fib(N - 2);
}

斐波那契数列的递归实现方式非常简洁,但简洁一定好吗?那该如何衡量其好与坏呢?

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

第二章:时间复杂度

2.1 时间复杂度概念

时间复杂度的定义:在计算机科学中, 算法的时间复杂度是一个函数 ,它定量描述了该算法的运行时间。一个算法执行所耗费的时间,从理论上说,是不能算出来的,只有你把你的程序放在机器上跑起来,才能知道。但是我们需要每个算法都上机测试吗?是可以都上机测试,但是这很麻烦,所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例,算法中的基本操作的执行次数,为算法 的时间复杂度。
即:找到某条基本语句与问题规模 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;

前面两个for循环的时间复杂度是N*N,第三个for循环的时间复杂度是2N,最后一个while循环的时间复杂度是10。最终的时间复杂度函数式:F(N)=N*N + 2*N + 10

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

2.2 大O的渐进表示法

大O符号(Big O notation):是用于描述函数渐进行为的数学符号。
推导大O阶方法:

  1. 用常数1取代运行时间中的所有加法常数。F(N)=N*N + 2*N + 10
  2. 在修改后的运行次数函数中,只保留最高阶项。N^2
  3. 如果最高阶项存在且不是1,则去除与这个项目相乘的常数。得到的结果就是大O阶。O(N^2)
 F(N) = N*N + 2*N + 10
N = 10F(N) = 130
N = 100F(N) = 10210
N = 1000F(N) = 1002010
O(N^2)
N = 10F(N) = 100
N = 100F(N) = 10000
N = 1000F(N) = 1000000

通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项,简洁明了的表示出了执行次数。当N越大,后面项对结果的影响就越小
另外有些算法的时间复杂度存在最好、平均和最坏情况:
最坏情况:任意输入规模的最大运行次数(上界)
平均情况:任意输入规模的期望运行次数
最好情况:任意输入规模的最小运行次数(下界)

例如:在一个长度为N数组中搜索一个数据x
最好情况:1次找到
最坏情况:N次找到
平均情况:N/2次找到
在实际中一般情况关注的是算法的最坏运行情况,所以数组中搜索数据时间复杂度为O(N)

2.3 常见时间复杂度计算举例 

实例1:
// 计算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);
}
//时间复杂度函数式:F(N) = 2*N + 10;时间复杂度:O(N)

在分析算法的时间复杂度时,通常关注的是算法的增长趋势,而不是具体的常数因子。因此,当时间复杂度中出现类似2N和10N这样的情况时,它们都会被认为是线性增长的,即O(N)。

在大规模问题上,常数因子不再影响算法的增长趋势。例如,假设一个算法的时间复杂度是2N,而另一个是10N,如果输入规模为100时,第一个算法的执行时间是200个单位时间,而第二个算法的执行时间是1000个单位时间。尽管第二个算法的执行时间更长,但它们的增长率是一样的,都是线性增长。

因此,当我们分析算法的时间复杂度时,会将常数因子视为可以忽略的因素,只关注随着输入规模增长时,算法执行时间的增长趋势,而这种增长趋势决定了算法的时间复杂度。

实例2:
// 计算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);
}
//时间复杂度函数式:F(N) = M + N;时间复杂度:O(M+N)
//M和N相互独立,某一项的增加和减少都会导致时间复杂度变化,所以不能省略其中一个

实例3:
// 计算Func4的时间复杂度?
void Func4(int N)
{
	int count = 0;
	for (int k = 0; k < 100; ++k)
	{
		++count;
	}
	printf("%d\n", count);
}
//时间复杂度函数式:F(N) = 100;时间复杂度:O(1) - 代表常数次
//常数时间复杂度表示算法的执行时间与输入规模无关,
//因此不管执行一次还是一亿次,都可以认为是常数次

实例4:
// 计算strchr的时间复杂度?
const char * strchr ( const char * str, int character );

//实现
while (*str)
{
	if (*str == character)
		return str;
	else
		++str;
}
//该算法时间复杂度O(N)

在该长度为N数组中搜索一个数据x
最好情况:1次找到
最坏情况:N次找到
平均情况:N/2次找到
在实际中一般情况关注的是算法的最坏运行情况,所以数组中搜索数据时间复杂度为O(N)

实例5:
// 计算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;
	}
}
//时间复杂度函数式:F(N) = N*(N-1) / 2;时间复杂度:O(N^2)
//第一轮:n - 1次
//第二轮:n - 2次
//第三轮:n - 3次
//......
//倒数第二轮:2次
//倒数第一轮:1次
//总共n-1轮
//全部加起来就是等差数列。首项1,尾项n-1,项数(n-1轮)

实例6:
// 计算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;
}
//时间复杂度函数式:F(N) = log_2 N;时间复杂度:O(logN)
//每查找一次少一半,所以每次除以2。N/2/2/2.../2 = 1
//反过来就是每次*2,(假设查找了x次),2^x = N
//查找次数和输入规模的关系就是log_2 N = x(2为底)

实例7:
// 计算阶乘递归Fac的时间复杂度?
long long Fac(size_t N)
{
	if (0 == N)
		return 1;

	return Fac(N - 1) * N;
}
//时间复杂度函数式:F(N) = N + 1;时间复杂度:O(N)
//调用如下,每次函数调用内部固定执行if判断和递减操作,可视为O(1)            
//Fac(N)
//Fac(N-1)
//Fac(N-2)
//.......
//Fac(2)
//Fac(1)
//Fac(0)

实例8:
// 计算斐波那契递归Fib的时间复杂度?
long long Fib(size_t N)
{
	if (N < 3)
		return 1;

	return Fib(N - 1) + Fib(N - 2);
}
时间复杂度:O(2^N)

//调用如下
//2^0	  Fib(N)
//2^1     Fib(N-1) Fib(N-2)
//2^2     Fib(N-2) Fib(N-3)  Fib(N-3) Fib(N-4)
//..........
//2^(n-4) Fib(4)
//2^(n-3) Fib(3)
//2^(n-2) Fib(2)
//每一层都是上一层的2倍,就是一个等比为2的等比数列
//通过下方错位相减法可得结果
//FN(n)= 2^0+2^1+2^2+......+2^(n-4)+2^(n-3)+2^(n-2)           1式
//2FN(n)=    2^1+2^2+......+2^(n-4)+2^(n-3)+2^(n-2) +2^(n-1)  2式
//两边乘以公比2,再用2式减1式
//FN(n)= 2^(n-1) - 1

第三章:空间复杂度

空间复杂度也是一个数学表达式,是对一个算法在运行过程中临时占用额外存储空间大小的量度。

空间复杂度不是程序占用了多少bytes的空间,因为这个也没太大意义,所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似,也使用大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 的增加而增加
//空间复杂度为 O(1)

实例2:

// 计算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;
}
//额外开辟了1个数组,元素个数为n+1
////空间复杂度为 O(N)

实例3:

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

	return Fac(N - 1) * N;
}
//递归调用了N次,开辟了N个栈帧,每个栈帧使用了常数个空间。
//空间复杂度为O(N)

实例4:

// 计算斐波那契递归Fib的空间复杂度?
long long Fib(size_t N)
{
	if (N < 3)
		return 1;

	return Fib(N - 1) + Fib(N - 2);
}
//空间复杂度为O(N)

调用顺序为红色箭头→蓝色箭头→绿色箭头。总共开辟0~n-2层,即n-1层栈帧。每一层的栈帧是共用的。例如调用Fib(2)创建栈帧,返回后,栈帧销毁;再调用Fib(1),再创建栈帧,返回,销毁。

时间是累积计算的,空间可以重复利用。所以空间复杂度为O(N)。

(下图证明栈帧可以共用)

作业:

1. 消失的数字

面试题 17.04. 消失的数字 - 力扣(LeetCode)

数组nums包含从0到n的所有整数,但其中缺了一个。请编写代码找出那个缺失的整数。你有办法在O(n)时间内完成吗?
示例 1:
输入:[3, 0, 1]
输出:2

示例 2:
输入:[9, 6, 4, 2, 3, 5, 7, 0, 1]
输出:8

//方法一:异或
int missingNumber(int* nums, int numsSize) {
    int i = 0;
    int ret = 0;//0异或任何数还是任何数
    for (i = 0; i < numsSize; i++)//将nums数组所有元素异或
        ret ^= nums[i];

    for (i = 0; i < numsSize + 1; i++)//因为nums数组少了个1个元素,在异或完整数组
        ret ^= i;

    //相当于用完整数组和少1个元素的数组(nums数组)所有元素异或,最后相同的为0,
    //剩下的就是少了的那个元素
    return ret;
}

//方法二:两数组相减
int missingNumber(int* nums, int numsSize) {
    // 计算从 0 到 n 的所有整数之和
    int total = numsSize * (numsSize + 1) / 2;
    // 计算 nums 中所有元素的和
    int sum = 0;
    for (int i = 0; i < numsSize; i++)
        sum += nums[i];
    // 返回缺失的整数
    return total - sum;
}

//方法三:排序后再比较
//排序,依次查找。如果下一个数不是上一个数+1,那么上一个数+1就是消失的数字
int missingNumber(int* nums, int numsSize) {
    // 如果数组只有一个数,返回缺失的整数
    if (numsSize == 1) 
        return (nums[0] == 0) ? 1 : 0;
    //当数组只包含一个元素时,我们需要确定缺失的整数是0还是1。
    //因为对于一个只包含一个元素的数组而言,如果这个元素是0,则缺失的整数可能是1;
    //如果这个元素不是0,则缺失的整数可能是0。

    // 如果数组中没有0,则0为缺失的整数
    if (nums[0] != 0) 
        return 0;

    // 遍历数组,检查是否存在断号
    for (int i = 1; i < numsSize; ++i) 
        if (nums[i] != nums[i - 1] + 1) 
            // 如果下一个数不是上一个数+1,那么上一个数+1就是缺失的整数
            return nums[i - 1] + 1;
        
    // 如果数组中没有缺失的整数,则返回数组最后一个数加一
    return nums[numsSize - 1] + 1;
}

2. 轮转数组

轮转数组

给定一个整数数组 nums,将数组中的元素向右轮转 k 个位置,其中 k 是非负数。
示例 1:
输入: nums = [1, 2, 3, 4, 5, 6, 7], k = 3
输出 : [5, 6, 7, 1, 2, 3, 4]
解释 :
    向右轮转 1 步 : [7, 1, 2, 3, 4, 5, 6]
    向右轮转 2 步 : [6, 7, 1, 2, 3, 4, 5]
    向右轮转 3 步 : [5, 6, 7, 1, 2, 3, 4]
示例 2 :
    输入:nums = [-1, -100, 3, 99], k = 2
    输出:[3, 99, -1, -100]
    解释 :
    向右轮转 1 步 : [99, -1, -100, 3]
    向右轮转 2 步 : [3, 99, -1, -100]
 

//方法一:3段逆序
//反转整个数组。
//反转前 k 个元素。
//反转剩下的 n - k 个元素

//反转前 n - k 个元素。
//反转后 k 个元素
//反转整个数组。
void reverse(int* left, int* right) {
	while (left < right) {
		int tmp = *left;
		*left = *right;
		*right = tmp;
		left++;
		right--;
	}
}

void rotate(int* nums, int numsSize, int k) {
	k %= numsSize;
	reverse(nums, nums + numsSize - k - 1); // 逆序前n-k个数字 4 3 2 1 5 6 7
	reverse(nums + numsSize - k, nums + numsSize - 1); // 逆序后k个数字 4 3 2 1 7 6 5
	reverse(nums, nums + numsSize - 1); // 逆序整个数组 5 6 7 1 2 3 4
}

//与上方逆序顺序不同
void rotate(int* nums, int numsSize, int k) {
	k %= numsSize;
	reverse(nums, nums + numsSize - 1);//逆序整个数组 7 6 5 4 3 2 1
	reverse(nums, nums + k - 1);//逆序前k个元素 5 6 7 4 3 2 1
	reverse(nums + k, nums + numsSize - 1);//逆序后n-k个元素 5 6 7 1 2 3 4
}
//时间复杂度:前n-k+后k个是n,逆序整个数组是n,加起来是2n,所以O(n)
//空间复杂度:O(1)



//方法二:拷贝
void rotate(int* nums, int numsSize, int k) {
    int* tmp = (int*)malloc(numsSize * sizeof(int));
    k %= numsSize;
    memcpy(tmp + k, nums, (numsSize - k) * sizeof(int));
    memcpy(tmp, nums + (numsSize - k), k * sizeof(int));
    memcpy(nums, tmp, numsSize * sizeof(int));
}

3. 两个单身狗数

撞色搭配

int* sockCollocation(int* sockets, int socketsSize, int* returnSize) {
    int ret = 0;
    for (int i = 0; i < socketsSize; i++)
        ret ^= sockets[i];


    // 找到 ret 中的某一位是1的位置。因为 ret 是两个唯一数的异或结果,
    //这意味着这两个数在这一位上是不同的:一个是0,一个是1。
    int pos = 0;
    for (pos = 0; pos < 32; pos++)
        if ((ret >> pos) & 1 == 1)
            break;


    int* result = (int*)malloc(sizeof(int) * 2);  
    int dog1 = 0;
    int dog2 = 0;
    // 根据第 pos 位的值,将数组中的数分为两组。
    //这样,两个唯一数会被分到不同的组,而其他成对出现的数也会被分到各自的组中。
    for (int i = 0; i < socketsSize; i++) {
        if ((sockets[i] >> pos) & 1 == 1)
            dog1 ^= sockets[i];
        else
            dog2 ^= sockets[i];
    }
    result[0] = dog1;
    result[1] = dog2;
    *returnSize = 2;  
    return result;   
}

4. 给定一个整数sum,从有N个有序元素的数组中寻找元素a,b,使得a+b的结果最接近sum,最快的平均时间复杂度是(   )

A. O(n)
B. O(n^2)
C. O(nlogn)
D. O(logn)

答案:A
此题目中,数组元素有序,所以a,b两个数可以分别从开始和结尾处开始搜,根据首尾元素的和是否大于sum,决定搜索的移动,整个数组被搜索一遍,就可以得到结果,所以最好时间复杂度为n

5. 下面算法的时间复杂度是(   )

int f(unsigned int n) {
	if (n == 0 || n == 1)
		return 1;
	else
		return n * f(n - 1);
}

A. O(n)
B. O(n^2)
C. O(nlogn)
D. O(logn)

答案:A
此函数会被递归调用n - 1次,每次操作都是一次,所以时间复杂度为n

6. 设某算法的递推公式是T(n)=T(n-1)+n,T(0)=1,则求该算法中第n项的时间复杂度为()

A. O(n)
B. O(n^2)
C. O(nlogn)
D. O(logn)

答案:B
T(n)
=T(n-1)+n
=T(n-2)+(n-1)+n
=T(n-3)+(n-2)+(n-1)+n
...
=T(0)+1+2+...+(n-2)+(n-1)+n
=1+1+2+...+(n-2)+(n-1)+n
这个求和式1+2+3+...+n,是等差数列的和,公式是n(n+1)/2。所以代入进去:
T(n) =1 + [n(n+1)/2] = (n² +n)/2 +1 = (n² +n +2)/2
这样的话,T(n)的表达式是一个二次函数,最高次项是n²,所以时间复杂度应该是O(n²),也就是选项B。

7. 分析以下函数的时间复杂度

void fun(int n) {
    int i = 1;
    while (i <= n)
        i = i * 2;
}

A. O(n)
B. O(n^2)
C. O(nlogn)
D. O(logn)

答案:D
此函数有一个循环,但是循环没有被执行n次,i每次都是2倍进行递增,所以循环只会被执行log2(n)次。

8. 分析以下程序的时间复杂度

for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
        a[i][j] = i * j;

A. O(n)
B. O(n^2)
C. O(nlogn)
D. O(logn)

答案:B
程序有两次循环,每个循环都有n次操作,所以时间复杂度为n^2

9. 下列有关大O表示法的说法错误的是

A.大O表示法只是对程序执行时间的一个估算
B.大O表示法只保留最高阶项
C.大O表示法会保留一个系数来更准确的表示复杂度
D.大O表示法一般表示的是算法最差的运行时间

答案:C
大O是一个渐进表示法,不会去表示精确的次数,cpu的运算速度很快,估计精确的没有意义。

10. 分析以下函数的空间复杂度(   )

int** fun(int n) {
    int** s = (int**)malloc(n * sizeof(int*));
    while (n--)
        s[n] = (int*)malloc(n * sizeof(int));
    return s;
}

A. O(n)
B. O(n^2)
C. O(1)
D. O(nlogn)

答案:B
此处开辟的是一个二维数组,数组有n行,每行分别有1,2,3,...n列,所以是n(n + 1)/2个元素空间,空间复杂度为n^2。(开辟了一个二维数组,每一行比上一行少一个元素)

11. 如果一个函数的内部中只定义了一个二维数组a[3][6],请问这个函数的空间复杂度为(   )

A. O(n)
B. O(n^2)
C. O(1)
D. O(m*n)

答案:C
函数内部数组的大小是固定的,不论函数运行多少次,所需空间都是固定大小的,因此空间复杂度为O(1)

Anthropic三件套重构AI工作流:Claude Code、Design与桌面宠物实战指南 AI协作已从单点工具迈入系统化工作流阶段。理解AI作为‘协作者’而非‘执行器’的本质,是提升工程效率的关键前提;其核心在于对任务调度、自适应推理与人机交互边界的重新定义。Claude Code的xhigh effort机制体现了分层推理的工程智慧,Claude Design以HTML为原生设计语言实现设计-代码一体化,而桌面宠物则将抽象的token消耗具象为可感知的硬件反馈。这些能力共同指向一个趋势:AI工作流正从prompt调参走向契约式委派、从界面割裂走向跨模态统一。本文结合Opus 4.7最新实践,解 阅读详情

相关推荐

国产射频直采收发器CX8242KA测试1

CX8242KA/CX8242KAN是一款集成了14比特,12 GSPSDAC和14比特,3GSPSADC的双通道,宽带、射频直采收发器芯片,该器件支持高达6GHz射频信号的直接采样输入和输出,集成了片内高性能采样钟模块,采样时钟Jitter

RFSOC的博客 9168

初阶数据结构之---导论,算法时间复杂度和空间复杂度(C语言)

在计算机科学中,算法的时间复杂度是一个函数,它定量描述了该算法的运行时间。一个算法执行所耗费的时间,从理论上说,是不能算出来的,只有你把你的程序放在机器上跑起来,才能知道。但是我们需要每个算法都上机测试吗?是可以都上机测试,但是这很麻烦,所以才有了时间复杂度这个分析方式。一个算法的用时随数据规模而增长的趋势,即时间复杂度//计算以下Fun1中++count执行了多少次?i < N;i++){j < N;t < 2 * N;++count;

2303_79329831的博客 1634

【SABRE 3D, SABRE 3DxT,LAM设备】2025年9月10日

前文:SABRE 3D系列机台简介本章节详细阐述了在维护期间锁定电气、机械、热力学及重力组件以及化学管线输入的锁定操作流程,旨在降低人员受伤风险。p42~p55。

weixin_46735260的博客 1619

【初阶数据结构与算法】新的旅程之时间复杂度和空间复杂度

数据结构(DataStructure)是计算机存储、组织数据的⽅式,指相互之间存在⼀种或多种特定关系的数据元素的集合没有⼀种单⼀的数据结构对所有⽤途都有⽤,都有各自的优缺点和应用领域,所以我们要学各式各样的数据结构,如:线性表、树、图、哈希等,然后就可以在不同场景下很好的使用和管理数据。

hdxbufcbjuhg的博客 2511

Fastwhisper + Pyannote 实现 ASR + 说话者识别

最近在研究ASR相关的业务,也是调研了不少模型,踩了不少坑,ASR这块,目前中文普通话效果最好的应该是阿里的modelscope上的中文模型了,英文的话,还是非whisper莫属了,而且whisper很变态,粤语效果也还不错,因此,如果实际业务中需要涉及到不同的语言,还是更推荐whisper多一点faster-whisper是使用CTranslate2对OpenAI的Whisper模型的重新实现,CTranslate2是一个用于Transformer模型的快速推理引擎。

qq_44193969的博客 1万+

从RTL到GDSII:DC综合里那些没人告诉你的时钟约束冷知识(附真实工程示例)

本文深入探讨数字IC设计中DC综合阶段的时钟约束冷知识,包括无毛刺时钟切换、寄存器分频时钟约束、虚拟时钟应用等关键技巧。通过真实工程示例,揭示常见约束误区及解决方案,帮助工程师提升时序收敛效率。特别针对input_delay和output_delay在多时钟域场景下的设置陷阱提供实用指南。

weixin_29306317的博客 431

乘初阶数据结构算法之舟,踏上探寻C++的旅途——时间复杂度和空间复杂度

元旦快乐

2401_88325505的博客 9394

混合动作空间在强化学习中的创新应用:PDQN与MPDQN算法解析

本文深入解析了强化学习中处理混合动作空间的PDQN与MPDQN算法。针对既有离散选择又有连续调节的复杂决策场景,PDQN通过参数化深度Q网络,巧妙结合DQN与DDPG进行交替优化;MPDQN则进一步改进,为每个离散动作提供专属参数评估以减少干扰。文章通过游戏、自动驾驶等实例阐述了其应用价值与面临的挑战。

efc123456的博客 865

初阶数据结构【 算法的时间复杂度和空间复杂度】

我们现在已经基本结束了对C语言基础的学习,了解了C语言的函数,结构体,动态内存管理等,但是我们自己独立面对一些编程题目的时候我们总是无法像一些大师一样给出适合的程序,略显乏力,这种情况有两种原因,一是自己没有大量的去刷题,而是没有深刻理解数据结构,所以从今天开始,小编开始更新初阶数据结构的相关内容,希望大家可以定时监督我;算法的时间复杂度和空间复杂度会贯穿我们学习数据结构的全程,所以可以慢慢理解,两个例题的思路几天后更新,希望大家同我一起思考,加油,你我同在路上;26考研必胜!

吴先生的博客 1079

Qt基础之十九:进程与QProcess

进程就是一个程序的执行实例,也就是正在运行的程序。对操作系统来说,进程就是一个担当分配系统资源CPU时间、内存的实体。在Qt 中,我们使用QProcess来表示一个进程。这个类可以允许我们的应用程序启动一个新的外部程序,并且与这个程序进行通讯。当外部程序开始启动时,QProcess的状态为Starting;外部程序已经启动时,QProcess的状态为Running,并发送started()信号;当外部层序退出了,QProcess的状态为NotRunning(初始状态),并发送finished()信号。

草上爬的博客 1万+

本地快速部署谷歌开放模型Gemma教程(基于Ollama)

谷歌最近发布了新一代开源AI模型Gemma,此次发布的 Gemma 相比自家的 Gemini 更加轻量级,模型权重也一并开源。不仅可以在笔记本电脑上运行,而且还免费可商用,支持中文。运行速度飞快。

特立独行的博客 6724

初阶数据结构(C语言实现)——2算法的时间复杂度和空间复杂度

时间复杂度的定义:在计算机科学中**,算法的时间复杂度是一个函数**,它定量描述了该算法的运行时间。一个算法执行所耗费的时间,从理论上说,是不能算出来的,只有你把你的程序放在机器上跑起来,才能知道。内存的申请就像是住酒店一样,你申请了一块空间相当于开了一间房,然后你使用完,就退房了,钥匙给酒店前台了(OS)。示例2分析:时间复杂度为 O(logN) (logN在算法分析中表示是底数为2,对数为N。空间复杂度不是程序占用了多少bytes的空间,因为这个也没太大意义,所以空间复杂度算的是变量的个数。

graceyun的博客 1440

通信算法之264: DJI O2 协议物理层逆向工程解析

对于 DroneID,标志之间的间隙由循环前缀 (CP) 填充:每个标志末尾的副本附加在相应标志的开头。有了关于确切标志开始的信息,可以使用 FFT 将标志转移到频域 - 来自时域的 1024 个样本导致频域中的 1024 个子载波。使用比特流的解扰和涡轮解码,并将生成的数据映射到如上的DroneID 结构,通过逆向工程在无人机的固件中找到了它。注意到一些无人机(Mavic 2 和更早的 OcuSync 无人机)不发送第一个标志(标志 1),这导致更短的帧持续时间为 576 µs。//产品型号数字代号。

leegang12的专栏 3952

【初阶数据结构与算法】第一篇:算法中的时间复杂度和空间复杂度

前言 一、 二、 总结

YQ20210216的博客 953

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

【C】初阶数据结构1 -- 时间复杂度与空间复杂度

算法也是分好坏的,用有的算法写出来的程序可能运行时间只需要4毫秒,而有的算法写出来的程序可能就会需要8秒甚至9秒,如,堆排序和冒泡排序(以后会讲解),都是100000个数据进行排序,但是堆排序只需要4毫秒,而冒泡排序却需要8秒,所以衡量一个算法的好坏就显得尤为重要,那么该用什么来衡量算法的好坏或者执行效率呢?这里就不得不提到这篇文章的重点,复杂度了。

L_0907的博客 1177

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

初阶数据结构:时间复杂度和空间复杂度

用不同方式达到同一目的,每个方式达到目的所用的时间和空间是不同的。在程序上,使用不同算法来获取结果所需的时间和空间也是不同的。时间复杂度和空间复杂度主要功能就是判断算法的好坏,也可以说算法效率的高低。时间复杂度主要用于衡量一个算法的运行快慢,空间复杂度主要用于衡量一个算法运行所需要的额外空间。

2401_86688820的博客 1330

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

小白也爱看的初阶数据结构1

好了,从今天开始我们就正式进入到了初阶数据结构的范畴,在此之前我还是先跟大家说一下前言,了解一下数据结构。大家在学习的时候才能更加有动力和激情。

chenyuhao2024的博客 900

第一章 时间复杂度和空间复杂度

本系列文章,将基于C语言实现一些初阶的数据结构,目的是帮助大家熟悉C语言的同时能够入门数据结构。

Turing_Sheep的博客 2667

初阶数据结构--复杂度

此题仍然因为排序存在多种情况,所以需要分情况讨论写出不同情况的时间复杂度。

Tanecious的博客 964

破解骇客的时空罗盘——【初阶数据结构与算法】时间与空间复杂度

本文介绍了数据结构与算法的基本概念及其重要性。数据结构是计算机存储和组织数据的方式,直接影响程序效率和性能。学习数据结构需掌握基础理论、动手实践并解决实际问题。算法则是定义良好的计算过程,将输入转化为输出结果。文章强调算法对求职和提升编程能力的价值,推荐LeetCode等刷题平台。重点讲解了时间复杂度及其大O表示法的推导规则,列举了O(1)、O(logn)、O(n)、O(nlogn)和O(n²)等常见复杂度等级。通过实际代码示例说明不同时间复杂度的特点,帮助读者理解算法效率分析的基本方法。

枫亭湖区的博客 2164

【初阶数据结构】深度解析七大常见排序|掌握底层逻辑与原理

本篇将介绍七大常见排序底层逻辑,有助于我们更好地理解不同排序的适用场景和效率上的差别。

专注于 C/C++ 后端开发,涵盖基础语法、Linux系统与网络、MySQL数据库、常见算法及项目经验。 6181

【初阶数据结构】时空罗盘妙解:时间复杂度&&空间复杂度

本篇开启数据结构初阶的学习,数据结构的重要性已经不言而喻,无论是在面试还是工作的时候,都占据重要的地位,面对海量数据或复杂逻辑关系,巧妙运用数据结构可梳理问题脉络,找到简洁的解题思路📖

Zero_VPN的博客 3031

【初阶数据结构】算法效率大揭秘 | 时间与空间复杂度的深度剖析

本篇将介绍影响算法效率的两个因素时间复杂度与空间复杂度,随着计算机的发展,空间复杂度的问题得到解决,本篇主要讲述时间复杂度与大O渐进表示法。

专注于 C/C++ 后端开发,涵盖基础语法、Linux系统与网络、MySQL数据库、常见算法及项目经验。 3320

【初阶数据结构与算法 1】时间复杂度与空间复杂度(1)

前言 从本文开始进入了新阶段,学习初阶数据结构和算法,以纯C实现。 本文主要学习时间复杂度与空间复杂度,内容包括: - 算法效率 - 时间复杂度 - 空间复杂度 - 常见时间和空间复杂度的练习...

taibudong1991的博客 1875

初阶数据结构(2):空间复杂度和复杂度算法题

初阶数据结构知识

2401_84577633的博客 3209

【初阶数据结构】时间复杂度和空间复杂度(超有趣+超详细)

本文主要讲解了如何评价一个算法的标准:时间复杂度和空间复杂度。还分别讲解了它们各自的定义和算法,以及常用的大O的渐进表示法。干货满满!!!

tianxiawushanu的博客 2582
上一篇: C语言学习记录—进阶作业(通讯录文件版本)
下一篇: 初阶数据结构—顺序表和链表
Awkwardx
博客等级 码龄5年 341粉丝 82原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值