精华内容
下载资源
问答
  • 这里我们来简单介绍一下时间复杂度和空间复杂度,并且给出表示的方法和例子。 时间复杂度关系到程序运行快慢,(时间上的效率) 空间复杂度运行时占用的内存/外存的空间多少 衡量一段代码效率,不一样的机器,不...

    复杂度可以看作是一段程序执行时,所要耗费时间或者空间上的量级。这里我们来简单介绍一下时间复杂度和空间复杂度,并且给出表示的方法和例子。

    • 时间复杂度关系到程序运行快慢,(时间上的效率)
    • 空间复杂度运行时占用的内存/外存的空间多少

    衡量一段代码效率,不一样的机器,不一样的环境。
    通过基本操作的数量,重复执行次数越多,程序运行就越慢

    O 渐进表示法:只是关注基本操作执行次数的数量级,不用很精确

    • 数组顺序查找时间复杂度为O(N),O(N) 表示基本操作大概执行N次.
    • 固定次数执行基本操作就可以记作O(1)
    • N 指的是数据的规模,两个数据规模相加
    • O(1) 程序运行时间不一定比 O(N)的运行时间短,宏观来看前者更快一些
    • 冒泡排序的时间复杂度为O(N^2) ,比较慢。二分查找时间复杂度为O(logN),与O(N)相差很多,比较快。
    • 递归阶乘O(N)
    展开全文
  • 今天我们来谈一下怎样计算时间复杂度。 时间复杂度概念:(百度版) 同一问题可用不同算法解决,而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法。 计算机科学中,...

    今天我们来谈一下怎样计算时间复杂度。

    时间复杂度概念:(百度版)

    同一问题可用不同算法解决,而一个算法的质量优劣将影响到算法乃至程序的效率。

    算法分析的目的在于选择合适算法和改进算法。

    计算机科学中,算法的时间复杂度是一个函数,它定量描写叙述了该算法的执行时间。

    这是一个关于代表算法输入值的字符串的长度的函数。时间复杂度经常使用大O符号表述,不包含这个函数的低阶项和首项系数。使用这样的方式时。时间复杂度可被称为是渐近的。它考察当输入值大小趋近无穷时的情况。

    注意:本文承接上一篇《数据结构与算法-函数的渐近增长》,想具体了解渐近增长,请点击:数据结构与算法-函数的渐近增长


    如今先上代码。请大家具体阅读凝视。由于整个计算过程都已经在凝视里面体现。


    /**
     * 计算时间复杂度
     * 
     * @author ray
     * 
     */
    public class Test {
    
    	private void test1(int n) {
    		System.out.println(n);// 操作=1
    	}
    
    	private void test2(int n) {
    		int a = 0;
    		for (int i = 0; i < n; i++) {// 操作=n
    			a++;// 操作=1
    		}
    		// 总操作=n*1=n
    		// 时间复杂度=O(1)
    	}
    
    	private void test3(int n) {
    		int a = 0;
    		for (int i = 0; i < n; i++) {// 操作=n
    			for (int j = 0; j < n; j++) {// 操作=n
    				a++;// 操作=1
    			}
    		}
    		// 总操作=n*n*1=n^2
    		// 时间复杂度=O(n^2)
    	}
    
    	private void test4(int n) {
    		int a = 0;
    		for (int i = 0; i < n; i++) {
    			for (int j = i; j < n; j++) {// 操作=n,n-1,n-2,n-3......1=(n+1)n/2
    				a++;// 操作=1
    			}
    		}
    		// 总操作=(n+1)n/2=n^2/2+n/2
    		// 因为时间复杂度是一个抽象的概念,当n的规模达到一定程度的时候。时间复杂度仅仅取最高次幂,并且忽略其它次要项和系数
    		// 时间复杂度=O(n^2)
    	}
    
    	private void test5(int n) {
    		int a = 0;
    		for (int i = 0; i < n; i++) {
    			for (int j = i; j < n; j++) {// 操作=n,n-1,n-2,n-3......1=(n+1)n/2
    				a++;// 操作=1
    				System.out.println(a);// 操作=1
    				// for循环内总操作=2
    			}
    		}
    		// 总操作=(n+1)n/2*2=n^2+n
    		// 因为时间复杂度是一个抽象的概念,当n的规模达到一定程度的时候,时间复杂度仅仅取最高次幂。并且忽略其它次要项和系数
    		// 时间复杂度=O(n^2)
    	}
    
    	private void test6(int n) {
    		int a = 0;
    		for (int i = 0; i < n; i++) {
    			for (int j = i; j < n; j++) {// 操作=n,n-1,n-2,n-3......1=(n+1)n/2
    				a++;// 操作=1
    				System.out.println(a);// 操作=1
    				System.out.println(i);// 操作=1
    				// for循环内总操作=3
    			}
    		}
    		// 总操作=(n+1)n/2*3=n^2*3/2+n*3/2
    		// 因为时间复杂度是一个抽象的概念,当n的规模达到一定程度的时候,时间复杂度仅仅取最高次幂,并且忽略其它次要项和系数
    		// 时间复杂度=O(n^2)
    	}
    
    	private void test7(int n) {
    		int a = 0;
    		int b = 0;
    		for (int i = 0; i < n; i++) {// 操作=n
    			for (int j = 0; j < n; j++) {// 操作=n
    				a++;// 操作=1
    				System.out.println(a);// 操作=1
    				// for循环内总操作=2
    				for (int k = 0; k < n; k++) {// 操作=n
    					b++;// 操作=1
    					// for循环内总操作=1
    				}
    			}
    		}
    		// 总操作==n^3+2n^2
    		// 因为时间复杂度是一个抽象的概念,当n的规模达到一定程度的时候,时间复杂度仅仅取最高次幂。并且忽略其它次要项和系数
    		// 时间复杂度=O(n^3)
    	}
    
    	public static void main(String[] args) {
    		int n = 10;
    		Test t = new Test();
    		t.test1(n);
    		t.test2(n);
    		t.test3(n);
    		t.test4(n);
    		t.test5(n);
    		t.test6(n);
    		t.test7(n);
    	}
    }
    



    转载于:https://www.cnblogs.com/lxjshuju/p/7000754.html

    展开全文
  • 如题,由于本人非科班毕业,给出这样的表达式,如T(N)=T(N/2)+T(2N)+N,怎么样计算时间复杂度?请各位指点下迷津,说说方法也行了,在百度上实在不知道搜什么关键词!
  • 计算执行程序的过程中,有两个衡量一个程序的所要消耗的空间和时间,这两个单位就是空间和时间复杂度。 因为如果只是单纯的对计算机的执行时间进行一个时间复杂度的定义,因为每台计算机的执行速度因配置而定,很...

    在计算执行程序的过程中,有两个衡量一个程序的所要消耗的空间和时间,这两个单位就是空间和时间复杂度。

    因为如果只是单纯的对计算机的执行时间进行一个时间复杂度的定义,因为每台计算机的执行速度因配置而定,很难完全相同,所以这样定义的时间复杂度是有问题的,但是如果将时间复杂度定义为一个程序最大执行的次数,就可以避开这个问题,因为无论是配置怎样高的计算机,他对一个程序的执行次数是肯定的,所以时间复杂度就是一个程序执行的次数。我么这里说的执行次数都是最大执行次数,因为一个程序的最差的情况往往是越容易发生的,所以我们选取最大的运行次数来计算时间复杂度。

    而空间复杂度的含义就和他的字面意思一样,就是程序在运行过程中所需要消耗的内存空间的大小。

     

    上面的是基本的定义,我们这里进行一个时间复杂度的具体讨论,空间复杂的具体讨论参照时间复杂度,就不一 一列举了。

    1.当计算机的执行次数为有限次的时候,时间复杂度是 O(1)。

            如果一个程序中有一个循环,循环进行的次数是确定的,那么这个循环的时间复杂度就是 O(1)。所以当我们看到一个时间复杂度为O(1)的程序的时候,并不是说这个程序仅仅执行了一个,而是这个程序执行了有限次,你可以知道的有限次,哪怕执行了一万次,一千万次,只要他的执行次数是已知的,时间复杂度都是O(1)。

    for(int i = 0;i < 10;i++)//这样的循环有10次,时间复杂度是O(1)
    {
        printf("%d\n",i);
    }
    
    for(int i = 0;i < 100000000;i++)//这样的循环有100000000次,时间复杂度是O(1)
    {
        printf("%d\n",i);
    }

    2.当计算机的执行次数并不能之直接指导具体的执行次数的时候,根据情况,进行时间复杂度的分析

            看一下例子,如果一个循环的循环次数并不已知,而是根据传入的参数进行变化,那就把这个次数定位n,当出现执行次数为N*N的时候,时间复杂度就是 N^2,不能进行简化,但是如果执行次数为2N的时候,时间复杂度就是N,因为在计算机的运行过程中,这样有限的已知的倍数可以化简为1,所以不进行计算。并且如果一个 N+20的运行次数,也应该简化为N,因为有限的运行次数都是需要进行简化的。

            这里的简化标准仅仅只是一个开始,我准备了一些例子,通过例子,来看具体的简化操作。答案我会附在后面,可以自己作对比。

    void Func1(int N) 
    { 
        int count = 0; 
        for (int i = 0; i < N ; ++ i)//执行次数为N*N
        {    
            for (int j = 0; j < N ; ++ j) 
           {       
               ++count;  
           }
        } 
        for (int k = 0; k < 2 * N ; ++ k)//执行次数为2N
        {
            ++count;
        }
     
        int M = 10; 
        while (M--)
        {    
            ++count;
        }
     
        printf("%d\n", count);
    } 
    void Func2(int N)// 计算Func2的时间复杂度?
    { 
    	int count = 0;
    	for (int k = 0; k < 2 * N; ++k) 
    	{ 
    		++count;
    	}
    
    
    	int M = 10; 
    	while (M--) 
    	{ 
    		++count; 
    	}
    	printf("%d\n", count);
    }
     
    void Func3(int N, int M)// 计算Func3的时间复杂度?
    { 
    	int count = 0;
    	for (int k = 0; k < M; ++k)
    	{
    		++count; 
    	}
    	for (int k = 0; k < N; ++k)
    	{ 
    		++count; 
    	}
    	printf("%d\n", count); 
    }
    
    
    
    void Func4(int N)// 计算Func4的时间复杂度? 
    {
    	int count = 0;
    	for (int k = 0; k < 100; ++k) 
    	{ 
    		++count;
    	}
    	printf("%d\n", count); 
    }
    
    
    void BubbleSort(int* a, int n) // 计算BubbleSort的时间复杂度? 
    { 
    	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;
    	}
    }
    
    int BinarySearch(int* a, int n, int x)// 计算BinarySearch的时间复杂度?
    { 
    	assert(a);
    	int begin = 0; 
    	int end = n - 1;
    	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;
    }
    

    这里是答案:

    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是怎么计算出来的

     

     

     

     

     

     

    展开全文
  • 怎样求解算法的时间复杂度呢? ⑴ 找出算法中的基本语句; 算法中执行次数最多的那条语句就是基本语句,通常是最内层循环的循环体。 ⑵ 计算基本语句的执行次数的数量级; 只需计算基本语句执行次数的数量级,这就...

    1、如何计算算法的时间复杂度

    常见的算法时间复杂度由小到大依次为:

    Ο(1)<Ο(log2n)<Ο(n)<Ο(nlog2n)<Ο(n2)<Ο(n3)<…<Ο(2n)<Ο(n!)
    在这里插入图片描述
    怎样求解算法的时间复杂度呢?

    ⑴ 找出算法中的基本语句;

    算法中执行次数最多的那条语句就是基本语句,通常是最内层循环的循环体。

    ⑵ 计算基本语句的执行次数的数量级;

    只需计算基本语句执行次数的数量级,这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可,可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析,并且使注意力集中在最重要的一点上:增长率。

    ⑶ 用大Ο记号表示算法的时间性能。

    将基本语句执行次数的数量级放入大Ο记号中。

    2、举例计算

    for (i=1; i<=n; i++)  
           x++;  
    for (i=1; i<=n; i++)  
         for (j=1; j<=n; j++)  
              x++;  
    

    第一个for循环的时间复杂度为Ο(n),
    第二个for循环的时间复杂度为Ο(n2),
    则整个算法的时间复杂度为Ο(n+n2)=Ο(n2)。

    以后就具体问题具体分析吧~~~~

    展开全文
  • 在我们编程的过程中,可能会遇到这样的情况。(下面只是一个小小的例子,现实中不会这么简单,这里只是取到一个抛砖引玉的作用哈) ...那么我们在程序中应该怎样去实现了 有的人可能会这样写: $a=0;for (...
  • 求解时间复杂度

    千次阅读 热门讨论 2015-11-15 21:00:12
    算法复杂度分为时间复杂度和空间... 那么,时间复杂度需要怎样计算呢! 【平行循环】  一个算法的时间复杂度要看这个算法的执行次数,首先要找这个方法的基础语句,算法中执行次数最多的那条语句就是基本语句,
  • 在实际应用中,会根据要解决的问题写出几个相应的解决办法,但是我们要选择执行效率最高的算法,那么怎样评估算法的效率呢,这时候就要用到算法时间复杂度了 二、如何计算算法的时间复杂度 步骤: 计算代码的时间...
  • 公式的正确读法:如O(log2),读作O log2的时间复杂度,这里的O指的它的复杂度是n的怎样一个函数。 举例: 时间复杂度曲线: 如何计算递归的时间复杂度? 示例:求斐波拉契数,使用递归求解、 主定理:...
  • 计算机的资源,最重要的是时间和空间(即存储器)资源。因而,算法的复杂性有时间复杂性和空间复杂性之分。 对于任意给定的问题,设计出复杂性尽可能低的算法是我们在设计算法时追求的一个重要目标;另一方面,当...
  • 我在来看计算机是怎样做除法的。给定两个自然数m1, m2。我们假设m1>m2;这样我们有了一个代数的表达式:m1=pm2+q。很显然p是商,q是余数且m2>q;我们也很容易理解为m1迭代连续p次减m2,最后得出结果如下式: m1=m1...
  • 数据计算 当对数据进行处理时,处理简单、结构化的数据集较为简单,算法复杂度也易于预测和评估,但是对于处理半结构化,非结构化数据时呈现多样化的问题,分析数据困难更大,算法复杂度超越了经典摩尔定量,整个...
  • HashMap怎样解决散列(hash)冲突?

    万次阅读 多人点赞 2018-12-12 15:58:10
    常用两种方法:链表法和开放寻址法 1、链表法(chaining) 在哈希表中,每一个桶(bucket)或者槽...在查找或删除元素时,我们同样通过散列函数计算出对应的散列槽位,然后再通过遍历链表进行查找或删除,时间复杂度...
  • 散列法(hash法、关键字地址计算法)

    千次阅读 2016-08-06 14:04:19
    时间复杂度为0(理想情况下),是一种key-value的存储方法。核心就是由hash函数决定关键字值和散列地址之间的关系,通过这种关系来组织存储并进行查找等操作。散列法面临的问题:会发生地址冲突。 (1)如何恰当的构造...
  •  在计算机复杂度理论中,P问题指的是能够在多项式的时间里得到解决的问题,NP问题指的是能够在多项式的时间里验证一个解是否正确的问题。 虽然人们大多相信P问题不等于NP问题,但人们目前既不能证明它,也不能推翻...
  • 线性动态规划(2)

    2020-04-06 23:45:54
    -  这周动态规划的训练结束了。... 当然,还有很多描述什么是算法的时间复杂度以及怎样计算的,但但多语言比较专业,半懂不懂,但总的来说还是有所收获的。  回到重点,动态规划,这周在做题时我总在...
  • 问题描述:有一个数据集合(该数据集合目前还在飞速增长中,计算复杂度也远高于O(N),如果这种简单的计算都搞不定,其他的就别搞了),2500*36的矩阵,需要任意两列之间进行两两的对比,计算由任意两行组成的向量...
  • 对这种蛮力算法的时间复杂度进行分析,并通过实施和实验验证您的分析结果(既写出来算法的设计思路等),并用python算法实现编程 2.通过动态编程开发更有效的算法。 您应该首先通过动态编程的思想来分析此问题,并...
  • 17-18专业课

    2019-10-07 06:56:13
    二叉树计算叶子节点算法,时间复杂度。(可使用任一程序设计语言或伪代码,建议先用自然语言描述算法)几乎逆序的数组排序用什么排序算法?写出算法,时间复杂度。二叉排序树的2种优化方法,并且介绍这两种方法是...
  • +专业课考点参考

    2019-10-07 06:53:39
    二叉树计算叶子节点算法,时间复杂度。(可使用任一程序设计语言或伪代码,建议先用自然语言描述算法)几乎逆序的数组排序用什么排序算法?写出算法,时间复杂度。二叉排序树的2种优化方法,并且介绍这两种方法是...
  • 在这一讲我们将介绍算法的复杂度怎样衡量一个算法的复杂度,以及算法的效率,参数大小的计算需要的时间,我们的目的不是要预测算法的运行时间,而是了解算法的内在复杂度 从常量算法、到线性算法,再到多项式和...
  • 1.什么是数据结构与算法? 数据结构:一组数据的存储结构。(线性表,散列表,图,树) 算法:操作数据的一组方法。...复杂度分析:空间复杂度,时间复杂度。 4.散列表(哈希表)(散列函数构造、处理冲...

空空如也

空空如也

1 2 3 4 5
收藏数 91
精华内容 36
关键字:

怎样计算时间复杂度