精华内容
下载资源
问答
  • 什么是算法

    万次阅读 多人点赞 2016-12-14 10:55:04
    什么是算法 1、什么是算法 算法(algorithm):就是定义良好的计算过程,他取一个或一组的值为输入,并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤,用来将输入数据转化成输出结果。 mark:我们...

    1、什么是算法

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

    mark:我们可以把所有的算法想象为一本“菜谱”,特定的算法比如菜谱中的的一道“老醋花生米”的制作流程,只要按照菜谱的要求制作老醋花生米,那么谁都可以做出一道好吃的老醋花生米。so,这个做菜的步骤就可以理解为:“解决问题的步骤”

    2、算法的意义

    假设计算机无限快,并且计算机存储容器是免费的,我们还需要各种乱七八糟的算法吗?如果计算机无限快,那么对于某一个问题来说,任何一个都可以解决他的正确方法都可以的!

    当然,计算机可以做到很快,但是不能做到无限快,存储也可以很便宜但是不能做到免费。

    那么问题就来了效率:解决同一个问题的各种不同算法的效率常常相差非常大,这种效率上的差距的影响往往比硬件和软件方面的差距还要大。

    3、如何选择算法

    第一首先要保证算法的正确性

    一个算法对其每一个输入的实例,都能输出正确的结果并停止,则称它是正确的,我们说一个正确的算法解决了给定的计算问题。不正确的算法对于某些输入来说,可能根本不会停止,或者停止时给出的不是预期的结果。然而,与人们对不正确算法的看法想反,如果这些算法的错误率可以得到控制的话,它们有时候也是有用的。但是一般而言,我们还是仅关注正确的算法!

    第二分析算法的时间复杂度

    算法的时间复杂度反映了程序执行时间随输入规模增长而增长的量级,在很大程度上能很好反映出算法的好坏。

    时间复杂度

    1、什么是时间复杂度

    一个算法花费的时间与算法中语句的执行次数成正比例,哪个算法中语句执行次数多,它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)
    一般情况下,算法中基本操作重复执行的次数是问题规模n的某个函数,用T(n)表示,若有某个辅助函数f(n),使得当n趋近于无穷大时,T(n)/f(n)的极限值为不等于零的常数,则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度,简称时间复杂度。

    2、时间复杂度的计算方法

    一个算法执行所耗费的时间,从理论上是不能算出来的,必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试因为该方法有两个缺陷:

    • 想要对设计的算法的运行性能进行测评,必须先依据算法编写相应的程序并实际运行。
    • 所得时间的统计计算依赖于计算机的硬件、软件等环境因素,有时候容易掩盖算法的本身优势。

    所以只需知道哪个算法花费的时间多,哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例,哪个算法中语句执行次数多,它花费时间就多。

     

    一般情况下,算法的基本操作重复执行的次数是模块n的某一个函数f(n),因此,算法的时间复杂度记做:T(n)=O(f(n))。随着模块n的增大,算法执行的时间的增长率和f(n)的增长率成正比,所以f(n)越小,算法的时间复杂度越低,算法的效率越高。 

     在计算时间复杂度的时候,先找出算法的基本操作,然后根据相应的各语句确定它的执行次数,再找出T(n)的同数量级(它的同数量级有以下:1,Log2n ,n ,nLog2n ,n的平方,n的三次方,2的n次方,n!),找出后,f(n)=该数量级,若T(n)/f(n)求极限可得到一常数c,则时间复杂度T(n)=O(f(n))。

    3、常见的时间复杂度

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

    Ο(1)<Ο(log2n)<Ο(n)<Ο(nlog2n)<Ο(n2)<Ο(n3)<…<Ο(2n)<Ο(n!)

     求解算法的时间复杂度的具体步骤:

    • 找出算法中的基本语句,算法中执行最多的那条语句是基本语句,通常是最内层循环的循环体。
    • 计算基本语句的执行次数的量级,保证最高次幂正确即可查看他的增长率。
    • 用大O几号表示算法的时间性能

     如果算法中包含镶套的循环,则基本语句通常是最内层的循环体,如果算法中包并列的循环,则将并列的循环时间复杂度相加,例如:

    复制代码
    #!/usr/bin/env python
    #-*- coding:utf-8 -*-
    __author__ = 'luotianshuai'
    
    n = 100
    
    for i in range(n):
        print(i)
    
    
    for i in range(n): ##每循i里的一个元素,for循环内部嵌套的for循环就整个循环一次
        for q in range(n):
            print(q)
    复制代码

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

    Ο(1)表示基本语句的执行次数是一个常数,一般来说,只要算法中不存在循环语句,其时间复杂度就是Ο(1)。

    其中Ο(log2n)、Ο(n)、 Ο(nlog2n)、Ο(n2)和Ο(n3)称为多项式时间,而Ο(2n)和Ο(n!)称为指数时间,计算机科学家普遍认为前者(即多项式时间复杂度的算法)是有效算法,把这类问题称为P(Polynomial,多项式)类问题,而把后者(即指数时间复杂度的算法)称为NP(Non-Deterministic Polynomial, 非确定多项式)问题在选择算法的时候,优先选择前者!

     

    OK我懂对于没有算法基础的同学,看起算法来也很头疼,但是这个是基础和重点,不会算法的开发不是一个合格的开发并且包括语言记得基础也是需要好好整理的!加油吧~~  咱们在一起看下时间复杂度的详细说明吧

    常见的时间复杂度示例

    1、O(1)

    #O(1)
    
    n = 100 
    sum = (1+n) * n/2 #执行一次
    sum_1 = (n/2) - 10 #执行一次
    sum_2 = n*4 - 10 + 8 /2 #执行一次

    这个算法的运行次数函数是f(n)=3。根据我们推导大O阶的方法,第一步就是把常数项3改为1。在保留最高阶项时发现,它根本没有最高阶项,所以这个算法的时间复杂度为O(1)。

    并且:如果算法的执行时间不随着问题规模n的增长而增加,及时算法中有上千条语句,其执行的时间也不过是一个较大的常数。此类算法的时间复杂度记作O(1)

    2、O(n2)

    n = 100 
    
    for i in range(n): #执行了n次
        for q in range(n): #执行了n2
            print(q) #执行了n2

    解:T(n)=2n2+n+1=O(n2)

    一般情况下,对进循环语句只需考虑循环体中语句的执行次数,忽略该语句中步长加1、终值判别、控制转移等成分当有若干个循环语句时,算法的时间复杂度是由嵌套层数最多的循环语句中最内层语句的频度f(n)决定的。  

    3、O(n)   

    复制代码
    #O(n)
    
    n =100 
    a = 0 #执行一次
    b = 1#执行一次
    for i in range(n): #执行n次
        s = a +b #执行n-1次
        b =a #执行n-1次
        a =s #执行n-1次
    复制代码

    解:T(n)=2+n+3(n-1)=4n-1=O(n)

    4、Ο(n3)

    #O(n3)
    n = 100
    for i in range(n):#执行了n次
        for q in range(n):#执行了n^2
            for e in range(n):#执行了n^3
                print(e)#执行了n^3

    简单点来去最大值是:Ο(n3)

    5、常用的算法的时间复杂度和空间复杂度

    排序法 平均时间 最差情况 稳定度 额外空间 备注
    冒泡排序 Ο(n2) Ο(n2) 稳定 O(1) n小时较好
    交换排序 Ο(n2) Ο(n2) 不稳定 O(1) n小时较好
    选择排序 Ο(n2) Ο(n2) 不稳定 O(1) n小时较好
    插入排序 Ο(n2) Ο(n2) 稳定 O(1) 大部分已排序时较好
    快速排序 Ο(nlogn) Ο(n2) 不稳定 Ο(nlogn) n较大时较好
    希尔排序(SHELL) Ο(log2n) Ο(ns)  1<s<2
    不稳定 O(1) s是所选分组
    归并排序 Ο(log2n) Ο(log2n) 稳定 O(1) n大时较好
    堆排序 Ο(log2n) Ο(log2n) 不稳定 O(1) n大时较好
    基数排序 Ο(logRB) Ο(logRB) 稳定 O(N)

    B是真数(0-9)

    R是基数(个十百)

     

     

     

     

     

     

     

     

     

     

     

    排序实例

    排序算法是在更复杂的算法中的是一个构建基础,所以先看下常用的排序。

    1、冒泡排序

    需求:

    请按照从小到大对列表,进行排序==》:[69, 471, 106, 66, 149, 983, 160, 57, 792, 489, 764, 589, 909, 535, 972, 188, 866, 56, 243, 619] 

    思路:相邻两个值进行比较,将较大的值放在右侧,依次比较!

    原理图:

    原理分析:

    列表中有5个元素两两进行比较,如果左边的值比右边的值大,就用中间值进行循环替换!
    既然这样,我们还可以用一个循环把上面的循环进行在次循环,用表达式构造出内部循环!

    代码实现:

    复制代码
    #!/usr/bin/env python
    #-*- coding:utf-8 -*-
    __author__ = 'luotianshuai'
    import random
    
    maopao_list = [13, 22, 6, 99, 11]
    '''
    原理分析:
    列表中有5个元素两两进行比较,如果左边的值比右边的值大,就用中间值进行循环替换!
    既然这样,我们还可以用一个循环把上面的循环进行在次循环,用表达式构造出内部循环!
    '''
    
    def handler(array):
        for i in range(len(array)):
            for j in range(len(array)-1-i):
                '''
                这里为什么要减1,我们看下如果里面有5个元素我们需要循环几次?最后一个值和谁对比呢?对吧!所以需要减1
                这里为什么减i?,这个i是循环的下标,如果我们循环了一次之后最后一只值已经是最大的了还有必要再进行一次对比吗?没有必要~
                '''
                print('left:%d' % array[j],'right:%d' % array[j+1])
                if array[j] > array[j+1]:
                    tmp = array[j]
                    array[j] = array[j+1]
                    array[j+1] = tmp
    
    
    
    if __name__ == '__main__':
        handler(maopao_list)
        print(maopao_list)
    复制代码

    时间复杂度说明看下他的代码复杂度会随着N的增大而成指数型增长,并且根据判断他时间复杂度为Ο(n2)

    2、选择排序

    需求:

    请按照从小到大对列表,进行排序==》:[69, 471, 106, 66, 149, 983, 160, 57, 792, 489, 764, 589, 909, 535, 972, 188, 866, 56, 243, 619] 

    思路:

    第一次,从列表最左边开始元素为array[0],往右循环,从右边元素中找到小于array[0]的元素进行交换,直到右边循环完之后。

    第二次,左边第一个元素现在是最小的了,就从array[1],和剩下的array[1:-1]内进行对比,依次进行对比!

    对比:

    他和冒泡排序的区别就是,冒泡排序是相邻的两两做对比,但是选择排序是左侧的“对比元素”和右侧的列表内值做对比!

    原理图:

    代码实现:

    复制代码
    #!/usr/bin/env python
    #-*- coding:utf-8 -*-
    __author__ = 'luotianshuai'
    
    
    xuanze_list = [13, 22, 6, 99, 11]
    
    print(range(len(xuanze_list)))
    
    def handler(array):
        for i in range(len(array)):
            '''
            循环整个列表
            '''
            for j in range(i,len(array)):
                '''
                这里的小循环里,循环也是整个列表但是他的起始值是i,当这一个小循环完了之后最前面的肯定是已经排序好的
                第二次的时候这个值是循环的第几次的值比如第二次是1,那么循环的起始值就是array[1]
                '''
                if array[i] > array[j]:
                    temp = array[i]
                    array[i] = array[j]
                    array[j] = temp
            # print(array)
    
    
    if __name__ == '__main__':
        handler(xuanze_list)
        print(xuanze_list)
    复制代码

    选择排序代码优化:

    复制代码
    #!/usr/bin/env python
    #-*- coding:utf-8 -*-
    __author__ = 'luotianshuai'
    
    import random
    import time
    
    
    def handler(array):
        for i in range(len(array)):
            smallest_index = i  #假设默认第一个值最小
            for j in range(i,len(array)):
                if array[smallest_index] > array[j]:
                    smallest_index = j  #如果找到更小的,记录更小元素的下标
            '''
            小的循环结束后在交换,这样整个小循环就之前的选择排序来说,少了很多的替换过程,就只替换了一次!提升了速度
            '''
            tmp = array[i]
            array[i] = array[smallest_index]
            array[smallest_index] = tmp
    
    
    if __name__ == '__main__':
        array = []
        old_time = time.time()
        for i in range(50000):
            array.append(random.randrange(1000000))
        handler(array)
        print(array)
        print('Cost time is :',time.time() - old_time)
    复制代码

    3、插入排序

    需求

    请按照从小到大对列表,进行排序==》:[69, 471, 106, 66, 149, 983, 160, 57, 792, 489, 764, 589, 909, 535, 972, 188, 866, 56, 243, 619] 

    思路:

    一个列表默认分为左侧为排序好的,我们拿第一个元素举例,他左边的全是排序好的,他右侧是没有排序好的,如果右侧的元素小于左侧排序好的列表的元素就把他插入到合适的位置

    原理图:

     

    代码实现:

    复制代码
    #!/usr/bin/env python
    #-*- coding:utf-8 -*-
    __author__ = 'luotianshuai'
    
    
    import random
    import time
    chaoru_list = [69, 471, 106, 66, 149, 983, 160, 57, 792, 489, 764, 589, 909, 535, 972, 188, 866, 56, 243, 619]
    
    def handler(array):
        for i in range(1,len(array)):
            position = i #刚开始往左边走的第一个位置
            current_val = array[i] #先把当前值存下来
            while position > 0 and current_val < array[position -1]:
                '''
                这里为什么用while循环,咱们在判断左边的值得时候知道他有多少个值吗?不知道,所以用while循环
                什么时候停下来呢?当左边没有值得时候,或者当他大于左边的值得时候!
                '''
                array[position] = array[position - 1] #如果whille条件成立把当前的值替换为他上一个值
                '''
                比如一个列表:
                [3,2,4,1]
                现在循环到 1了,他前面的元素已经循环完了
                [2,3,4] 1
    
                首先我们记录下当前这个position的值 = 1
                [2,3,4,4] 这样,就出一个位置了
                在对比前面的3,1比3小
                [2,3,3,4] 在替换一下他们的值
                 在对比2
                [2,2,3,4]
                最后while不执行了在进行替换'array[position] = current_val  #把值替换'
                '''
                position -= 1
            #当上面的条件都不成立的时候{左边没有值/左边的值不比自己的值小}
            array[position] = current_val  #把值替换
    
    
    if __name__ == '__main__':
        handler(chaoru_list)
        print(chaoru_list)
    
    '''
        array = []#[69, 471, 106, 66, 149, 983, 160, 57, 792, 489, 764, 589, 909, 535, 972, 188, 866, 56, 243, 619]
        old_time = time.time()
        for i in range(50000):
            array.append(random.randrange(1000000))
        handler(array)
        print(array)
        print('Cost time is :',time.time() - old_time)
    '''
    复制代码

    4、快速排序

    设要排序的数组是A[0]……A[N-1],首先任意选取一个数据(通常选用数组的第一个数)作为关键数据,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一趟快速排序。值得注意的是,快速排序不是一种稳定的排序算法,也就是说,多个相同的值的相对位置也许会在算法结束时产生变动.他的时间复杂度是:O(nlogn) ~Ο(n2)

    排序示例:

    假设用户输入了如下数组:

    创建变量i=0(指向第一个数据)[i所在位置红色小旗子], j=5(指向最后一个数据)[j所在位置蓝色小旗子], k=6(赋值为第一个数据的值)。

    我们要把所有比k小的数移动到k的左面,所以我们可以开始寻找比6小的数,从j开始,从右往左找,不断递减变量j的值,我们找到第一个下标3的数据比6小,于是把数据3移到下标0的位置,把下标0的数据6移到下标3,完成第一次比较:

    i=0 j=3 k=6

    接着,开始第二次比较,这次要变成找比k大的了,而且要从前往后找了。递加变量i,发现下标2的数据是第一个比k大的,于是用下标2的数据7和j指向的下标3的数据的6做交换,数据状态变成下表:

     i=2 j=3 k=6

    称上面两次比较为一个循环。
    接着,再递减变量j,不断重复进行上面的循环比较。
    在本例中,我们进行一次循环,就发现i和j“碰头”了:他们都指向了下标2。于是,第一遍比较结束。得到结果如下,凡是k(=6)左边的数都比它小,凡是k右边的数都比它大:

    如果i和j没有碰头的话,就递加i找大的,还没有,就再递减j找小的,如此反复,不断循环。注意判断和寻找是同时进行的。

    然后,对k两边的数据,再分组分别进行上述的过程,直到不能再分组为止。
    注意:第一遍快速排序不会直接得到最终结果,只会把比k大和比k小的数分到k的两边。为了得到最后结果,需要再次对下标2两边的数组分别执行此步骤,然后再分解数组,直到数组不能再分解为止(只有一个数据),才能得到正确结果。

    代码实现:

    复制代码
    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    # Author:luotianshuai
    import random
    import time
    
    def quick_sort(array,start,end):
        if start >= end:
            return
        k = array[start]
        left_flag = start
        right_flag = end
        while left_flag < right_flag:
            '''
            left_flag = start 默认为0
            right_flag = end 默认为传来的列表总长度
            当left_flag 小与right_flag的时候成立,说明左右两边的小旗子还没有碰头(为相同的值)
            '''
            #右边旗子
            while left_flag < right_flag and array[right_flag] > k:#代表要继续往左一移动小旗子
                right_flag -= 1
            '''
            如果上面的循环停止说明找到右边比左边的值小的数了,需要进行替换
            '''
            tmp = array[left_flag]
            array[left_flag] = array[right_flag]
            array[right_flag] = tmp
    
            #左边旗子
            while left_flag < right_flag and array[left_flag] <= k:
                #如果没有找到比当前的值大的,left_flag 就+=1
                left_flag += 1
            '''
            如果上面的循环停止说明找到当前段左边比右边大的值,进行替换
            '''
            tmp = array[left_flag]
            array[left_flag] = array[right_flag]
            array[right_flag] = tmp
    
        #进行递归把问题分半
        quick_sort(array,start,left_flag-1)
        quick_sort(array,left_flag+1,end)
    
    if __name__ == '__main__':
        array = []  # [69, 471, 106, 66, 149, 983, 160, 57, 792, 489, 764, 589, 909, 535, 972, 188, 866, 56, 243, 619]
        start_time = time.time()
        for i in range(50000):
            array.append(random.randrange(1000000))
        quick_sort(array,0,len(array)-1)
        end_time = time.time()
        print(array)
        print(start_time,end_time)
        cost_time = end_time - start_time
        print('Cost time is :%d' % cost_time)
    复制代码

     

    展开全文
  • 什么是数据结构?什么是算法

    万次阅读 多人点赞 2018-05-04 00:35:22
    什么是算法? 呃呃呃呃 哎….不会。 多次参加了MOOC姥姥的数据结构,都没有坚持下来,希望这次可以坚持下来。 引用姥姥的例子:如果给你一堆书你会怎么放? 想怎么放就怎么放,哈哈。 如果书不多,我们一般是...

    记得是大一大二的时候学习了数据结构。时间过的好快,现在实现了,现在感觉自己的基础好差很多都不会。欠的帐还是要还的!

    什么是数据结构?什么是算法?

    呃呃呃呃 哎….不会。

    多次参加了MOOC姥姥的数据结构,都没有坚持下来,希望这次可以坚持下来。

    引用姥姥的例子:如果给你一堆书你会怎么放?

    想怎么放就怎么放,哈哈。

    如果书不多,我们一般是一本插着一本的放着。如下图

    要是书的规模很大呢?如学校图书馆里面的书如果是按上述一本一本的插入,那么以后需要找书的时候是不是累死人了。如下图

    所以答案是看书的规模。


    什么是数据结构?

    数据是什么?结构是什么?

    参考大话数据结构,几个术语的定义

    数据:是描述客观事物的符号,是计算机中可以操作的对象,是能被计算机识别,并输入给计算机处理的符号集合

    其实就是图书馆中所有的书。

    数据元素:是组成数据的、有一定意义的基本单位,在计算机中通常作为整体处理。也被称为记录。

    就是书。

    数据项:一个数据元素可以由若干个数据项组成。

    其实就是书名、作者、出版社啥的….

    class Book {
    //书名
    private String bookName;
    //作者
    private String bookAuthor;
    //出版社
    private String bookPress;
    }
    

    其实一个Book对象就是数据元素,bookName、bookAuthor、bookPress就是数据项。

    数据对象:是性质相同的数据元素的集合,是数据的子集。

    其实就是某一类书。如图下图都是数据结构一类的书

    是不是明白了什么是数据?哈哈 还是需要结合例子理解的深入啊。

    什么是结构?

    逻辑结构、物理结构。

    逻辑结构:是指数据对象中数据元素之间的相互关系。包括集合结构、线性结构、树形结构、图形结构。

    集合结构:集合结构中的数据元素除了同属于一个集合外,它们之间没有其它关系。

    线性结构:线性结构中的数据之间是一对一的关系。

    树形结构:树形结构中的数据之间存在一种一对多的层次关系。

    图形结构:图形结构的数据元素是多对多的关系。


    物理结构:是指数据的逻辑结构在计算机中的存储形式。顺序存储和链式存储。

    顺序存储:是把数据元素存放在地址连续的存储单元里。

    链式存储:是把数据元素存放在任意的存储单元里,这组存储单元可以是连续的,也可以是不连续的。


    什么是数据结构?

    Sartaj Sahni在他的《数据结构、算法与应用》一书中称:“数据结构是数据对象,以及存在于该对象的实例合组成实例的数据元素之间的各种联系。这些联系可以通过定义相关的函数来给出。”他将数据对象(data object)定义为“一个数据对象是实例或值的集合”。

    Clifford A.Shaffer在《数据结构与算法分析》一书中的定义是:“数据结构是 ADT(抽象数据类型Abstract Data Type) 的物理实现。”

    大话数据结构:数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

    姥姥:数据结构包括数据对象集以及它们在计算机中的组织方式,即它们的逻辑结构和物理存储结构,同时还包括与数据对象集相关的操作集,以及实现这些操作的最高效的算法。

    个人:就是把图书馆中的书转化为一些字符数据存入电脑中,以及对这些数据对象集的操作。如找书,摆放放书等。


    什么是算法?

    还是图书馆的例子,如果一本一本找累死人,要是有个索引,先找哪一类这样会快很多。如何查找其实就是算法。

    算法是解决问题步骤的有限集合,通常用某一种计算机语言进行伪码描述。通常用时间复杂度和空间复杂度来衡量算法的优劣。

    算法的五大特征:输入、输出、有穷性、确定性、可行性。

    输入:零个或多个输入。

    输出:一个或多个输出。

    有穷性:有限步骤后在可接受时间内完成。

    确定性:每个步骤都有确定含义,无二义性。

    可行性:每一步都是可行的。

    算法设计要求:正确性、可读性、健壮性、时间效率高和存储低。

    正确性:有输入输出,无二义性,有正确答案。

    可读性:方便阅读。

    健壮性:输入不合法能处理

    时间效率高和存储低:时间空间复杂度越低越好。


    这就是数据结构和算法。

    展开全文
  • 什么是算法,算法有哪些特征?

    千次阅读 2019-11-11 07:44:45
    什么是算法,算法有哪些特征? 算法定义:为解决一个问题而采取的方法和步骤,称为“算法”。 算法五大特征: ①有穷性 ②确定性 ③有零个或多个输入 ④有一个或多个输出 ⑤有效性 ...

    什么是算法,算法有哪些特征?

    算法定义:为解决一个问题而采取的方法和步骤,称为“算法”。

    算法五大特征:

    ①有穷性

    ②确定性

    ③有零个或多个输入

    ④有一个或多个输出

    ⑤有效性

    展开全文
  • 它们是算法开始运算前给予算法的量。这些输入取自于特定的对象的集合。它们可以使用输入语句由外部提供,也可以使用赋值语句在算法内给定。② 有输出。一个算法应有一个或多个输出,输出的量是算法计算的结果。③ ...

    算法的定义

    通常,定义算法为"为解决某一特定任务而规定的一个指令序列"

    算法的5个基本特性

    ① 有输入。一个算法必须有0个或多个输入。它们是算法开始运算前给予算法的量。这些输入取自于特定的对象的集合。它们可以使用输入语句由外部提供,也可以使用赋值语句在算法内给定。

    ② 有输出。一个算法应有一个或多个输出,输出的量是算法计算的结果。

    ③ 确定性。算法的每一步都应确切地、无歧义地定义。对于每一种情况,需要执行的动作都应严格地、清晰地规定。

    例1:

    void fa( )
    { 
    	int x=5,y=10; 
    	z=x+++y;//解释为:x+(++y)?(x++)+y?
    	printf("%d,%d,%d",x,y,z);
    }
    void fb( )
    { 
    	int x=5,y=10;
    	z=x+(++y); //x+++y解释为:x+(++y)
    	printf("%d,%d,%d",x,y,z);
    }
    void fc( )
    {
    	int x=5,y=10;
    	z=(x++)+y;	//x+++y解释为:(x++)+y
    	printf("%d,%d,%d",x,y,z);
    }

     有穷性。一个算法无论在什么情况下都应在执行有穷步后结束。

    例2:

    void fa(  )
    {
          int i=0,s=0;
          while(i<10) //死循环
              s++;        //不满足有穷性
          i++;
          printf(“s=%d,i=%d\n“,s,i);
    }
    void fb(  )
    {
          int i=0,s=0;
          while(i<10) //i<10执行多少次
          {
              s++;  //s++执行?次
              i++; // i++ 执行?次
          }
          printf(“s=%d,i=%d\n“,s,i); 
    }

     有效性。算法中每一条运算都必须是足够基本的。就是说,它们原则上都能精确地执行,甚至人们仅用笔和纸做有限次运算就能完成。

    例3:

    求和:S=1+2+3+...+∽   //不可以实现。

    算法设计的要求

    1)正确性

           a.无语法错误;

           b.对n组输入产生正确结果;

           c.对特殊输入产生正确结果;

           d.对所有输入产生正确结果。

    2)可读性:算法主要是为了人的阅读与交流

    3)健壮性

    4)高效与低存储量


    来源:我是码农,转载请保留出处和链接!

    本文链接:http://www.54manong.com/?id=16

    '); (window.slotbydup = window.slotbydup || []).push({ id: "u3646208", container: s }); })();
    '); (window.slotbydup = window.slotbydup || []).push({ id: "u3646147", container: s }); })();
    展开全文
  • 什么是算法分析

    千次阅读 2018-03-10 14:45:47
    第一:数据越多意味着程序...第四:平方算法对输入规模超过几千不可行的。第五:立方算法对输入规模几百不可行的。第六:按增长率升序排列的函数(常数、对数、对数的平方、线性、NlogN、平方、立方、指数)。...
  • 我个人觉得算法里面极大一部分内容如何有效地进行搜索,这里的”有效”可以分为:避免不必要的计算(如A*寻路以及所有的启发式剪枝),缓存重复计算(如所有­的动态规划)。当然,知道这些跟具体的设计出一个算法...
  • 算法初步--什么是算法

    千次阅读 2012-11-15 20:36:42
     “算法一系列解决问题的清晰指令。也就是说,对于符合一定规范的输入,能够在有限时间内获得所要求的输出。如图:    可以认为算法是问题的程序化解决方案。这些解决方案就是上面说的清晰精确指令。那么...
  • 什么是算法的复杂度?

    千次阅读 2016-04-06 17:52:39
    算法复杂度分为**看到一篇比较好的文章,最近比较忙,所以比较少上QQ和博客了,sz-绵羊。...时间复杂度指执行算法所需要的计算工作量。 重点在其计算方法: 一个算法中的语句执行次数称为**语句频度或时间频度**。
  • 有趣的算法世界---什么是算法

    千次阅读 2003-06-23 08:12:00
    什么是算法? 如果您想进入这个世界的话,您就不应该不知道,这个美丽的世界,她究竟是什么? 什么是算法?是呀,这是个问题。它的意义,可比于那个“To be,or not to be”,如果我们也如哈姆雷特般的徘徊起来:...
  • 一开始就来一些概念性的东西,其实并不是让人接受的方法...算法与数据结构就是这样一门科学,光看当时看懂了,可是有用吗,有,不过当下,之后你就会忘得一干二净,怎么办呢,不要只是看,真的不要只是看,我现在很
  •  算法(Algorithm)指解题方案的准确而完整的描述,一系列解决问题的清晰指令,算法代表着用系统的方法描述解决问题的策略机制。也就是说,能够对一定规范的输入,在有限时间内获得所要求的输出。如果一个算法...
  • 苏联哲学百科:什么是算法?

    千次阅读 2007-02-04 20:56:00
    算法是逻辑学和数学的基本概念之一。  不能把上述“计算”过程狭义地理解为数字的计算。例如,中学的代数就已经有字母的计算,如 (x+y)*(x-y)=x*x-y*y( 虽然这里的字母还只起替代数字的作用 ) ;就在算术的计算中...
  • 对于编程了解较少,只能用c++磕磕盼盼实现自己的想法,没有做过正规的一个软件项目研发,现在老板说让我想一下用什么来实现算法引擎,听他的意思应该是做一个东西来调用我的算法,但是对什么是算法引擎,我脑子里...
  • 什么是共识算法

    万次阅读 多人点赞 2019-04-05 10:28:26
    什么是共识算法 著名的共识设计理论 经典的共识算法设计 什么是共识算法 背景 分布式系统集群设计中面临着一个不可回避的问题,一致性问题 对于系统中的多个服务节点,给定一系列操作,如何试图使全局对局部...
  • 什么是SM2算法

    千次阅读 2019-03-25 19:29:53
    什么是SM2算法 - weixin_39466605的博客 - CSDN博客 https://blog.csdn.net/weixin_39466605/article/details/80222969 SM2算法是一种新的国产非对称算法,相对于RSA算法,它更先进。基于国家商业密码安全等原因,...
  • 什么是哈希算法

    千次阅读 2018-05-07 18:27:19
    什么是hash函数? 常见的hash算法 hashlib的用法 hash算法的用途 什么是hash函数? 哈希函数,又称哈希算法,它通过一个函数,把任意长度的数据转换为一个长度固定的数据串(通常用16进制的字符串表示)。 ...
  • 随机化算法是一种在算法中使用了随机函数,且随机函数的返回值直接或间接的影响了算法的执行流程或执行结果。而确定性算法是与随机化算法相对来说的。 PCA:组成分分析,常见的降维方法,确定性算法,第一次...
  • 什么是KNN算法

    万次阅读 多人点赞 2018-09-27 10:19:25
    KNN(K-Nearest Neighbor)算法是机器学习算法中最基础、最简单的算法之一。它既能用于分类,也能用于回归。KNN通过测量不同特征值之间的距离来进行分类。 KNN算法的思想非常简单:对于任意n维输入向量,分别对应于...
  • 智能算法是什么

    万次阅读 2019-06-29 22:29:44
    “智能算法指在工程实践中,经常会接触到一些比较“新颖”的算法或理论,比如模拟退火,遗传算法,禁忌搜索,神经网络,天牛须搜索算法等。这些算法或理论都有一些共同的特性(比如模拟自然过程。它们在解决一些...
  • 什么是算法? 在计算机领域中,算法是一系列的程序指令,用于处理特定的运算和逻辑问题. 衡量算法的好坏主要的指标是时间复杂度和空间复杂度 二 怎么衡量算法的优劣? 2.1时间复杂度 时间复杂度可以理解为,算法执行...
  • 什么是KMP算法

    千次阅读 2020-09-18 09:31:26
    ————— 第二天 ————— ———————————— 前情回顾 在字符串匹配算法的前两讲,...BF算法是如何工作的? 正如同它的全称BruteForce一样,BF算法使用简单粗暴的方式,对主串和模式串进行逐个..
  • 什么是AES算法

    千次阅读 2019-07-09 14:49:00
    什么是AES算法?        今天偶然看到一篇关于AES算法的通俗解释,特意介绍给大家
  • 什么是Base64算法

    万次阅读 多人点赞 2018-03-15 20:31:20
    A:为什么在进行Http传输的时候,需要把Byte数组进行Base64编码呢? B:这很简单呀,因为Http协议文本协议,不同于二进制协议(如Thrift)...B:首先,Base64一种编码算法。为什么叫左Base64呢?因为这种算法只支...
  • 什么是遗传算法

    千次阅读 2016-11-28 17:53:01
    本文从遗传算法的生物学基础讲起,详细介绍了遗传算法的原理、步骤和简单应用。
  • 什么是哈希算法

    万次阅读 多人点赞 2018-12-03 10:39:31
    哈希算法的基本含义    哈希密码学的基础,理解哈希理解数字签名和加密通信等技术的必要前提。    哈希,英文 hash ,本来意思”切碎并搅拌“,有一种食物就叫 Hash ,就是把食材切碎并搅拌一下做成...
  • 什么是控制算法

    千次阅读 多人点赞 2018-05-22 20:15:00
    商业转载请联系作者获得授权,非商业转载请注明出处。 本人大学和研究生学的控制,大学做的飞思卡尔智能车,毕业后做...先回答问题,我所看到的,最惊艳的控制算法就是PI控制器,没有之一,简约极致之美。下面慢...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 98,668
精华内容 39,467
关键字:

什么是算法