1
00:00:00,000 --> 00:00:05,860
>> [音乐播放]

2
00:00:05,860 --> 00:00:09,530
>> 道格·劳埃德：你可能认为，
代码只是用来完成任务。

3
00:00:09,530 --> 00:00:10,450
你写出来。

4
00:00:10,450 --> 00:00:11,664
它做一些事情。

5
00:00:11,664 --> 00:00:12,580
这几乎是它。

6
00:00:12,580 --> 00:00:13,160
>> 你编译它。

7
00:00:13,160 --> 00:00:13,993
运行该程序。

8
00:00:13,993 --> 00:00:15,370
你是好去。

9
00:00:15,370 --> 00:00:17,520
>> 但是，不管你信不信，如果
你的代码很长一段时间，

10
00:00:17,520 --> 00:00:20,550
你居然不妨来看看
代码东西是美丽的。

11
00:00:20,550 --> 00:00:23,275
它解决了在一个问题
一个非常有趣的方式，

12
00:00:23,275 --> 00:00:26,510
或有只是一些真正
整齐的有关它的样子。

13
00:00:26,510 --> 00:00:28,750
你可能会笑
我，但这是事实。

14
00:00:28,750 --> 00:00:31,530
和递归是一种方式
排序得到这个想法

15
00:00:31,530 --> 00:00:34,090
美丽的，优雅的外观的代码。

16
00:00:34,090 --> 00:00:37,740
它解决的方式的问题，
很有意思，很容易想象，

17
00:00:37,740 --> 00:00:39,810
而令人惊讶的短。

18
00:00:39,810 --> 00:00:43,190
>> 该方法递归作品
是，递归函数

19
00:00:43,190 --> 00:00:49,291
被定义为一个函数调用
本身作为其执行的一部分。

20
00:00:49,291 --> 00:00:51,790
这似乎有些奇怪，
我们会看到一点点

21
00:00:51,790 --> 00:00:53,750
关于如何工作的时刻。

22
00:00:53,750 --> 00:00:55,560
但同样，这些
递归程序

23
00:00:55,560 --> 00:00:57,730
会是如此优雅
因为他们会

24
00:00:57,730 --> 00:01:00,410
解决这个问题，而无需
拥有所有这些功能

25
00:01:00,410 --> 00:01:02,710
还是这些长循环。

26
00:01:02,710 --> 00:01:06,310
你会看到，这些递归
程序要看看这么短。

27
00:01:06,310 --> 00:01:10,610
他们真的会做
你的代码看起来很多更漂亮。

28
00:01:10,610 --> 00:01:12,560
>> 我给你举个例子
这怎么看

29
00:01:12,560 --> 00:01:14,880
递归过程可能被定义。

30
00:01:14,880 --> 00:01:18,202
所以，如果你熟悉这个
从数学课很多年前，

31
00:01:18,202 --> 00:01:20,910
有被称为东西
阶乘功能，这通常是

32
00:01:20,910 --> 00:01:25,340
表示为一个感叹号，这
是指对所有的正整数。

33
00:01:25,340 --> 00:01:28,850
和的方式使n
阶乘的计算方法

34
00:01:28,850 --> 00:01:31,050
是你乘的是
小于的数字

35
00:01:31,050 --> 00:01:33,750
或等于n together--
所有的小于整数

36
00:01:33,750 --> 00:01:34,880
或等于n在一起。

37
00:01:34,880 --> 00:01:39,850
>> 因此，5阶乘是5倍
4次3次2次1。

38
00:01:39,850 --> 00:01:43,020
和4因子的4倍
3次2次1等。

39
00:01:43,020 --> 00:01:44,800
你的想法。

40
00:01:44,800 --> 00:01:47,060
>> 作为程序员，我们不这样做
用N，感叹号。

41
00:01:47,060 --> 00:01:51,840
因此，我们将定义的阶乘
功能实际上为n的。

42
00:01:51,840 --> 00:01:56,897
我们将用阶乘创建
递归地解决的问题。

43
00:01:56,897 --> 00:01:59,230
我想你可能会发现
这是一个很多更直观

44
00:01:59,230 --> 00:02:02,380
吸引力比迭代
版本的这一点，这

45
00:02:02,380 --> 00:02:05,010
我们还将看看在某一时刻。

46
00:02:05,010 --> 00:02:08,310
>> 因此，这里有几个
facts--双关语intended--

47
00:02:08,310 --> 00:02:10,169
关于factorial--的
阶乘函数。

48
00:02:10,169 --> 00:02:13,090
1的阶乘，正如我所说，是1。

49
00:02:13,090 --> 00:02:15,690
2的阶乘是2倍1。

50
00:02:15,690 --> 00:02:18,470
3的阶乘是3
次2次1，依此类推。

51
00:02:18,470 --> 00:02:20,810
我们谈到了4,5了。

52
00:02:20,810 --> 00:02:23,940
>> 但看这，是不是这样的吗？

53
00:02:23,940 --> 00:02:28,220
是不是阶乘的2只
2倍的1的阶乘？

54
00:02:28,220 --> 00:02:31,130
我的意思是，1的阶乘是1。

55
00:02:31,130 --> 00:02:34,940
那么，为什么我们不能只是说，
自2阶乘是2倍1，

56
00:02:34,940 --> 00:02:38,520
它实际上只是2倍
1阶乘？

57
00:02:38,520 --> 00:02:40,900
>> 然后扩展这一想法，
是不是3的阶乘

58
00:02:40,900 --> 00:02:44,080
短短3倍2的阶乘？

59
00:02:44,080 --> 00:02:50,350
和4的阶乘的4倍
3，等等的阶乘？

60
00:02:50,350 --> 00:02:52,530
事实上，阶乘
任何数量可以只

61
00:02:52,530 --> 00:02:54,660
如果我们表达一种
携带这一点，直到永远。

62
00:02:54,660 --> 00:02:56,870
那种我们可以概括
阶乘问题

63
00:02:56,870 --> 00:02:59,910
因为它的n倍
阶乘ñ减1。

64
00:02:59,910 --> 00:03:04,840
它的n倍的产物
所有的数字比我少。

65
00:03:04,840 --> 00:03:08,890
>> 这样的想法，这
问题的概括，

66
00:03:08,890 --> 00:03:13,410
允许我们递归
定义阶乘函数。

67
00:03:13,410 --> 00:03:15,440
当你定义一个函数
递归，有

68
00:03:15,440 --> 00:03:17,470
两件事情，需要成为它的一部分。

69
00:03:17,470 --> 00:03:20,990
你需要有一种叫
基本情况，其中，当你触发它，

70
00:03:20,990 --> 00:03:22,480
将停止递归过程。

71
00:03:22,480 --> 00:03:25,300
>> 否则，一个函数调用
itself--你可能imagine--

72
00:03:25,300 --> 00:03:26,870
可以永远持续下去。

73
00:03:26,870 --> 00:03:29,047
函数调用函数
调用函数调用

74
00:03:29,047 --> 00:03:30,380
该函数调用的函数。

75
00:03:30,380 --> 00:03:32,380
如果你没有办法
停止它，你的程序

76
00:03:32,380 --> 00:03:34,760
将得到有效卡住
在无限循环。

77
00:03:34,760 --> 00:03:37,176
它会崩溃，最终，
因为它会耗尽内存。

78
00:03:37,176 --> 00:03:38,990
但是，这是题外话。

79
00:03:38,990 --> 00:03:42,210
>> 我们必须要阻止一些其他的方式
除了我们的程序崩溃的事情，

80
00:03:42,210 --> 00:03:46,010
因为一个程序崩溃是
也许不漂亮或优雅。

81
00:03:46,010 --> 00:03:47,690
因此，我们称之为基本情况。

82
00:03:47,690 --> 00:03:50,610
这是一个简单的解决方案
到停止的问题

83
00:03:50,610 --> 00:03:52,770
递归过程的发生。

84
00:03:52,770 --> 00:03:55,220
所以这是的一部分
递归函数。

85
00:03:55,220 --> 00:03:56,820
>> 第二部分是递归情况下。

86
00:03:56,820 --> 00:03:59,195
而这正是递归
将实际发生。

87
00:03:59,195 --> 00:04:02,200
这是其中
功能调用自身。

88
00:04:02,200 --> 00:04:05,940
>> 它不会调用自身完全相同
以同样的方式，它被称为。

89
00:04:05,940 --> 00:04:08,880
这将是一个轻微的变化
这使得该问题是

90
00:04:08,880 --> 00:04:11,497
试图解决一个很小的有点小。

91
00:04:11,497 --> 00:04:14,330
但一般通过降压
的解决本体溶液的

92
00:04:14,330 --> 00:04:17,450
到不同的呼叫的路线。

93
00:04:17,450 --> 00:04:20,290
>> 这些长相
像基本情况吗？

94
00:04:20,290 --> 00:04:25,384
这些看起来像一个
最简单的解决问题的方法？

95
00:04:25,384 --> 00:04:27,550
我们有一大堆的阶乘的，
我们可以继续

96
00:04:27,550 --> 00:04:30,470
去on-- 6，7，8，9，10，等等。

97
00:04:30,470 --> 00:04:34,130
>> 但这些貌似之一
良好的情况下是基本情况。

98
00:04:34,130 --> 00:04:35,310
这是一个非常简单的解决方案。

99
00:04:35,310 --> 00:04:37,810
我们并没有做什么特别的事情。

100
00:04:37,810 --> 00:04:40,560
>> 1的阶乘是只有1。

101
00:04:40,560 --> 00:04:42,790
我们没有做任何
乘法可言。

102
00:04:42,790 --> 00:04:45,248
好像如果我们要
尝试和解决这个问题，

103
00:04:45,248 --> 00:04:47,600
我们需要停止
递归的地方，

104
00:04:47,600 --> 00:04:50,610
我们可能要停止
它，当我们得到1。

105
00:04:50,610 --> 00:04:54,580
我们不希望在这之前停止。

106
00:04:54,580 --> 00:04:56,660
>> 因此，如果我们定义
我们的阶乘函数，

107
00:04:56,660 --> 00:04:58,690
这里有一个骨架
我们如何做到这一点。

108
00:04:58,690 --> 00:05:03,110
我们需要在这两个things--堵塞
基本情况和递归情况下。

109
00:05:03,110 --> 00:05:04,990
什么是基本情况？

110
00:05:04,990 --> 00:05:10,150
如果n等于1，返回1--这是
要解决一个非常简单的问题。

111
00:05:10,150 --> 00:05:11,890
>> 1的阶乘是1。

112
00:05:11,890 --> 00:05:13,860
这不是1次东西。

113
00:05:13,860 --> 00:05:15,020
这只是1。

114
00:05:15,020 --> 00:05:17,170
这是一个非常简单的事实。

115
00:05:17,170 --> 00:05:19,620
因此，可以是我们的基本情况。

116
00:05:19,620 --> 00:05:24,730
如果获得通过1到这个
功能，我们就返回1。

117
00:05:24,730 --> 00:05:27,320
>> 什么是递归
情况大概是什么样子？

118
00:05:27,320 --> 00:05:32,445
对于每一个其他数
除了1，什么模式？

119
00:05:32,445 --> 00:05:35,780
那么，如果我们正在做
n的阶乘，

120
00:05:35,780 --> 00:05:38,160
的n是n次的阶乘减1。

121
00:05:38,160 --> 00:05:42,130
>> 如果我们采取的3阶乘，
它是3负1 3倍的阶乘，

122
00:05:42,130 --> 00:05:43,070
或2。

123
00:05:43,070 --> 00:05:47,330
所以，如果我们不
看着1，否则

124
00:05:47,330 --> 00:05:51,710
返回n倍
阶乘ñ减1。

125
00:05:51,710 --> 00:05:53,210
这是非常简单的。

126
00:05:53,210 --> 00:05:57,360
>> 并且为了稍微具有
更清洁和更优雅的代码，

127
00:05:57,360 --> 00:06:01,440
知道，如果我们有单行循环
或单行条件分支，

128
00:06:01,440 --> 00:06:04,490
我们可以摆脱所有的
他们周围的花括号。

129
00:06:04,490 --> 00:06:06,850
因此，我们可以巩固这种此。

130
00:06:06,850 --> 00:06:09,640
这具有完全相同的
功能这一点。

131
00:06:09,640 --> 00:06:13,850
>> 我只是收走了大
牙套，因为只有一行

132
00:06:13,850 --> 00:06:18,500
里面的那些条件分支。

133
00:06:18,500 --> 00:06:21,160
因此，这些行为相同。

134
00:06:21,160 --> 00:06:23,800
如果n等于1，则返回1。

135
00:06:23,800 --> 00:06:28,351
否则返回n次
Ñ​​减去1的阶乘。

136
00:06:28,351 --> 00:06:29,850
因此，我们正在做的问题较小。

137
00:06:29,850 --> 00:06:33,850
如果n开出5，我们要
返回的4 5倍的阶乘。

138
00:06:33,850 --> 00:06:37,100
我们会在一分钟内看到，当我们谈论
关于另一个视频通话stack--

139
00:06:37,100 --> 00:06:39,390
我们谈论了哪里
致电stack--我们将学习

140
00:06:39,390 --> 00:06:41,630
关于到底为什么这个过程的工作。

141
00:06:41,630 --> 00:06:46,970
>> 但5阶乘时说：
返回阶乘的5倍4，和4

142
00:06:46,970 --> 00:06:49,710
会说，好了，好了，回报
4倍3的阶乘。

143
00:06:49,710 --> 00:06:51,737
正如你所看到的，我们是
那种接近1。

144
00:06:51,737 --> 00:06:53,820
我们越来越近
接近这一基本情况。

145
00:06:53,820 --> 00:06:58,180
>> 一旦我们打的基本情况，
以前的所有功能

146
00:06:58,180 --> 00:07:00,540
有他们在寻找答案。

147
00:07:00,540 --> 00:07:03,900
2阶乘是说回归
2倍的1的阶乘。

148
00:07:03,900 --> 00:07:06,760
那么，1返回1阶乘。

149
00:07:06,760 --> 00:07:10,090
因此呼吁阶乘
2可以返回2次1，

150
00:07:10,090 --> 00:07:13,980
并给出了回阶乘
3，这是等待该结果。

151
00:07:13,980 --> 00:07:17,110
>> 然后它可以计算
其结果，3次2是6，

152
00:07:17,110 --> 00:07:18,907
并给它回到4的阶乘。

153
00:07:18,907 --> 00:07:20,740
再次，我们有一个
视频的调用堆栈

154
00:07:20,740 --> 00:07:23,810
其中这被示出一个小
不是我在说什么，现在更多。

155
00:07:23,810 --> 00:07:25,300
但是，这是它。

156
00:07:25,300 --> 00:07:29,300
这仅仅是解决
计算一个数的阶乘。

157
00:07:29,300 --> 00:07:31,527
>> 它只有四行代码。

158
00:07:31,527 --> 00:07:32,610
这很酷，不是吗？

159
00:07:32,610 --> 00:07:35,480
这是一种性感。

160
00:07:35,480 --> 00:07:38,580
>> 如此一般，但不
总是，递归函数

161
00:07:38,580 --> 00:07:41,190
可以替代在一个循环
非递归函数。

162
00:07:41,190 --> 00:07:46,100
所以在这里，并排，是迭代
版本阶乘功能。

163
00:07:46,100 --> 00:07:49,650
这两种计算
同样的事情。

164
00:07:49,650 --> 00:07:52,170
>> 他们都计算n的阶乘。

165
00:07:52,170 --> 00:07:54,990
版本在左边
使用递归来做到这一点。

166
00:07:54,990 --> 00:07:58,320
该版本在右侧
使用迭代来做到这一点。

167
00:07:58,320 --> 00:08:02,050
>> 而通知，我们要声明
一个变量的整数产品。

168
00:08:02,050 --> 00:08:02,940
然后我们循环。

169
00:08:02,940 --> 00:08:06,790
只要n是大于0，我们
保持该产品用n乘以

170
00:08:06,790 --> 00:08:09,890
和递减ñ直到
我们计算该产品。

171
00:08:09,890 --> 00:08:14,600
所以这两个函数，再次，
做同样的事情。

172
00:08:14,600 --> 00:08:19,980
但他们不这样做的
方式完全相同。

173
00:08:19,980 --> 00:08:22,430
>> 现在，有可能
有一个以上的基

174
00:08:22,430 --> 00:08:25,770
情况下或多于一个的
递归情况下，根据

175
00:08:25,770 --> 00:08:27,670
在你的函数试图做的。

176
00:08:27,670 --> 00:08:31,650
您不必仅仅局限于
单个基案或单个递归

177
00:08:31,650 --> 00:08:32,370
案例。

178
00:08:32,370 --> 00:08:35,320
的东西这么一个例子
有多个基例

179
00:08:35,320 --> 00:08:37,830
可能是this--的
斐波那契数列。

180
00:08:37,830 --> 00:08:41,549
>> 您可能还记得
小学生时代

181
00:08:41,549 --> 00:08:45,740
该斐波那契序列定义
像this--的第一个元素是0。

182
00:08:45,740 --> 00:08:46,890
第二个要素是1。

183
00:08:46,890 --> 00:08:49,230
这两项都只是定义。

184
00:08:49,230 --> 00:08:55,920
>> 然后每隔一个元素被定义
当n减去1和n减去2的总和。

185
00:08:55,920 --> 00:09:00,330
因此第三元件
将0加1是1。

186
00:09:00,330 --> 00:09:03,280
然后将第四元件
将第二个元素，1，

187
00:09:03,280 --> 00:09:06,550
加所述第三元件，1。

188
00:09:06,550 --> 00:09:08,507
这将是2。

189
00:09:08,507 --> 00:09:09,340
等等等等。

190
00:09:09,340 --> 00:09:11,680
>> 所以在这种情况下，我们有两个基例。

191
00:09:11,680 --> 00:09:14,850
如果n等于1，则返回0。

192
00:09:14,850 --> 00:09:18,560
如果n等于2，则返回1。

193
00:09:18,560 --> 00:09:25,930
否则，正的回报斐波那契
减1加N减2的斐波那契数。

194
00:09:25,930 --> 00:09:27,180
>> 所以这是多个基地的情况。

195
00:09:27,180 --> 00:09:29,271
那么多个递归情况？

196
00:09:29,271 --> 00:09:31,520
那么，有什么东西
叫考拉兹猜想。

197
00:09:31,520 --> 00:09:34,630
我不会说，
你知道那是什么，

198
00:09:34,630 --> 00:09:38,170
因为它实际上是我们最后的
问题对于该特定视频。

199
00:09:38,170 --> 00:09:43,220
而这是我们的运动
一起工作的。

200
00:09:43,220 --> 00:09:46,760
>> 因此，这里的什么
在Collat​​z猜想is--

201
00:09:46,760 --> 00:09:48,820
它适用于每一个正整数。

202
00:09:48,820 --> 00:09:51,500
它推测，它的
总是可能得到回

203
00:09:51,500 --> 00:09:55,060
1，如果你遵循这些步骤。

204
00:09:55,060 --> 00:09:57,560
如果n为1，停止。

205
00:09:57,560 --> 00:10:00,070
我们得回到1，如果n为1。

206
00:10:00,070 --> 00:10:05,670
>> 否则，通过这个
过程中再次n个除以2。

207
00:10:05,670 --> 00:10:08,200
看看你能回到1。

208
00:10:08,200 --> 00:10:13,260
否则，如果n是奇数，经过
这个过程再次3N加1，

209
00:10:13,260 --> 00:10:15,552
或3 n次加1。

210
00:10:15,552 --> 00:10:17,010
所以在这里，我们有一个基本情况。

211
00:10:17,010 --> 00:10:18,430
如果n等于1，停止。

212
00:10:18,430 --> 00:10:20,230
我们没有做任何更多的递归。

213
00:10:20,230 --> 00:10:23,730
>> 但是，我们有两个递归的情况下。

214
00:10:23,730 --> 00:10:28,750
如果n为偶数，我们做一递归
情况下，调用n乘2分。

215
00:10:28,750 --> 00:10:33,950
如果n是奇数，我们做了不同的
递归的情况下，3 n次加1。

216
00:10:33,950 --> 00:10:39,120
>> 这样一来，目标这个视频
花一秒钟，暂停视频，

217
00:10:39,120 --> 00:10:42,440
并尝试写
递归函数在Collat​​z

218
00:10:42,440 --> 00:10:47,640
你传递一个值n，其中和
它计算多少步它

219
00:10:47,640 --> 00:10:52,430
才能到达1，如果你从n个开始
你遵循这些台阶之上。

220
00:10:52,430 --> 00:10:56,660
如果n是1，它采取0的步骤。

221
00:10:56,660 --> 00:11:00,190
否则，它会
走一步加然而，

222
00:11:00,190 --> 00:11:06,200
它需要在任N多的步骤
除以2，如果n是偶数，或3n的加1

223
00:11:06,200 --> 00:11:08,100
如果n是奇数。

224
00:11:08,100 --> 00:11:11,190
>> 现在，我已经把在屏幕上点击这里
一对夫妇测试你的东西，

225
00:11:11,190 --> 00:11:15,690
你一对夫妇的测试用例，看
什么这些不同在Collat​​z号码，

226
00:11:15,690 --> 00:11:17,440
而且插图
的步骤

227
00:11:17,440 --> 00:11:20,390
需要通过这样你就可以走了
那种看到这个过程在行动。

228
00:11:20,390 --> 00:11:24,222
因此，如果n是等于
1，N的在Collat​​z为​​0。

229
00:11:24,222 --> 00:11:26,180
你不必做
什么要回1。

230
00:11:26,180 --> 00:11:27,600
你已经在那里了。

231
00:11:27,600 --> 00:11:30,550
>> 如果n是2，它需要
一个步骤去1。

232
00:11:30,550 --> 00:11:31,810
你开始2。

233
00:11:31,810 --> 00:11:33,100
井，2是不等于1。

234
00:11:33,100 --> 00:11:36,580
因此，这将是一步到位
加上然而，许多步骤是

235
00:11:36,580 --> 00:11:38,015
需要n个除以2。

236
00:11:38,015 --> 00:11:41,280

237
00:11:41,280 --> 00:11:42,910
>> 2除以2为1。

238
00:11:42,910 --> 00:11:47,200
因此，需要一步加然而，
许多步骤需要1。

239
00:11:47,200 --> 00:11:49,720
1采取零步骤。

240
00:11:49,720 --> 00:11:52,370
>> 3，你可以看到，有
相当多的步骤，参与。

241
00:11:52,370 --> 00:11:53,590
你从3。

242
00:11:53,590 --> 00:11:56,710
然后你去
10，5，16，8,4，2，1。

243
00:11:56,710 --> 00:11:58,804
这需要七个步骤要回1。

244
00:11:58,804 --> 00:12:01,220
正如你所看到的，有一个
其他几个测试用例在这里

245
00:12:01,220 --> 00:12:02,470
来测试你的程序。

246
00:12:02,470 --> 00:12:03,970
如此反复，暂停视频。

247
00:12:03,970 --> 00:12:09,210
我会去跳回到我们
什么样的实际过程是在这里，

248
00:12:09,210 --> 00:12:11,390
这是什么猜想。

249
00:12:11,390 --> 00:12:14,140
>> 看看你能不能找出
如何界定的n在Collat​​z

250
00:12:14,140 --> 00:12:19,967
因此，它计算多少
步骤才能到达1。

251
00:12:19,967 --> 00:12:23,050
所以希望，你已经暂停视频
你不只是在等我

252
00:12:23,050 --> 00:12:25,820
给你答案在这里。

253
00:12:25,820 --> 00:12:29,120
但如果你是，那么，
这里的答案呢。

254
00:12:29,120 --> 00:12:33,070
>> 所以这里有一个可能的定义
的在Collat​​z功能。

255
00:12:33,070 --> 00:12:35,610
如果n是我们的基础case--
等于1，我们返回0。

256
00:12:35,610 --> 00:12:38,250
它没有采取任何
步骤要回1。

257
00:12:38,250 --> 00:12:42,710
>> 否则，我们有两个递归cases--
一个用于偶数，一个用于奇。

258
00:12:42,710 --> 00:12:47,164
我测试连号的方式
是检查是否N模2等于0。

259
00:12:47,164 --> 00:12:49,080
这基本上是，再次，
问这个问题，

260
00:12:49,080 --> 00:12:54,050
如果你还记得什么国防部is--如果我
除以n乘2有没有余数？

261
00:12:54,050 --> 00:12:55,470
这将是一个偶数。

262
00:12:55,470 --> 00:13:01,370
>> 所以，如果n模2等于0
测试是这样一个偶数。

263
00:13:01,370 --> 00:13:04,250
如果是的话，我想回到1，
因为这绝对是

264
00:13:04,250 --> 00:13:09,270
走一步加在Collat​​z
不管数字是我的一半。

265
00:13:09,270 --> 00:13:13,910
否则，我想返回1
在Collat​​z加3 n次加1。

266
00:13:13,910 --> 00:13:16,060
这是其他
递归步骤我们

267
00:13:16,060 --> 00:13:19,470
可以采取的计算
Collat​​z--的步数

268
00:13:19,470 --> 00:13:22,610
它需要找回
到1给出一个数字。

269
00:13:22,610 --> 00:13:24,610
所以希望，这个例子
给你一点点

270
00:13:24,610 --> 00:13:26,620
的递归过程的味道。

271
00:13:26,620 --> 00:13:30,220
我们希望，你觉得代码是
小实施更漂亮，如果

272
00:13:30,220 --> 00:13:32,760
在一个优雅的，递归的方式。

273
00:13:32,760 --> 00:13:35,955
但即使没有，递归是一种
真正强大的工具，不过。

274
00:13:35,955 --> 00:13:38,330
所以这是绝对的东西
围绕让你的头，

275
00:13:38,330 --> 00:13:41,360
因为你能够创建
使用递归很酷方案

276
00:13:41,360 --> 00:13:45,930
否则可能是复杂的写
如果您使用的是循环和迭代。

277
00:13:45,930 --> 00:13:46,980
我是道格·劳埃德。

278
00:13:46,980 --> 00:13:48,780
这是CS50。

279
00:13:48,780 --> 00:13:50,228