精华内容
下载资源
问答
  • 因为在线下上课时,老师可能会回顾一下上周的内容、某些内容会看学生的反应重复几遍、会当堂问做一些提问,以及在各种软件等教学工具之间切换,这些都要花点时间,而这些在线上课程中都不存在了,所以视频的时间不会...
  • 今天是我离职后的一个月零好几天,很幸运有同学的帮助,知晓了这个面试机会,上午到公司写了份笔试题目,发现有许多题目都不会,这也侧面反应了自己JAVA基础... JS中有六数据类型,其中包括基本的数据类型(...

    今天是我离职后的一个月零好几天,很幸运有同学的帮助,知晓了这个面试机会,上午到公司写了份笔试题目,发现有许多题目都不会,这也侧面反应了自己JAVA基础不是很好。

    下面是自己不是很懂的题目,写下来,不仅是对自己的总结,也算是一种分享,如果有人看到我的博客有所收获,也是一件让人开心的事。

     

    1.JavaScript的几种基本数据类型。

       JS中有六大数据类型,其中包括五种基本的数据类型(Number、String、Boolean、undefned、null)和一种复杂的数据类型(Object)。

    2.HTTP的get和post的区别。

         get请求将参数放入url中传递,post是通过request body进行传递;不过get和post本质上都是TCP连接,但是由于HTTP的规定和浏览器/服务器的限制,导致他们在应用过程中有些不同,其实,get和post还有一个重要的区别,就是:get产生一个数据包,post产生两个数据包。

         (w3schools)标准答案:

         (1)get在浏览器回退是无害的,post会再次提交请求。

         (2)get请求会被浏览器主动cache,但是post不行,除非手动设置。

         (3)get产生的url地址可以bookmark,但是post不行。

         (4)get请求只能进行url编码,post支持多种编码。

         (5)get请求参数会被完整保留在浏览器历史记录里,但post不会。

         (6)get请求在url中传送的参数有长度限制,而post没有。

         (7)get请求的参数数据类型必须是ASCII字符,而post没限制。

         (8)get请求没有post安全,因为参数暴露在url中。

         (9)get请求将参数放入url中传递,post是通过request body进行传递。

          若有不明之处,可参考原文链接:https://mp.weixin.qq.com/s?__biz=MzI3NzIzMzg3Mw==&mid=100000054&idx=1&sn=71f6c214f3833d9ca20b9f7dcd9d33e4#rd

          关于(1),有人解释:因为Get请求浏览器有缓存,回退时读取的是缓存中的数据. 但是Post没有浏览器缓存会再次发送请求,消耗服务器性能. 

    3.如何把一个逗号分割的字符串转换为一个数组。

    public static void main(String[] args) {
    
                    System.out.println("---通过split方法转换为数组---");
    		String str="avd,faaw,lfa,we";
    		String[] result=str.split(",");
    		for (String string : result) {
    			System.out.println(string);
    		}
    
    		System.out.println("---通过StringTokenizer方法转换为数组---");
    		StringTokenizer tokener=new StringTokenizer(str, ",");
    		String[] result1=new String[tokener.countTokens()];
    		int i=0;
    		while (tokener.hasMoreElements()) {
    			result1[i++]=tokener.nextToken();
    		}
    		for (int j = 0; j < result1.length; j++) {
    			System.out.println(result1[j]);
    		}
    		
    	}

       注:JAVA中,既可以用split()方法分隔字符串,也可以用StringTokenizer进行分隔字符串。但是StringTokenizer分隔的字符串是逐个分隔,而split()方法是整体分隔。若有疑问,可参考链接:https://www.runoob.com/java/java-stringtokenizer-example.html

    4.java的几种循环结构。

      (1)for循环:for(变量初始化;循环成立条件;循环变量更新){ }

      (2)while循环:while(循环条件){ }

      (3)do..while循环:do{ }while(循环条件),至少要执行一次

      注:java5中引入了一种主要用于数组的增强for循环:for(变量类型 变量名:表达式(一般为要访问的数组名或者返回值为数组的方法)){ }

      详细可参考:https://blog.csdn.net/Life_s/article/details/78885942

    5.JAVA循环遍历Map的几种方法。

    6.Servlet是什么以及它的生命周期。

    7.有一张department表,它有departId(部门id)、departName(部门名称)、departUpId(上级部门id)、departDate(部门成立时间)。

    (1)写一段语句,查询表中重复的部门以及数量。

    (2)写一段sql,查询成立日期至今大于两年,1-2年,小于1年的部门(oracle)。

    (3)查询上级部门名称为销售部的第5-10条记录。

    8.判断101-200之间有多少个素数并且将其打印出来。

    9.利用代码实现JAVA简单的工厂模式。

    展开全文
  • 文章目录第一次尝试第二次改进算法的提出算法的概念算法的五大特征算法效率衡量执行时间反应算法效率不能单靠时间衡量算法效率时间复杂度与“大O记法”如何理解“大O记法”最坏时间复杂度时间复杂度的几条基本计算...

    第一次尝试

    试验:若a+b+c=1000,a ^2 +b ^2=C ^2,abc的取值有多少种组合?

    • 枚举法(最原始的方法,最笨的方法)
    import time
    start_time=time.time()
    for a in range(0,1001):
        for b in range(0,1001):
            for c in range(0,1001):
                if a+b+c==1000 and a**2 +b**2==c**2:
                    print('a,b,c:%d,%d,%d'%(a,b,c))
    end_time=time.time()
    print('times:%d'%(end_time-start_time))
    print('finished')
    
    a,b,c:0,500,500
    a,b,c:200,375,425
    a,b,c:375,200,425
    a,b,c:500,0,500
    times:113
    finished
    

    第二次改进

    import time
    
    start_time = time.time()
    
    # 注意是两重循环
    for a in range(0, 1001):
        for b in range(0, 1001-a):
            c = 1000 - a - b
            if a**2 + b**2 == c**2:
                print("a, b, c: %d, %d, %d" % (a, b, c))
    
    end_time = time.time()
    print("elapsed: %f" % (end_time - start_time))
    print("complete!")
    
    a, b, c: 0, 500, 500
    a, b, c: 200, 375, 425
    a, b, c: 375, 200, 425
    a, b, c: 500, 0, 500
    elapsed: 0.545541
    complete!
    

    算法的提出

    算法的概念

    算法是计算机处理信息的本质,因为计算机程序本质上是一个算法来告诉计算机确的步骤来执行一个指定的任务。一般地,当算法在处理信息时,会从输入设备或数据的存储地址读取数据,把结果写入输出设备或 某个存储地址供以后再调用
    算法是独立存在的一种解决问题的方法和思想。
    对于算法而言,实现的语言并不重要,重要的是思想
    法可以有不同的语言描述实现版本(如C描述、C++描述、Python措述等),我们现在是在用Python语言进行描述实现。

    算法的五大特征

    1.输入: 算法具有0个或多个输入
    2.输出: 算法至少有1个或多个输出
    3.有穷性: 算法在有限的步骤之后会自动结束而不会无限循环,并且每一个步骤可以在可接受的时间内完成
    4.确定性:算法中的每一步都有确定的含义,不会出现二义性
    5.可行性:算法的每一步都是可行的,也就是说每一步都能够执行有限的次数完成

    算法效率衡量

    执行时间反应算法效率

    对于同一问题,我们给出了两种解决算法,在两种算法的实现中,我们对程序执行的时间进行了测算,发现两段程序执行的时间相差悬殊(113秒相比于0.545541秒),由此我们可以得出结论:实现算法程序的执行时间可以反应出算法的效率,即算法的优劣。

    不能单靠时间衡量算法效率

    假设我们将第二次尝试的算法程序运行在一台配置古老性能低下的计算机中,情况会如何?很可能运行的时间并不会比在我们的电脑中运行(1)的速度快多少。
    单纯依靠运行的时间来比较算法的优劣并不一定是客观准确的
    程序的运行离不开计算机环境(包括硬件和操作系统),这些客观原因会影响程序运行的速度并反应的执行时间上。那么如何才能客观的评判-个算法的优劣呢?

    时间复杂度与“大O记法”

    我们假定计算机执行算法每—个基本操作的时间是固定的一个时间单位,那么有多少个基本操作就代表会花费多少时间单位。虽然对于不同的机器环境而言,确切的单位时间是不同的,但是对于算法进行多少个基本操作(即花费多少时间单位) 在规模数量级上却是相同的,由此可以忽略机器环境的影响而客观的反应算法的时间效率。
    对于算法的时间效率,我们可以用“大O记法"来表示
    “大O记法”:对于单调的整数函数f,如果存在一个整数函数g和实常数c>0,使得对于充分大的n总有f(n)<=c*g(n),就说函数g是f的一个渐近函数(忽略常数),记为f(n)=O(g(n))。也就是说,在趋向无穷的极限意义下,函数f的增长速度受到函数g的约束,亦即函数f与函数g的特征相似。
    时间复杂度:假设存在函数g,使得算法A处理规模为n的问题示例所用时间为T(n)=O(g(n)),则称O(g(n))为算法A的渐近时间复杂度,简称时间复杂度,记为T(n)

    如何理解“大O记法”

    对于算法进行特别具体的细致分析虽然很好,但在实践中的实际价值有限。对于算法的时间性质和空间性质,最重要的是其数量级和趋势,这些是分析算法效率的主要部分。而计量算法基本操作数量的规模函数中那些常量因子可以忽略不计。例如,可以认为3n2和100n2属于同一个量级,如果两个算法处理同样规模实例的代价分别为这两个函数,就认为它们的效率“差不多”,都为n2级。

    最坏时间复杂度

    分析算法时,存在几种可能的考虑:

    算法完成工作最少需要多少基本操作,即最优时间复杂度
    算法完成工作最多需要多少基本操作,即最坏时间复杂度
    算法完成工作平均需要多少基本操作,即平均时间复杂度
    对于最优时间复杂度,其价值不大,因为它没有提供什么有用信息,其反映的只是最乐观最理想的情况,没有参考价值。

    对于最坏时间复杂度,提供了一种保证,表明算法在此种程度的基本操作中一定能完成工作。

    对于平均时间复杂度,是对算法的一个全面评价,因此它完整全面的反映了这个算法的性质。但另一方面,这种衡量并没有保证,不是每个计算都能在这个基本操作内完成。而且,对于平均情况的计算,也会因为应用算法的实例分布可能并不均匀而难以计算。

    因此,我们主要关注算法的最坏情况,亦即最坏时间复杂度。

    时间复杂度的几条基本计算规则

    1.基本操作,即只有常数项,认为其时间复杂度为O(1)
    2.顺序结构,时间复杂度按加法进行计算
    3.循环结构,时间复杂度按乘法进行计算
    4.分支结构,时间复杂度取最大值
    判断一个算法的效率时,往往只需要关注操作数量的最高次项,其它次要项和常数项可以忽略
    在没有特殊说明时,我们所分析的算法的时间复杂度都是指最坏时间复杂度

    常见时间复杂度

    注意,经常将log2n(以2为底的对数)简写成logn
    常见时间复杂度之间的关系:
    在这里插入图片描述
    所消耗的时间从小到大

    O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n^3) < O(2 ^n) < O(n!) < O(n ^n)

    Python内置类型性能分析

    timeit模块

    timeit模块可以用来测试一小段Python代码的执行速度。

    class timeit.Timer(stmt='pass', setup='pass', timer=<timer function>)
    

    Timer是测量小段代码执行速度的类。

    stmt参数是要测试的代码语句(statment);

    setup参数是运行代码时需要的设置;

    timer参数是一个定时器函数,与平台有关。

    timeit.Timer.timeit(number=1000000)
    

    Timer类中测试语句执行速度的对象方法。number参数是测试代码时的测试次数,默认为1000000次。方法返回执行代码的平均耗时,一个float类型的秒数。

    不同类型列表操作的时间效率

    试验:append与+=创建列表的时间效率:

    from timeit import Timer
    def t1():
        li= []
        for i in range(10000):
            li.append(i)
    def t2():
        li = []
        for i in range(10000):
            li += [i]
    def t3():
        li = [i for i in range(10000)]
    def t4():
        li = list(range(10000))
    def t5():
        li=[]
        for i in range(10000):
            li.extend([i])
    def t6():
        li=[]
        for i in range(10000):
            li.insert(1,i)
    timer1 = Timer('t1()', 'from __main__ import t1')
    print('append:',timer1.timeit(1000))
    timer2 = Timer('t2()', 'from __main__ import t2')
    print('+:',timer2.timeit(1000))
    timer3 = Timer('t3()', 'from __main__ import t3')
    print('[i for i in range(10000)]:',timer3.timeit(1000))
    timer4 = Timer('t4()', 'from __main__ import t4')
    print('list(range(10000)):',timer4.timeit(1000))
    timer5 = Timer('t5()', 'from __main__ import t4')
    print('extend:',timer4.timeit(1000))
    timer6 = Timer('t6()', 'from __main__ import t4')
    print('insert:',timer4.timeit(1000))
    
    
    
    append: 0.5449690999999999
    +: 0.6627310999999999
    [i for i in range(10000)]: 0.2919345
    list(range(10000)): 0.17491080000000014
    extend: 0.17312720000000015
    insert: 0.18060199999999993
    
    
    def t2():
        li = []
        for i in range(10000):
            #li += [i]  #这个和=+还是有区别的!
            li=li+[i]
    timer2 = Timer('t2()', 'from __main__ import t2')
    print('+:',timer2.timeit(1000))
    
    +: 112.227202
    

    list内置操作的时间复杂度

    在这里插入图片描述

    dict内置操作的时间复杂度

    在这里插入图片描述

    数据结构

    我们如何用Python中的类型来保存一个班的学生信息? 如果想要快速的通过学生姓名获取其信息呢?

    实际上当我们在思考这个问题的时候,我们已经用到了数据结构。列表和字典都可以存储一个班的学生信息,但是想要在列表中获取一名同学的信息时,就要遍历这个列表,其时间复杂度为O(n),而使用字典存储时,可将学生姓名作为字典的键,学生信息作为值,进而查询时不需要遍历便可快速获取到学生信息,其时间复杂度为O(1)。

    我们为了解决问题,需要将数据保存下来,然后根据数据的存储方式来设计算法实现进行处理,那么数据的存储方式不同就会导致需要不同的算法进行处理。我们希望算法解决问题的效率越快越好,于是我们就需要考虑数据究竟如何保存的问题,这就是数据结构。

    在上面的问题中我们可以选择Python中的列表或字典来存储学生信息。列表和字典就是Python内建帮我们封装好的两种数据结构。

    概念

    数据是一个抽象的概念,将其进行分类后得到程序设计语言中的基本类型。如:int,float,char等。数据元素之间不是独立的,存在特定的关系,这些关系便是结构。数据结构指数据对象中数据元素之间的关系。

    Python给我们提供了很多现成的数据结构类型,这些系统自己定义好的,不需要我们自己去定义的数据结构叫做Python的内置数据结构,比如列表、元组、字典。而有些数据组织方式,Python系统里面没有直接定义,需要我们自己去定义实现这些数据的组织方式,这些数据组织方式称之为Python的扩展数据结构,比如栈,队列等。

    算法与数据结构的区别

    数据结构只是静态的描述了数据元素之间的关系。

    高效的程序需要在数据结构的基础上设计和选择算法。

    程序 = 数据结构 + 算法

    总结:算法是为了解决实际问题而设计的,数据结构是算法需要处理的问题载体

    抽象数据类型(Abstract Data Type)

    抽象数据类型(ADT)的含义是指一个数学模型以及定义在此数学模型上的一组操作。即把数据类型和数据类型上的运算捆在一起,进行封装。引入抽象数据类型的目的是把数据类型的表示和数据类型上运算的实现与这些数据类型和运算在程序中的引用隔开,使它们相互独立。

    最常用的数据运算有五种:

    1. 插入
    2. 删除
    3. 修改
    4. 查找
    5. 排序
    展开全文
  • 在此窗口中分为签约登记和提成分配两部分,在签约登记中选择客户类型(如果是已登记客户,真接输入客户编号就可显示出客户信息),填写实际的签约信息;在提成分配中对此次交易需要分配提成的员工进行登记分配比例,...
  • 概念1.1 算法的提出算法的概念算法的五大特性1.2 算法效率衡量执行时间反应算法效率单靠时间值绝对可信吗?时间复杂度与“大O记法”如何理解“大O记法”最坏时间复杂度时间复杂度的几条基本计算规则1.3 常见时间...

    1.概念

    1.1 算法的提出

    算法的概念

    算法是计算机处理信息的本质,因为计算机程序本质上是一个算法来告诉计算机确切的步骤来执行一个指定的任务。一般地,当算法在处理信息时,会从输入设备或数据的存储地址读取数据,把结果写入输出设备或某个存储地址供以后再调用。
    算法是独立存在的一种解决问题的方法和思想。
    对于算法而言,实现的语言并不重要,重要的是思想。
    算法可以有不同的语言描述实现版本(如C描述、C++描述、Python描述等)。

    算法的五大特性

    1.输入: 算法具有0个或多个输入
    2.输出: 算法至少有1个或多个输出
    3.有穷性: 算法在有限的步骤之后会自动结束而不会无限循环,并且每一个步骤可以在可接受的时间内完成
    4.确定性:算法中的每一步都有确定的含义,不会出现二义性
    5.可行性:算法的每一步都是可行的,也就是说每一步都能够执行有限的次数完成

    1.2 算法效率衡量

    执行时间反应算法效率

    实现算法程序的执行时间可以反应出算法的效率,即算法的优劣。

    单靠时间值绝对可信吗?

    单纯依靠运行的时间来比较算法的优劣并不一定是客观准确的!
    程序的运行离不开计算机环境(包括硬件和操作系统),这些客观原因会影响程序运行的速度并反应在程序的执行时间上。

    时间复杂度与“大O记法”

    算然对于不同的机器环境而言,确切的单位时间是不同的,但是对于算法进行多少个基本操作(即花费多少时间单位)在规模数量级上却是相同的,由此可以忽略机器环境的影响而客观的反应算法的时间效率。

    对于算法的时间效率,可以用“大O记法”来表示。

    “大O记法”:对于单调的整数函数f,如果存在一个整数函数g和实常数c>0,使得对于充分大的n总有f(n)<=c*g(n),就说函数g是f的一个渐近函数(忽略常数),记为f(n)=O(g(n))。也就是说,在趋向无穷的极限意义下,函数f的增长速度受到函数g的约束,亦即函数f与函数g的特征相似。

    时间复杂度:假设存在函数g,使得算法A处理规模为n的问题示例所用时间为T(n)=O(g(n)),则称O(g(n))为算法A的渐近时间复杂度,简称时间复杂度,记为T(n)

    如何理解“大O记法”

    对于算法的时间性质和空间性质,最重要的是其数量级和趋势,这些是分析算法效率的主要部分。而计量算法基本操作数量的规模函数中那些常量因子可以忽略不计。例如,可以认为3n2和100n2属于同一个量级,如果两个算法处理同样规模实例的代价分别为这两个函数,就认为它们的效率“差不多”,都为n2级。

    最坏时间复杂度

    分析算法时,存在几种可能的考虑:
    算法完成工作最少需要多少基本操作,即最优时间复杂度
    算法完成工作最多需要多少基本操作,即最坏时间复杂度
    算法完成工作平均需要多少基本操作,即平均时间复杂度

    对于最优时间复杂度,其价值不大,因为它没有提供什么有用信息,其反映的只是最乐观最理想的情况,没有参考价值。

    对于最坏时间复杂度,提供了一种保证,表明算法在此种程度的基本操作中一定能完成工作。

    对于平均时间复杂度,是对算法的一个全面评价,因此它完整全面的反映了这个算法的性质。但另一方面,这种衡量并没有保证,不是每个计算都能在这个基本操作内完成。而且,对于平均情况的计算,也会因为应用算法的实例分布可能并不均匀而难以计算。

    因此,我们主要关注算法的最坏情况,亦即最坏时间复杂度。

    时间复杂度的几条基本计算规则

    1.基本操作,即只有常数项,认为其时间复杂度为O(1)
    2.顺序结构,时间复杂度按加法进行计算
    3.循环结构,时间复杂度按乘法进行计算
    4.分支结构,时间复杂度取最大值
    5.判断一个算法的效率时,往往只需要关注操作数量的最高次项,其它次要项和常数项可以忽略
    6.在没有特殊说明时,所分析的算法的时间复杂度都是指最坏时间复杂度

    1.3 常见时间复杂度

    在这里插入图片描述

    常见时间复杂度之间的关系

    在这里插入图片描述
    所消耗的时间从小到大
    O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) < O(2n) < O(n!) < O(nn)

    1.4 Python内置类型性能分析

    timeit模块

    timeit模块可以用来测试一小段Python代码的执行速度。

    class timeit.Timer(stmt=‘pass’, setup=‘pass’, timer=)
    Timer是测量小段代码执行速度的类。

    stmt参数是要测试的代码语句(statment);

    setup参数是运行代码时需要的设置;

    timer参数是一个定时器函数,与平台有关。

    timeit.Timer.timeit(number=1000000)
    Timer类中测试语句执行速度的对象方法。number参数是测试代码时的测试次数,默认为1000000次。方法返回执行代码的平均耗时,一个float类型的秒数。

    list的操作测试

    from timeit import Timer
    
    def test1():
        li = []
        for i in range(10000):
            li.append(i)
    
    def test2():
        li = []
        for i in range(10000):
        #    li += [i]
            li = li + [i]
    
    def test3():
        li = [i for i in range(10000)]
    
    def test4():
        li = list(range(10000))
    
    def test5():
        li = []
        for i in range(10000):
            li.extend([i])
    
    timer1 = Timer("test1()","from __main__ import test1")
    print("append:",timer1.timeit(1000))
    
    timer2 = Timer("test2()","from __main__ import test2")
    print("+:",timer2.timeit(1000))
    
    timer3 = Timer("test3()","from __main__ import test3")
    print("[i for i in range]:",timer3.timeit(1000))
    
    timer4 = Timer("test4()","from __main__ import test4")
    print("list(range():",timer4.timeit(1000))
    
    timer5 = Timer("test5()","from __main__ import test5")
    print("extend:",timer5.timeit(1000))
    
    def test6():
        li = []
        for i in range(10000):
            li.append(i)
    
    def test7():
        li = []
        for i in range(10000):
            li.insert(0,i)
    
    timer6 = Timer("test6()","from __main__ import test6")
    print("append:",timer6.timeit(1000))
    
    timer7 = Timer("test7()","from __main__ import test7")
    print("insert(0):",timer7.timeit(1000))
    

    pop操作测试

    x = range(2000000)
    pop_zero = Timer("x.pop(0)","from __main__ import x")
    print("pop_zero ",pop_zero.timeit(number=1000), "seconds")
    x = range(2000000)
    pop_end = Timer("x.pop()","from __main__ import x")
    print("pop_end ",pop_end.timeit(number=1000), "seconds")
    
    # ('pop_zero ', 1.9101738929748535, 'seconds')
    # ('pop_end ', 0.00023603439331054688, 'seconds')
    

    测试pop操作:从结果可以看出,pop最后一个元素的效率远远高于pop第一个元素

    list内置操作的时间复杂度

    在这里插入图片描述

    dict内置操作的时间复杂度

    在这里插入图片描述

    1.5 数据结构

    为了解决问题,需要将数据保存下来,然后根据数据的存储方式来设计算法实现进行处理,那么数据的存储方式不同就会导致需要不同的算法进行处理。希望算法解决问题的效率越快越好,于是就需要考虑数据究竟如何保存的问题,这就是数据结构。

    概念

    数据是一个抽象的概念,将其进行分类后得到程序设计语言中的基本类型。如:int,float,char等。数据元素之间不是独立的,存在特定的关系,这些关系便是结构。数据结构指数据对象中数据元素之间的关系。

    Python给我们提供了很多现成的数据结构类型,这些系统自己定义好的,不需要我们自己去定义的数据结构叫做Python的内置数据结构,比如列表、元组、字典。而有些数据组织方式,Python系统里面没有直接定义,需要我们自己去定义实现这些数据的组织方式,这些数据组织方式称之为Python的扩展数据结构,比如栈,队列等。

    算法与数据结构的区别

    数据结构只是静态的描述了数据元素之间的关系。

    高效的程序需要在数据结构的基础上设计和选择算法。

    程序 = 数据结构 + 算法

    总结:算法是为了解决实际问题而设计的,数据结构是算法需要处理的问题载体

    抽象数据类型(Abstract Data Type)

    抽象数据类型(ADT)的含义是指一个数学模型以及定义在此数学模型上的一组操作。即把数据类型和数据类型上的运算捆在一起,进行封装。引入抽象数据类型的目的是把数据类型的表示和数据类型上运算的实现与这些数据类型和运算在程序中的引用隔开,使它们相互独立。

    最常用的数据运算有五种:
    插入
    删除
    修改
    查找
    排序

    展开全文
  • 算法的提出1.1 算法的概念1.2 算法的五大特征2. 算法效率衡量2.1 执行时间反应算法效率2.2 时间复杂度与“大O记法”2.3 如何理解“大O记法”2.4 最坏时间复杂度2.5 时间复杂度的几条基本计算规则2.6常见的时间复杂度...

    1.算法的提出

    1.1 算法的概念
    • 算法是独立存在的一种解决问题的方法和思想
    • 对于算法而言,实现的语言并不重要,重要的是思想
      问题: 1. 如果 a+b+c=1000,且 a2 + b2 =c**2(a,b,c 为自然数),如何求出所有a、b、c可能的组合?
    import time
    
    start = time.time()
    for a in range(1001):
        for b in range(1001):
            for c in range(1001):
                if a + b + c == 1000 and a ** 2 + b ** 2 == c ** 2:
    
                    print('a, b, c:{} {} {}'.format(a, b, c))
    end = time.time()
    print('耗时:{}'.format(end - start))

    时间复杂度:
    T(n) = O(nnn)) = O(nnn) = O(n3)

    1.2 算法的五大特征
    • 输入: 算法具有0个或多个输入
    • 输出: 算法至少有1个或多个输出
    • 有穷性: 算法在有限的步骤之后会自动结束而不会无限循环,并且每一个步骤可以在可接受的时间内完成
    • 确定性:算法中的每一步都有确定的含义,不会出现二义性
    • 可行性:算法的每一步都是可行的,也就是说每一步都能够执行有限的次数完成

    2. 算法效率衡量

    上问题,解法二:

    import time
    
    start = time.time()
    for a in range(1001):
        for b in range(1001):
            c = 1000 - a - b
            if a ** 2 + b ** 2 == c ** 2:
                print('a, b, c:{} {} {}'.format(a, b, c))
    end = time.time()
    print('耗时:{}'.format(end - start))

    时间复杂度:
    T(n) = O(nn(1+1)) = O(n*n) = O(n2)

    2.1 执行时间反应算法效率
    • 实现算法程序的执行时间可以反应出算法的效率,即算法的优劣
    • 单纯依靠运行的时间来比较算法的优劣并不一定是客观准确的
    2.2 时间复杂度与“大O记法”
    • 假定计算机执行算法每一个基本操作的时间是固定的一个时间单位,那么有多少个基本操作就代表会花费多少时间单位
    • 算然对于不同的机器环境而言,确切的单位时间是不同的,但是对于算法进行多少个基本操作(即花费多少时间单位)在规模数量级上却是相同的
    • “大O记法”:对于单调的整数函数f,如果存在一个整数函数g和实常数c>0,使得对于充分大的n总有f(n)<=c*g(n),就说函数g是f的一个渐近函数(忽略常数),记为f(n)=O(g(n))。也就是说,在趋向无穷的极限意义下,函数f的增长速度受到函数g的约束,亦即函数f与函数g的特征相似
    • 时间复杂度:假设存在函数g,使得算法A处理规模为n的问题示例所用时间为T(n)=O(g(n)),则称O(g(n))为算法A的渐近时间复杂度,简称时间复杂度,记为T(n)
    2.3 如何理解“大O记法”
    • 可以认为3n2和100n2属于同一个量级,如果两个算法处理同样规模实例的代价分别为这两个函数,就认为它们的效率“差不多”,都为n2级
    2.4 最坏时间复杂度

    分析算法时,存在几种可能的考虑:

    • 算法完成工作最少需要多少基本操作,即最优时间复杂度
    • 算法完成工作最多需要多少基本操作,即最坏时间复杂度
    • 算法完成工作平均需要多少基本操作,即平均时间复杂度
    2.5 时间复杂度的几条基本计算规则
    1. 基本操作,即只有常数项,认为其时间复杂度为O(1)
    2. 顺序结构,时间复杂度按加法进行计算
    3. 循环结构,时间复杂度按乘法进行计算
    4. 分支结构,时间复杂度取最大值
    5. 判断一个算法的效率时,往往只需要关注操作数量的最高次项,其它次要项和常数项可以忽略
    6. 在没有特殊说明时,我们所分析的算法的时间复杂度都是指最坏时间复杂度
    2.6常见的时间复杂度

    在这里插入图片描述

    2.7 常见时间复杂度之间的关系

    在这里插入图片描述

    • 所消耗的时间从小到大
      O(1) < O(logn) < O(n) < O(nlogn) < O(n2) < O(n3) < O(2n) < O(n!) < O(nn)

    3. Python内置类型性能分析

    3.1 timeit模块
    • timeit模块可以用来测试一小段Python代码的执行速度
    • class timeit.Timer(stmt=‘pass’, setup=‘pass’, timer=)
    • Timer是测量小段代码执行速度的类
    • stmt参数是要测试的代码语句(statment)
    • setup参数是运行代码时需要的设置
    • timer参数是一个定时器函数,与平台有关。
      eg:timeit.
      Timer.timeit(number=1000000)
      Timer类中测试语句执行速度的对象方法。number参数是测试代码时的测试次数,默认为1000000次。方法返回执行代码的平均耗时,一个float类型的秒数。

    list的操作测试:

    from timeit import Timer
    
    
    def t1():
        l = []
        for i in range(1000):
            l = l + [i]
    
    
    def t2():
        l = []
        for i in range(1000):
            l.append(i)
    
    
    def t3():
        l = [i for i in range(1000)]
    
    
    def t4():
        l = list(range(1000))
    
    
    t1 = Timer("t1()", "from __main__ import t1")
    print("concat ", t1.timeit(number=100), "seconds")
    t2 = Timer("t2()", "from __main__ import t2")
    print("append ", t2.timeit(number=100), "seconds")
    t3 = Timer("t3()", "from __main__ import 3")
    print("comprehension ", t3.timeit(number=100), "seconds")
    t4 = Timer("t4()", "from __main__ import t4")
    print("list range ", t4.timeit(number=100), "seconds")
    3.2 list内置操作的时间复杂度

    在这里插入图片描述

    3.3 dict内置操作的时间复杂度

    在这里插入图片描述

    4. 数据结构

    • 数据的存储方式不同就会导致需要不同的算法进行处理。我们希望算法解决问题的效率越快越好,于是我们就需要考虑数据究竟如何保存的问题,这就是数据结构
    4.1 概念
    • 数据是一个抽象的概念,将其进行分类后得到程序设计语言中的基本类型
    • 数据元素之间不是独立的,存在特定的关系,这些关系便是结构。数据结构指数据对象中数据元素之间的关系
    • Python给我们提供了很多现成的数据结构类型,这些系统自己定义好的,不需要我们自己去定义的数据结构叫做Python的内置数据结构,比如列表、元组、字典。而有些数据组织方式,Python系统里面没有直接定义,需要我们自己去定义实现这些数据的组织方式,这些数据组织方式称之为Python的扩展数据结构,比如栈,队列等。
    4.2 算法与数据结构的区别
    • 数据结构只是静态的描述了数据元素之间的关系
    • 高效的程序需要在数据结构的基础上设计和选择算法
    • 程序 = 数据结构 + 算法
    • 总结:算法是为了解决实际问题而设计的,数据结构是算法需要处理的问题载体
    4.3 抽象数据类型(Abstract Data Type)
    • 指一个数学模型以及定义在此数学模型上的一组操作。即把数据类型和数据类型上的运算捆在一起,进行封装。引入抽象数据类型的目的是把数据类型的表示和数据类型上运算的实现与这些数据类型和运算在程序中的引用隔开,使它们相互独立。
      最常用的数据运算有五种:
    • 插入
    • 删除
    • 修改
    • 查找
    • 排序
    展开全文
  • 算法的五大特性 第二次尝试 算法效率衡量 执行时间反应算法效率 单靠时间值绝对可信吗? 时间复杂度与“大O记法” 如何理解“大O记法” 最坏时间复杂度 时间复杂度的几条基本计算规则 算法分析 常见时间...
  • 算法的五大特性二、算法效率衡量1.执行时间反应算法效率2.不能单靠时间衡量算法效率3.时间复杂度与“大O记法”4.如何理解“大O记法”5.最坏时间复杂度6.时间复杂度的几条基本计算规则7.常见时间复杂度三、Python内置...
  • 文章目录引入穷举法、枚举法输出结果及耗时优化算法的概念算法的五大特性算法效率衡量执行时间反应算法效率单靠时间值绝对可信吗?时间复杂度与“大O记法”时间复杂度的几条基本计算规则基本操作,即只有常数项,...
  • 引入概念引入第一次尝试算法的提出算法的五大特性第二次尝试算法效率衡量执行时间反应算法效率时间复杂度与“大O记法”如何理解“大O记法”最坏时间复杂度时间复杂度的几条基本计算规则算法分析常见时间复杂度常见...
  • 算法 时间复杂度 数据结构算法的提出算法的概念算法的五大特性算法效率衡量执行时间反应算法效率时间复杂度与“大O记法”最坏时间复杂度时间复杂度的几条基本计算规则常见时间复杂度Python内置类型性能分析timeit...
  • Python数据结构与算法算法引入概念第一次尝试算法概念的提出算法的五大特性第二次尝试第一次尝试和第二次尝试的算法分析算法效率衡量执行时间反应算法效率单靠时间值绝对可信吗?时间复杂度与“大O记法”如何理解...
  • pyhton数据结构与算法——基础概念算法的概念算法的五大特性算法效率衡量执行时间反应算法效率时间复杂度与“大O记法”如何理解“大O记法”最坏时间复杂度时间复杂度的几条基本计算规则常见时间复杂度常见时间复杂度...
  • (1)功率式:输出转矩较,能直接带动较负载(一般使用反应式、混合式步进电机)。 (2)伺服式:输出转矩较小,只能带动较小负载(一般使用永磁式、混合式步进电机)。 7、步进电机的选择: (1)首先选择...
  • 挖0day 高清扫描版

    2018-06-30 10:52:42
    让读者能够真正学习到软件安全漏洞挖掘的精髓,面对一个新的软件能够马上反应出从哪里入手分析出软件安全漏洞。另外,本书将大量的具体案例结合其中,目的就是能够让读者进行实际动手操作,达到学与用相结合的良好...
  • (1)功率式:输出转矩较,能直接带动较负载(一般使用反应式、混合式步进电机)。 (2)伺服式:输出转矩较小,只能带动较小负载(一般使用永磁式、混合式步进电机)。 7、步进电机的选择: (1)首先选择...
  • 十、网狐荣耀版手机端分享时出现“由于不支持的分享类型,无法分享到微信“的解决办法 去腾讯开放平台申请账号,审核通过后,在开放平台添加相应信息,就可以正常分享了。 十一、网狐荣耀版vs生成解决方案时出现...
  • 本书分五大部分全面讲解ActionScript 3.0动画。第一部分介绍了ActionScript动画基础,包括ActionScript 3.0基本知识和渲染技术等。第二部分和第三部分集中讲述了制作动画涉及的基本运动和高级运动,如速度和加速度、...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    在较的公司,为自有品牌或者其他品牌设计手机或者平板电脑的总体方案。 根据需求对系统进行定制外,为系统编写定制的应用。 第二类开发者 在创业型公司或者是独立开发者,盈利方式主要2种: 为国外公司外包开发,...
  • Thinking.In.Java

    2012-03-21 22:35:53
    基本数据类型和数组的一个介绍;作用域以及垃圾收集器清除对象的方式;如何将Java中的所有东西都归为一种新数据类型(类),以及如何创建自己的类;函数、自变量以及返回值;名字的可见度以及使用来自其他库的组件...
  • 16.1.2 习惯:知彼解己 409 16.1.3 习惯六:统合综效 409 16.1.4 习惯七:不断更新 410 16.1.5 总图 410 16.2 和老板的关系 411 16.2.1 给你的老板分个类 411 16.2.2 老板的话必须要听 417 16.2.3 老板的话要听懂 ...
  • 电影数据分析.docx

    2019-12-16 09:38:23
    6. 前五大电影类型分别是动作片Action,喜剧片Comedy,动画片Animation,剧情片Drama,冒险片Adventure。1995年之前,动作片和喜剧片都是影院观众最喜爱的电影类型,对应的高票房数量不分伯仲,剧情片是另一相对流行...
  • 在新的编程思想中,指针基本上被禁止使用(JAVA中就是这样),至少也是被限制使用。而在我们交换机的程序中大量使用指针,并且有增无减。 2、防止指针/数组操作越界 【案例1.2.1】 在香港项目测试中,发现ISDN话机...
  • 软件工程需求文档

    2015-11-01 00:05:13
    院 系:软 件 学 院 实验课程:软件工程 实验项目:《餐饮管理系统》需求分析说明书 指导老师:庞雄文 开课时间:2012 ~ 2013年度第 1学期 专 业:软件工程(数字媒体) 班 级:2010级7,8班 ...
  • 操作系统重点

    2013-01-15 16:59:50
     操作系统的五大主要功能:存储管理、进程和处理机管理、文件管理、设备管理、用户接口管理。  【理解】  1.操作系统的特征:并发、共享和异步性。  理解模拟:并发——“大家都前进了”;  共享——“一件东西...
  • 主板检测卡代码表

    2011-09-11 20:26:32
    4、对于不同BIOS(常用的AMI、Award、Phoenix)用同一代码所代表的意义有所不同,因此应弄清您所检测的电脑是属于哪一种类型的BIOS,您可查问你的电脑使用手册,或从主板上的BIOS芯片上直接查看,也可以在启动屏幕...
  • 操作系统的五大类型是批处理操作系统、分时操作系统、实时操作系统、网络操作系统、分布式操作系统。 多道程序设计:即在系统内(内存)同时存放并运行几道相互独立的程序。 多道程序设计的基础:是将...
  • 第15章 反应能力 面试题1:下水道的井盖 面试题2:30秒答题 面试题3:一分钟答题 面试题4:镜子中的你 面试题5:埃及古币 面试题6:投硬币 面试题7:他在撒谎吗 面试题8:制造零件 面试题9:不喜欢正方形窗户的人 ...

空空如也

空空如也

1 2 3 4
收藏数 61
精华内容 24
关键字:

五大基本反应类型