python小白-day4递归和算法基础

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python小白-day4递归和算法基础相关的知识,希望对你有一定的参考价值。

递归&算法基础

一、递归

递归函数的优点是定义简单,逻辑清晰。理论上,所有的递归函数都可以写成循环的方式,但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。

1
2
3
4
5
6
7
8
def calc(n):
    print(n)
    if n/2>1:
        ret = calc(n/2)
        print(ret)
    print(‘N‘,n)
    return n
calc(10)

技术分享

二、二分法

主要使用折半查找算法和利用递归函数来实现。因为每次取中间数字后,都会产生左右两个数组,
需要使用队列把数组存起来,然后输入递归函数内计算中间数字。递归函数终止条件是:1)中间数字
与左边最小的数字相邻;2)中间数字与右边最大的数字相邻。

代码实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def binary_search(data_source,find_num):
    mid = int(len(data_source)/2)
    if len(data_source) >1:
        if data_source[mid] > find_num:
            binary_search(data_source[:mid],find_num)
            print(‘data in left of [%s]‘%data_source[mid])
        elif data_source[mid] < find_num:
            binary_search(data_source[mid:],find_num)
            print(‘data in right of [%s]‘%data_source[mid])
        else:
            print(‘found‘,data_source[mid])
    else:
        print(‘cannot found‘)
if __name__ == ‘__main__‘:
    data = list(range(1,600000))
    binary_search(data,75000)

技术分享

三、用递归实现斐波那契数列

1
2
3
4
5
6
7
8
def fun(arg0,arg1,stop):
    if arg0 == 0:
        print(arg0,arg1)
    arg2 = arg0 + arg1
    if arg2 < stop :
        print(arg2)
        fun(arg1,arg2,stop)
fun(0,1,1000)

技术分享

四、二维数组转换

需求:生成一个4*4的二维数组并将其顺时针旋转90度

核心思想:数组下标的对应关系可以一一对应转换。

1
2
3
4
5
6
7
8
9
10
11
data = [[col for col in range(4)] for row in range(4)]
for i in data:
    print(i)
for r_index,row in enumerate(data):
    for c_index in range(r_index,len(row)):
        tmp = data[c_index][r_index]
        data[c_index][r_index] = row[c_index]
        data[r_index][c_index] = tmp
print(‘--------------------‘)
for i in data:
    print(i)

技术分享

五、冒泡排序

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env python
data = [10,4,33,21,54,3,8,11,5,22,2,1,17,13,6]
for i in range(len(data)):
    for j in range(len(data)-1-i):
        if data[j] > data[j+1]:
            tmp = data[j+1]
            data[j+1] = data[j] 
            data[j] = tmp
            #data[j],data[j+1] = data[j+1],data[j] #这种方式也可以
    print(data)

技术分享

六、时间复杂度

(1)时间频度 一个算法执行所耗费的时间,从理论上是不能算出来的,必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试,只需知道哪个算法花费的时间多,哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例,哪个算法中语句执行次数多,它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
(2)时间复杂度 在刚才提到的时间频度中,n称为问题的规模,当n不断变化时,时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此,我们引入时间复杂度概念。 一般情况下,算法中基本操作重复执行的次数是问题规模n的某个函数,用T(n)表示,若有某个辅助函数f(n),使得当n趋近于无穷大时,T(n)/f(n)的极限值为不等于零的常数,则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),O(f(n)) 为算法的渐进时间复杂度,简称时间复杂度。
 
指数时间
指的是一个问题求解所需要的计算时间m(n),依输入数据的大小技术分享而呈指数成长(即输入数据的数量依线性成长,所花的时间将会以指数成长)
1
2
3
4
5
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)。

常数时间

 

若对于一个算法,技术分享的上界与输入大小无关,则称其具有常数时间,记作技术分享时间。一个例子是访问数组中的单个元素,因为访问它只需要一条指令。但是,找到无序数组中的最小元素则不是,因为这需要遍历所有元素来找出最小值。这是一项线性时间的操作,或称技术分享时间。但如果预先知道元素的数量并假设数量保持不变,则该操作也可被称为具有常数时间。

 

对数时间 

若算法的T(n) = O(log n),则称其具有对数时间

常见的具有对数时间的算法有二叉树的相关操作和二分搜索

对数时间的算法是非常有效的,因为每增加一个输入,其所需要的额外计算时间会变小。

递归地将字符串砍半并且输出是这个类别函数的一个简单例子。它需要O(log n)的时间因为每次输出之前我们都将字符串砍半。 这意味着,如果我们想增加输出的次数,我们需要将字符串长度加倍。

 

线性时间 

如果一个算法的时间复杂度为O(n),则称这个算法具有线性时间,或O(n)时间。非正式地说,这意味着对于足够大的输入,运行时间增加的大小与输入成线性关系。例如,一个计算列表所有元素的和的程序,需要的时间与列表的长度成正比。













以上是关于python小白-day4递归和算法基础的主要内容,如果未能解决你的问题,请参考以下文章

python 之day4

Python之路,Day4

Python基础篇-day4

day4-递归

python s12 day4 算法基础之二分查找

day4递归原理及实现