三种递归比较

最新推荐文章于 2022-09-03 17:08:58 发布
最新推荐文章于 2022-09-03 17:08:58 发布
阅读量261 收藏
点赞数
分类专栏： 应用 理论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjinyyzyq/article/details/90666500
版权
应用 同时被 2 个专栏收录
185 篇文章 2 订阅
订阅专栏
理论
82 篇文章 0 订阅
订阅专栏 
In [29]: import time                                                                                                                                                                                        

In [30]: def f(s): 
    ...:     new_s = [] 
    ...:     for i in s: 
    ...:         new_s.append(str(i)) 
    ...:     return new_s 
    ...: if __name__ == '__main__': 
    ...:     start = time.time() 
    ...:     m_1 = f(test_list) 
    ...:     end_1 = time.time() 
    ...:     m_2 = [str(s) for s in test_list] 
    ...:     end_2 = time.time() 
    ...:     m_3 = list(map(str, test_list)) 
    ...:     end_3 = time.time() 
    ...:     print('普通for循环：{}， 列表式递推：{}, map函数：{}' 
    ...:           .format(end_3 - end_2, end_2 - end_1, end_1 - start)) 
    ...:                                                                                                                                                                                                    
普通for循环：0.0013279914855957031， 列表式递推：0.0015621185302734375, map函数：0.0020105838775634766

In [31]: def f(s): 
    ...:     new_s = [] 
    ...:     for i in s: 
    ...:         new_s.append(str(i)) 
    ...:     return new_s 
    ...: if __name__ == '__main__': 
    ...:     start = time.time() 
    ...:     m_1 = f(test_list) 
    ...:     end_1 = time.time() 
    ...:     m_2 = [str(s) for s in test_list] 
    ...:     end_2 = time.time() 
    ...:     m_3 = list(map(str, test_list)) 
    ...:     end_3 = time.time() 
    ...:     print('普通for循环：{}， 列表式递推：{}, map函数：{}' 
    ...:           .format(end_3 - end_2, end_2 - end_1, end_1 - start)) 
    ...:                                                                                                                                                                                                    
普通for循环：0.0012891292572021484， 列表式递推：0.0015742778778076172, map函数：0.0020847320556640625

In [32]: def f(s): 
    ...:     new_s = [] 
    ...:     for i in s: 
    ...:         new_s.append(str(i)) 
    ...:     return new_s 
    ...: if __name__ == '__main__': 
    ...:     start = time.time() 
    ...:     m_1 = f(test_list) 
    ...:     end_1 = time.time() 
    ...:     m_2 = [str(s) for s in test_list] 
    ...:     end_2 = time.time() 
    ...:     m_3 = list(map(str, test_list)) 
    ...:     end_3 = time.time() 
    ...:     print('普通for循环：{}， 列表式递推：{}, map函数：{}' 
    ...:           .format(end_3 - end_2, end_2 - end_1, end_1 - start)) 
    ...:                                                                                                                                                                                                    
普通for循环：0.0012030601501464844， 列表式递推：0.0015230178833007812, map函数：0.0020287036895751953

In [33]: def f(s): 
    ...:     new_s = [] 
    ...:     for i in s: 
    ...:         new_s.append(str(i)) 
    ...:     return new_s 
    ...: if __name__ == '__main__': 
    ...:     test_list = range(1000000) 
    ...:     start = time.time() 
    ...:     m_1 = f(test_list) 
    ...:     end_1 = time.time() 
    ...:     m_2 = [str(s) for s in test_list] 
    ...:     end_2 = time.time() 
    ...:     m_3 = list(map(str, test_list)) 
    ...:     end_3 = time.time() 
    ...:     print('普通for循环：{}， 列表式递推：{}, map函数：{}' 
    ...:           .format(end_3 - end_2, end_2 - end_1, end_1 - start)) 
    ...:            
    ...:                                                                                                                                                                                                    
普通for循环：0.13965439796447754， 列表式递推：0.1729893684387207, map函数：0.21480298042297363

In [34]: def f(s): 
    ...:     new_s = [] 
    ...:     for i in s: 
    ...:         new_s.append(str(i)) 
    ...:     return new_s 
    ...: if __name__ == '__main__': 
    ...:     test_list = range(1000000) 
    ...:     start = time.time() 
    ...:     m_1 = f(test_list) 
    ...:     end_1 = time.time() 
    ...:     m_2 = [str(s) for s in test_list] 
    ...:     end_2 = time.time() 
    ...:     m_3 = map(str, test_list) 
    ...:     end_3 = time.time() 
    ...:     print('普通for循环：{}， 列表式递推：{}, map函数：{}' 
    ...:           .format(end_3 - end_2, end_2 - end_1, end_1 - start)) 
    ...:            
    ...:                                                                                                                                                                                                    
普通for循环：0.011281013488769531， 列表式递推：0.1831061840057373, map函数：0.22450542449951172

In [35]: def f(s): 
    ...:     new_s = [] 
    ...:     for i in s: 
    ...:         new_s.append(str(i)) 
    ...:     return new_s 
    ...: if __name__ == '__main__': 
    ...:     test_list = range(1000000) 
    ...:     start = time.time() 
    ...:     m_1 = f(test_list) 
    ...:     end_1 = time.time() 
    ...:     m_2 = [str(s) for s in test_list] 
    ...:     end_2 = time.time() 
    ...:     m_3 = map(str, test_list) 
    ...:     end_3 = time.time() 
    ...:     print('普通for循环：{}， 列表式递推：{}, map函数：{}' 
    ...:           .format(end_3 - end_2, end_2 - end_1, end_1 - start)) 
    ...:            
    ...:                                                                                                                                                                                                    
普通for循环：5.7220458984375e-06， 列表式递推：0.18357276916503906, map函数：0.22466301918029785

In [36]: def f(s): 
    ...:     new_s = [] 
    ...:     for i in s: 
    ...:         new_s.append(str(i)) 
    ...:     return new_s 
    ...: if __name__ == '__main__': 
    ...:     test_list = range(1000000) 
    ...:     start = time.time() 
    ...:     m_1 = f(test_list) 
    ...:     end_1 = time.time() 
    ...:     m_2 = [str(s) for s in test_list] 
    ...:     end_2 = time.time() 
    ...:     m_3 = map(str, test_list) 
    ...:     end_3 = time.time() 
    ...:     print('普通for循环：{}， 列表式递推：{}, map函数：{}' 
    ...:           .format(end_3 - end_2, end_2 - end_1, end_1 - start)) 
    ...:            
    ...:                                                                                                                                                                                                    
普通for循环：5.9604644775390625e-06， 列表式递推：0.18172597885131836, map函数：0.2219834327697754

In [37]: def f(s): 
    ...:     new_s = [] 
    ...:     for i in s: 
    ...:         new_s.append(str(i)) 
    ...:     return new_s 
    ...: if __name__ == '__main__': 
    ...:     test_list = range(100000000) 
    ...:     start = time.time() 
    ...:     m_1 = f(test_list) 
    ...:     end_1 = time.time() 
    ...:     m_2 = [str(s) for s in test_list] 
    ...:     end_2 = time.time() 
    ...:     m_3 = map(str, test_list) 
    ...:     end_3 = time.time() 
    ...:     print('普通for循环：{}， 列表式递推：{}, map函数：{}' 
    ...:           .format(end_3 - end_2, end_2 - end_1, end_1 - start)) 
    ...:            
    ...:                                                                                                                                                                                                    
普通for循环：1.4066696166992188e-05， 列表式递推：128.19690418243408, map函数：22.801581144332886
yjinyyzyq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP递归的三种常用方式
01-20
递归的三种常用技法： 静态变量、全局变量、引用 一 静态变量方式 function loop(){ static $i = 0; echo $i.' '; $i++; if($i<10){ loop(); } } loop();//输出 0 1 2 3 4 5 6 7 8 9 二 全局变量方式 $...
PHP实现递归的三种方法
10-15
主要介绍了PHP实现递归的三种方法，文中讲解非常详细，示例代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
递归和迭代的对比
qq_40893595的博客
10-08 1425
递归和迭代的对比递归迭代特点 递归 程序调用自身的编程技巧称为递归（recursion）。递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。 递归的主要思考方式在于：把大事化小 递...
递归三之：将问题分解为更小规模
weixin_44184990的博客
03-29 752
将问题分解为更小规模求解 这是我们使用递归解决比较多的一种问题了，将问题分解为更小的规模，使得更小规模的问题更容易求解，而最终问题的解又包含了比之更小规模的解。常见的比如说分治的思想。这种问题有时候可以推导出它的递归数学表达式，如果最后能够找到一个递归结束的边界条件，那么问题一般就可以解决了。 下面举几个例子进行演示。 问题1：爬楼梯 问题描述：有N个台阶，一步能走一个或两个台阶，问走完有多少总...
递归算法总结JAVA
Cheers Li 软件测试博客
03-20 1367
java递归算法总结             原文地址：http://blog.csdn.net/tomcat_2014/article/details/51113740    作者：toMatser 1.何为递归 个人理解就是自己调用自己，直到满足一个条件结束自己调用自己的过程，这个就是递归。举一个通俗的点的例子： 假设你在一个电影院，你想知道自己坐在哪一排，
递归与尾递归的对比，及尾递归的优势
friend_ship的博客
05-18 308
递归与尾递归的对比与原理
C语言：递归实现三个数比大小
倒咖啡的
11-26 815
#include<stdio.h> f(int a,int b,int c){ return (c>b)?(b>a?c:(c>a)?c:a):(c>a?b:(b>a?b:a)); } int main(){ int q,w,e; puts("输入三个数比最大"); scanf("%d%d%d",&q,&w,&e); pr...
二叉树的三种递归和非递归算法
10-23
常用的数据结构的算法，包括二叉树的三种递归和非递归算法，染色问题，八皇后问题，深度广度遍历，约瑟夫环，数值转换，树的高度和叶子节点数，最小生成树 ，两点之间的所有路径
php实现递归的三种基本方式
12-18
本文列出了三种基本方式。理解其原来需要一定的基础知识水品，包括对全局变量，引用，静态变量的理解，也需对他们的作用范围有所理解。递归函数也是解决无限级分类的一个很好地技巧。如果对无限级分类感兴趣，请参照...
Java经典算法题—用递归求最大值和最小值
一个射手座程序猿
11-27 1996
public class GetMax { /* * 用递归的思路实现一个数组的最大值 */ public static int getMax(int[] arr, int L, int R) { if (L == R) { return arr[L]; } int mid = (L + R) / 2; int maxLeft = getMax(arr, L, ...
算法之递归和循环比较
amychang230_的博客
08-14 4021
递归的缺点 首先递归实现效率不如循环。 递归由于是函数调用自身，而函数调用要消耗空间和时间，每一次调用都需要在内存栈中分配空间，来保存参数、返回地址及临时变量，并且往栈里压入数据和弹出数据都需要时间。递归中有很多计算是重复的，因此带来很大的负面影响。其本质是把一个问题分解成两个和多个小问题，如果多个小问题存在相互重叠部分，就造成重复计算。 动态规划用递归分析问题，但由于递归分解的子问题存在大...
笔记：递归对比两组复杂数据是否相同
weixin_52517132的博客
09-03 140
递归对比两组复杂数据是否相同
用递归实现比较任意两个数据
weixin_57167969的博客
07-27 293
用递归实现比较任意两个数据 // 只对普通对象、数组、函数、日期和基本类型的数据结构进行对比 function isDeepEqual(obj1, obj2, testPrototypes = false) { // 判断是不是基本类型 if (obj1 === obj2) { return true }; // 如果是函数 if (type
两种递归算法的比较
ViV587的博客
08-31 417
首先来看第一种： def fab(n): if(n&lt;1): print('输入有误！！') return -1 if n==1 or n==2: return 1 else: return fab(n-1)+fab(n-2) 假设输入n=5，则递归过程如下图： 可以看出，在第二次调用fab(3...
递归与非递归的比较
热门推荐
luojinping的专栏
10-24 1万+
递归与非递归的比较 非递归效率高；递归代码写出来思路清晰，可读性强。        生成可执行文件大小应该和编译器有关吧。。。。 递归的话函数调用是有开销的，而且递归的次数受堆栈大小的限制。  以二叉树搜索为例：  bool search(btree* p, int v)  {  if (null == p)  return false;  if (v == p->v
递归
HABITXIA的专栏
03-13 944
1.所谓的递归慢到底是什么原因呢？ 大家都知道递归的实现是通过调用函数本身，函数调用的时候，每次调用时要做地址保存，参数传递等，这是通过一个递归工作栈实现的。具体是每次调用函数本身要保存的内容包括：局部变量、形参、调用函数地址、返回值。那么，如果递归调用N次，就要分配N*局部变量、N*形参、N*调用函数地址、N*返回值。这势必是影响效率的。   2.用循环效率会比递归效率高吗？
递归与循环的优缺点
安冉
09-24 2016
递归好处：代码更简洁清晰。一般来说，一个人可能很容易的写出前中后序的二叉树遍历的递归算法，要写出相应的非递归算法就比较考验水平了，恐怕至少一半的人搞不定。所以说递归代码更简洁明了。 递归坏处：由于递归需要系统堆栈，所以空间消耗要比非递归代码要大很多。而且，如果递归深度太大，可能系统撑不住。 一般尾递归（即最后一句话进行递归）和单向递归（函数中只有一个递归调用地方）都可以用循环来避免递归，更
普通迭代与普通递归耗时对比
yuyajun06的博客
03-21 2774
 迭代：迭代是重复反馈过程的活动，其目的通常是为了逼近所需目标或结果。每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值（来自百度百科）递归：程序调用自身的编程技巧称为递归（ recursion）测试用的算法：斐波那契数列测试代码：/** * 迭代与递归耗时统计 * 算法：斐波那契数列（Fibonacci sequence），又称黄金分割数列、0 ，1，1,2,3,...
二叉树的三种递归遍历
最新发布
11-30
二叉树的三种递归遍历分别是前序遍历、中序遍历和后序遍历。它们的遍历顺序如下所示： 1. 前序遍历：根节点 -> 左子树 -> 右子树 2. 中序遍历：左子树 -> 根节点 -> 右子树 3. 后序遍历：左子树 -> 右子树 -> 根...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值