精华内容
下载资源
问答
  • 对算法效率进行评价
    2020-03-27 11:44:02

    算法效率评判标准

    时间复杂度
    空间复杂度

    空间复杂度

    算法执行过程中所需要的额外空间与问题规模n之间的函数关系
    malloc–>n
    递归–>n

    时间复杂度

    算法中最基本的操作执行的次数与问题规模n之间的关系
    运行算法所消耗的工作量与问题规模之间的函数关系,选
    择一个对于所研究问题的最基本的原操作,然后去计算该
    操作重复执行的次数(与问题规模相关)

    时间复杂度遵循的原则

    1、去掉常数
    2、去掉系数
    3、取最高项

    举例说明:

    O(1)
    void fun()
    {
      printf("hello world\n");
    }
    
    O(n)
    void fun(int n)
    {
     for(int i=0;i<n:++i)
         {
           ….
         }
    }
    
    O(n)
    void fun(int n)
    {
     for(int i=0;i<n:++i)
         {
           ….
         }
    for(int i=0;i<n:++i)
         {
           ….
         }
    }
    
    O(n)
    void fun(int n)
    {
     for(int i=0;i<n:i+=2)
         {
           ….
         }
    }
    
    O(n^2)
    void fun(int n)
    {
     for(int i=0;i<n:++i)
         { 
         for(int i=0;i<n:++i)
         {
           ….
         }
         }
    }
    
    O(log n)
    void fun(int n)
    {
     for(int i=0;i<n:i*=2)
         {
           ….
         }
    }
    
    更多相关内容
  • 算法效率评价

    千次阅读 2019-05-24 14:15:19
    1.算法效率评价标准 对于同样的编程问题,使用不同的算法最终的结果是一样的,但计算机计算过程是消耗的时间和空间却不一样,但是我们又不能去计算每个算法用的时间和空间,我们只能通过数学的方法来估算这个算法,...

    1.算法效率评价标准

    对于同样的编程问题,使用不同的算法最终的结果是一样的,但计算机计算过程是消耗的时间和空间却不一样,但是我们又不能去计算每个算法用的时间和空间,我们只能通过数学的方法来估算这个算法,这就是时间复杂度和空间复杂度产生的原由。
    时间复杂度和空间复杂度也是判断算法效率的重要指标;

    时间维度:是执行当前算法所消耗的时间,我们通常使用时间复杂度来描述.个人认为时间复杂度是[评估代码在cpu中的运行总行数]----T(n)=O(f(n))
    空间维度:是指执行当前需要占用多少=内存空间,我们通常用空间复杂度来描述.[评估代码在计算机内存中声明单元变量的总个数]-----S(n)=O(n)

    2.时间复杂度

    我们想要知道一个算法的「时间复杂度」,很多人首先想到的的方法就是把这个算法程序运行一遍,那么它所消耗的时间就自然而然知道了。
    这种方式可以吗?当然可以,不过它也有很多弊端。
    这种方式非常容易受运行环境的影响,在性能高的机器上跑出来的结果与在性能低的机器上跑的结果相差会很大。
    而且对测试时使用的数据规模也有很大关系。再者,并我们在写算法的时候,还没有办法完整的去运行呢。

    因此,另一种更为通用的方法就出来了:「 大O符号表示法 」,即 T(n) = O(f(n)) T(n) = O(f(n))
    其中f(n) 表示每行代码执行次数之和 而 O 表示正比例关系 这个公式的全称是:算法的渐进时间复杂度
    为什么可以这么去简化呢,因为大O符号表示法并不是用于来真实代表算法的执行时间的,它是用来表示代码执行时间的增长变化趋势的。
    所以上面的例子中,如果n无限大的时候,T(n) = time(1+2n)中的常量1就没有意义了,倍数2也意义不大。因此直接简化为T(n) = O(n) 就可以了。

    常见的时间复杂度量级有:
    常数阶O(1)
    对数阶O(logN)
    线性阶O(n)
    线性对数阶O(nlogN)
    平方阶O(n²)
    立方阶O(n³)
    K次方阶O(n^k)
    指数阶(2^n)

    3.空间复杂度

    既然时间复杂度不是用来计算程序具体耗时的,那么我也应该明白,空间复杂度也不是用来计算程序实际占用的空间的。
    空间复杂度是对一个算法在运行过程中临时占用存储空间大小的一个量度,同样反映的是一个趋势,我们用 S(n) 来定义。
    空间复杂度比较常用的有:O(1)、O(n)、O(n²),我们下面来看看:

    空间复杂度 O(1)

    {
    	int i = 1;
    	int j = 2;
    	++i;
    	j++;
    	int m = i + j;
    }
    代码中的 i、j、m 所分配的空间都不随着处理数据量变化,因此它的空间复杂度 S(n) = O(1)
    

    空间复杂度 O(n)

    {
    	int[] m = new int[n]
    	for(i=1; i<=n; ++i)
    	{
    	   j = i;
    	   j++;
    	}
    }
    	这段代码中,第一行new了一个数组出来,这个数据占用的大小为n,
    	这段代码的2-6行,虽然有循环,但没有再分配新的空间,
    	因此,这段代码的空间复杂度主要看第一行即可,即 S(n) = O(n)
    
    展开全文
  • 数据结构算法和算法效率评价

    千次阅读 2017-11-24 14:25:20
    一、算法的基本概念 算法(Algorithm):是针对特定问题的问题求解步骤的一种描述。它是指令的有限序列;算法具有如下五个重要特征: 1.1、有穷性:有穷步骤,有穷计算时间; 1.2、确定性:每一条指令必须有确切的...

    一、算法的基本概念
    算法(Algorithm):是针对特定问题的问题求解步骤的一种描述。它是指令的有限序列;算法具有如下五个重要特征:
    1.1、有穷性:有穷步骤,有穷计算时间;
    1.2、确定性:每一条指令必须有确切的含义。换句话说就是:对于相同的输入必须得出相同的输出结果。
    1.3、可行性:算法是可行的,算法中描述的操作都是可以通过已经实现的基本运算执行有限次得到。
    1.4、输入
    1.5、输出

    一个好的算法有如下几个评价标准:
    1.正确性
    2.可读性
    3.健壮性
    4.效率与低存储量的要求

    二、算法效率的度量
    2.1时间复杂度:一个语句的频度是指该语句在算法中被重复执行的次数。算法中所有的语句频度之和记作T(n),他是该算法问题规模n的函数,时间复杂度主要分析T(n)的数量级;算法中的基本运算(循环中的最深循坏内语句)的频度与T(n)同数量级。所以通常用算法中基本运算的频度f(n)来分析算法的时间复杂度。因此时间的复杂度记作:
    T(n) = O(f(n))
    以上的O表示为T(n)的数量级。其严格的数学含义为:若T( n)和f(n)是定义在正整数集合上的两个函数。则存在正整数C和 n0,使得n>=n0,都满足0<=T(n)<=C*f( n)
    另外算法的时间复杂度不仅仅只是依赖以问题规模n,同时也取决于输入参数的性质(比如:数据的初始值);例如以下例子:
    在数组中A[0……N-1],查找最大值K

    i = 1;
    while(i>=0&&A[i] !=K)
        i--;
    return i;

    在此算法,时间复杂度不仅与最内层循环(i–)的赋值次数有关,还有A数组中的各元素值和目标最大值K有关:
    1.若A中没有与K相等的数,则算法中的(i–)的频度为f(n);
    2.若A的最后一个元素的值与K相等。则(i–)的频数为f(n) = 0;

    以下是常见的几个复杂度概念:
    最坏时间复杂度:在最坏情况下的时间复杂度;
    平均时间复杂度:所有可能输入实例在等概率出现的情况下,算法的期望运行时间。
    最好时间复杂度:在最好的情况下,算法的时间复杂度。
    一般情况下总是先考虑最坏时间复杂度,以保证算法的时间 复杂度不会超过这个最大值。

    时间复杂度的两个基本规则:
    1.加法法则:
    T(n)=T1(n) + T2(n) = O(f(n)) + O(g(n)) = O(max(f(n),g(n)));

    2.乘法法则:
    T(n) = T1(n)T2(n) = O(f(n)) O(g(n)) = O(f(n)*g(n))

    3.常见的时间复杂度比较:
    O(1)< O(log2n)< O(n) < O(nlog(2n))< O(n^2)< O(n^3)< O(2^n)

    展开全文
  • 基于灰狼优化K-means聚类算法的公交地铁换乘效率评价方法.pdf
  • 大数据-算法-华北平原高产区农田土壤条件与水氮利用效率定量评价.pdf
  • 基于点对应的相机姿态估计算法缺少科学的性能评价方法,增加了工程应用中算法选择的难度。...借助仿真实验平台,9种经典相机姿态估计算法进行了性能评价。结果表明,RPnP+LHM算法的综合性能最优。
  • 目录1、算法效率2、时间复杂度2.1 时间复杂度的概念2.2 大O的渐进表示法2.3常见时间复杂度计算举例3、空间复杂度 1、算法效率 1.算法效率 算法效率分析分为两种:第一种是时间效率,第二种是空间效率。时间效率被...

    1、算法效率

    1.算法效率
    算法效率分析分为两种:第一种是时间效率,第二种是空间效率。时间效率被称为时间复杂度,而空间效率被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度,而空间复杂度主要衡量一个算法所需要的额外空间,在计算机发展的早期,计算机的存储容量很小。所以对空间复杂度很是在乎。
    但是经过计算机行业的迅速发展,计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

    2、时间复杂度

    2.1 时间复杂度的概念

    概念:算法中的基本操作的执行次数,为算法的时间复杂度。

    2.2 大O的渐进表示法

    请计算一下Func1基本操作执行了多少次?

    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);
    }
    
    F(N)=N²+2*N+10
    N = 10 F(N) = 130
    N = 100 F(N) = 10210
    N = 1000 F(N) = 1002010

    实际中我们计算时间复杂度时,我们其实并不一定要计算精确的执行次数,而只需要大概执行次数,那么这里我们使用大O的渐进表示法。
    大O符号(Big O notation):是用于描述函数渐进行为的数学符号。
    推导大O阶方法:

    1、用常数1取代运行时间中的所有加法常数。
    2、在修改后的运行次数函数中,只保留最高阶项。
    3、如果最高阶项存在且不是1,则去除与这个项目相乘的常数。得到的结果就是大O阶。

    使用大O的渐进表示法以后,Func1的时间复杂度为:

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

    通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项,简洁明了的表示出了执行次数。
    另外有些算法的时间复杂度存在最好、平均和最坏情况:
    最坏情况:任意输入规模的最大运行次数(上界)
    平均情况:任意输入规模的期望运行次数
    最好情况:任意输入规模的最小运行次数(下界)
    例如:在一个长度为N数组中搜索一个数据x
    最好情况:1次找到
    最坏情况:N次找到
    平均情况:N/2次找到
    在实际中一般情况关注的是算法的最坏运行情况,所以数组中搜索数据时间复杂度为O(N)

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

    分别计算下列函数的时间复杂度。
    实例1:

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

    实例2:

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

    实例3:

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

    实例4:

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

    实例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;
    }
    }
    

    实例6:

    // 计算BinarySearch的时间复杂度?
    int BinarySearch(int* a, int n, int x)
    {
    assert(a);
    int begin = 0;
    int end = n;
    while (begin < end)
    {
     int mid = begin + ((end-begin)>>1);
     if (a[mid] < x)
     begin = mid+1;
     else if (a[mid] > x)
     end = mid;
     else
     return mid;
    }
    return -1;
    }
    

    实例7:

    // 计算阶乘递归Factorial的时间复杂度?
    long long Factorial(size_t N)
    {
    return N < 2 ? N : Factorial(N-1)*N;
    }
    

    实例8:

    // 计算斐波那契递归Fibonacci的时间复杂度?
    long long Fibonacci(size_t N)
    {
    return N < 2 ? N : Fibonacci(N-1)+Fibonacci(N-2);
    }
    

    实例答案及分析:

    1. 实例1基本操作执行了2N+10次,通过推导大O阶方法知道,时间复杂度为 O(N)
    2. 实例2基本操作执行了M+N次,有两个未知数M和N,时间复杂度O(N+M)
    3. 实例3基本操作执行了10次,通过推导大O阶方法,时间复杂度为 O(1)
    4. 实例4基本操作执行最好1次,最坏N次,时间复杂度一般看最坏,时间复杂度为 O(N)
    5. 实例5基本操作执行最好N次,最坏执行了(N*(N+1)/2次,通过推导大O阶方法+时间复杂度一般看最坏,时间复杂度为 O(N^2)
    6. 实例6基本操作执行最好1次,最坏O(logN)次,时间复杂度为 O(logN) ps:logN在算法分析中表示是底数为2,对数为N。有些地方会写成lgN。(建议通过折纸查找的方式讲解logN是怎么计算出来的)
    7. 实例7通过计算分析发现基本操作递归了N次,时间复杂度为O(N)。
    8. 实例8通过计算分析发现基本操作递归了2N次,时间复杂度为O(2N)。(
      3.空间复杂度
      空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少
      bytes的空间,因为这个也没太大意义,所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟实践
      复杂度类似,也使用大O渐进表示法。

    3、空间复杂度

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

    实例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 ;
    }
    

    实例3:

    // 计算阶乘递归Factorial的空间复杂度?
    long long Factorial(size_t N)
    {
     return N < 2 ? N : Factorial(N-1)*N;
    }
    

    实例答案:

    1. 实例1使用了常数个额外空间,所以空间复杂度为 O(1)
    2. 实例2动态开辟了N个空间,空间复杂度为 O(N)
    3. 实例3递归调用了N次,开辟了N个栈帧,每个栈帧使用了常数个空间。空间复杂度为O(N)
    展开全文
  • 1.必须到机器上去计算,而且这个计算不只是一次,我们要用多组数据进行重复的运算,然后得到一个统计的结果,那么你要算上机器的时间。 2.肯定会有一些其他因素掩盖算法的本质。 2.事前分析估算法 通常比较算法...
  • 算法评价标准

    千次阅读 2021-11-02 19:00:15
    算法评价的标准 1 正确性 2 可读性 3 健壮性:运行稳定性、容错性、可靠性和环境适应性等 4 时间复杂度 5 空间复杂度 算法的时间复杂性 和算法执行时间相关的因素: 问题中存储数据的数据结构 算法采用的数学模型 ...
  • 双向聚类法卫生资源利用效率研究文献的分类及评价.pdf
  • 大数据-算法
  • 算法效率的度量通过时间复杂度和空间复杂度来衡量。 一般考察时间复杂度的内容偏多,空间复杂度了解就行。 1.时间复杂度 语句的频度是指一个语句在算法中被重复执行的次数。 时间复杂度是指执行算法所需要的计算...
  • 算法评价与神经网络算法

    千次阅读 2021-12-06 14:03:16
    算法效率 通常使用时间复杂度和空间复杂度,来计算运算时间的相对消耗及计算使用存储空间的相对消耗。 算法效果 对于参数量较大的算法或一些黑箱性质的算法,通常算法效果也是算法评价的重要指标。通常使用在测试...
  • 算法性能评价

    千次阅读 2019-09-23 08:05:25
    一种数据结构的优劣是由实现其各种运算的算法具体体现的,数据结构的分析实质上就是实现运算算法的分析,除了要验证算法是否正确解决该问题之外,还需要对算法效率作性能评价。在计算机程序设计中,算法分析是...
  • 算法效率主要体现在它的复杂度上,而算法复杂度,主要有两个维度,分别是时间复杂度与空间复杂度。时间复杂度是指执行这个算法所需要的计算工作量;而空间复杂度是指执行这个算法所需要的内存空间。时间和空间(即...
  • DEA决策单元进行评价,直接输入测算矩阵就可以。
  • 基于灰色聚类的码头前沿营运效率综合评价.pdf
  • 二、算法效率的度量1、时间复杂度2、空间复杂度 一、算法的基本概念 算法(Algorithm)是特定问题求解步骤的一种描述,它是指令的有限序列,其中的每条指令表示一个或多个操作。 此外,一个算法还具有下列5个...
  • DEA决策单元进行评价,直接输入测算矩阵就可以,方便简单,传统DEA模型进行了优化,克服传统DEA中同时出现多个有效评价单元时无法进行作进一步评价的缺陷,多个有效的评价单元作出进一步的评判
  • 多目标优化算法的性能评价
  • 针对粒子群优化算法(PSO) 在处理高维复杂函数时容易陷入局部极值... 最后, 运用典型函数所提出算法进行测试, 并与最新相关算法进行比较, 结果表明, 所提出算法在全局搜索能力、效率和稳定性方面均具有明显的优势.</p>
  • 算法创作|如何评价算法

    千次阅读 2021-03-20 00:31:32
    本文首发于微信公众号:"算法与编程之美",欢迎关注,及时了解更多此系列文章。问题描述在我们解决问题时,我们可以通过许多的途径去实现。而在这过程中,我们所用的途径可能是正确的...
  • 基于夹具定位方案几何稳定性概念,推导了确定性定位下夹具定位方案的几何稳定性参数表达式,并针对装配过程中偏差控制目标,提出了定位点搜索算法夹具定位点布置进行优化设计。通过某车型仪表板定位方案设计实例...
  • 为优化土地复垦规划设计,降低土地复垦成本,该研究构建了基于...满足了土地成本适宜和质量适宜的要求,协调了不同土地利用约束的需求,提高了土地复垦效率,工程复垦预算和复垦规划设计具有现实指导意义,在土地复垦评价
  • 遗传算法在现在的生产中应用很广泛,性能指标也很高,增加了生产效率,里面是其评价指标。
  • 与传统博弈交叉效率评价方法相比,改进方法不仅利于在相同的权重空间中不同决策单元进行比较,而且在收敛速度上有明显改善,在一定程度上可消除传统博弈交叉效率结果的不惟一问题.结果表明所有决策单元施加限制可...
  • 研究了行动-评价强化学习方法,通过把多步截断学习引入评价器代替单步学习,并定义一种新的迹来记忆最新的多步学习经验,提出一种新的行动-评价强化学习算法,并进行仿真实验,实验结果表明,新算法的学习效率有明显...
  • 主要讨论具有单隐层的正交投影神经网络的权值和 值的学习问题,提出了一种新的将BP算法和GS算法相结合的杂交学习算法,其中GS算法对隐层到输出层的权值和阈值进行学习,BP算法用于输入层到隐层权值的学习,并给出一种...
  • 算法效率的衡量

    千次阅读 2017-11-18 07:58:26
    执行时间反应算法效率假设对于同一问题,我们给出了两种解决算法,在两种算法的实现中,我们程序执行的时间进行了测算,发现两段程序执行的时间相差悬殊,由此我们可以得出结论:实现算法程序的执行时间可以反应出...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,504
精华内容 23,801
热门标签
关键字:

对算法效率进行评价