斯坦福-CS106A-B-L-X-编程入门笔记-十一-

斯坦福 CS106A/B/L/X 编程入门笔记（十一）

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P26：Lecture 26 - What's Next - 加加zero - BV1By411h75g

好啦，我们开始吧，这是我们本季度的最后一堂课，今天是第十周或第十一周的星期五，我不知道号码，三天后期末考试，现在是星期一早上，十一个在八点，凌晨三点，那次真的很抱歉，一个简短的故事，就像。

考试时间不是我选的，它的运作方式通常是大学只是选择，你知道的，但我们在CS班，尤其是在一零六，我们有很多问题，学生们在我们考试的同时还有其他考试，而且我们的班级真的很大。

所以我们会有大约50个人有考试冲突，这一直是一个很大的后勤问题，对所以我们实际上去了大学，我们抱怨说嘿，你能帮我们吗，所以他们说，好啦，如果我们划出一个时间段，就像你们一样，你知道你可以有自己的时段。

就像没有人在那段时间有期末考试一样，你不会再有这些冲突了，我们就像，那太好了，然后他们总是我们，早上八点，他们就像，哎呦，你想要一个时段，这是你的时段，就像，如果你，如果你只是搜索，就像斯坦福。

期末考试或任何考试时间表，然后你会发现他们在某个地方有一张小桌子，我不知道，在哪里，也许这个和他们放的一样，他们总是把我们放在第一个时段，不管我是什么意思，还有其他一些人可以在那里，但基本上只有我们。

但是他们总是提前给我们期末考试时间，很抱歉，那正是我们必须忍受的，所以那真的很快，离现在只有三天了，我的猜测是，考虑到你们要做的所有其他事情，那个，你可能没有很多时间学习，然而。

希望你能在这个周末抽出一些时间来做这件事，你的作业8斯坦福1，2点3分今晚6点到期，昨晚我们玩了最后一晚，昨天晚上，星期四晚上，所以如果你想帮助斯坦福一二三，我建议使用广场论坛或电子邮件或联系部门领导。

诸如此类的事情，希望你们能尽快完成，反正，所以是的，接下来是期末考试，星期一上午，我今天想谈谈这个，然后我有几张幻灯片，我很快就过去，只是一些你可以选择在休息时间做的事情，或者在这堂课之后，等等。

这就是今天的计划，举起手来，如果我的期末考试是期末考试还是项目季末，今年秋天你最紧张的事情，好啦，如果你不举手，我只是好奇你有没有举手，然后呢，你比我还怕什么，你想怎么算，五一，我听说物理。

物理学六十一，是啊，是啊，数学五一，数学61，物理学六十一，好啦，所以我必须渴望与这些人匹敌，好啦，嗯，我会的，我会看看他们在做什么，并试着看看，你知道我们会看看我能做些什么，但是，嗯。

所以让我让我简单地谈谈决赛，嗯，如果你还没看，你知道的，有一堆期末考试资源，已经发布在我们的考试页面上，就像我们期中考试一样，所以如果你点击考试页面，我们有语法参考表，如果你想看看上面会有什么。

会被钉在试卷后面，就像期中考试一样，我们有三次练习考试，一、二、三，问题都是，你知道你可以看问题和答案键，您可以一步一步地查看代码中的问题，并键入答案以查看，如果你的答案正确地解决了问题。

所有的问题都应该在里面，至少所有的代码编写问题都应该在那里，如果你以某种方式完成了所有这些问题，你想要更多的问题，我是说，一步一步的代码是一个你可以查看的地方，它在这些一般类别中有很多问题。

也许选择一个你想要更多练习的类别，像图一样，或者你知道二叉树，不管是什么，你可以点击那个类别，一步一步地，你可以做更多的问题，本周的讲义，是为考试复习，所以这些也是额外的问题，回到前几节。

我肯定里面有些问题，你以前可能没时间解决，你可以去看看那些，所以说，我希望你们不会用光材料，从，就像你知道吗，在你的学习时间里，你能做的最有帮助的事情是什么？我真的认为做练习题是我看到的第一件事有人问。

我应该去读书上的章节吗，我应该回去看讲座录像吗，那些东西也很好，但我真的觉得就像锻炼你的肌肉一样，你知道解决这些问题是解决问题的方法，嗯，你知道在做那个的时候，实践问题，我想最好的准备方式，我是说你看。

我不是那种有创造力的人，我只是看着所有的老问题，我想到了一个新的，它通常与旧的问题很相似，所以如果你能解决所有这些，你可能在真正的测试中处于相当好的状态，就考试可能涉及的主题而言。

如果你还没有在这里读过，我有张单子，如果你向下滚动一点，它有主题列表，我可能还会问你关于链表的问题，递归或回溯，我把它弄厚一点，它们是链表，所以我问你期中考试的链表，但那只是一张节点的小照片。

就像把这张照片做成这张照片，你知道在决赛的时候，我可能会要求您编写一个方法，它接受一个前指针，并操纵一系列节点，这可能有点难，所以你可能想研究一下，我仍然希望你知道递归和回溯二叉树，你知道吗。

这里有一个指向树根的指针，我要你操纵这棵树，谈论如何实现一个结构，就像如果我说嘿，我们要实现一个类，那是一个堆栈或一个队列或一个列表或类似的东西，我希望你能谈谈如何在图形问题上做到这一点，像往常一样。

我会给你一个基本的图形对象，我要你做一些调查，或者是对图表的某种操纵，这包括我们学到的一些路径搜索算法，像戴克斯特拉，一颗星，以及克里斯托最小生成树算法，我还谈到了本季度晚些时候的一些材料，作业上没有。

就像搜索和排序，或者我猜排序主要是我们学到的不同排序算法，我们也学到了一些遗传之类的东西，所以我可能会问你一个问题，涉及到使用继承，所以这些都是不同的话题，如果你看看这些不同的决赛。

我想你会发现它们触及了这些主题的不同子集，就像不是每一个主题都出现在每一个练习测试中，但我想给你举个例子，因为有些季度我做或不包括不同的问题，所以你知道，这会给你不同的例子，你可能想练习，所以是的。

这些都是主题，如果你想知道一些你不需要学习的东西，下面也列出了一些，我不会让你画任何分形，我不会逼你的，操作员重载，我不会让你做STL的东西，我们周三学到的标准c+，所有这些不同的事情我不会让你做。

我不在的时候教的任何高级二叉树，就像自动平衡，旋转的树木，红黑树，所有我想知道的事情，如果你们有，关于什么是预期的，什么是不预期的，什么是不包括的，或者我什么都不知道，你对考试有什么问题吗，是呀。

其中一个问题是，如果像你这样的问题是关于实现数据结构，像那样什么的，如果一个问题谈到实现一个结构，我会给你一个标题，基本上是那个结构的h文件，所以你会知道它有什么方法，你就会知道它有什么私人数据。

所以希望，这个问题将，希望你知道，口头描述，也喜欢收藏是什么，所以我希望这将是足够的上下文，你会理解，就像收藏的性质是什么，或者问题在说什么，这里还有一个问题，我们真正需要了解的是什么，是啊，是啊。

做好分类你需要知道什么，我认为看练习考试是一个很好的起点，例如，有时我会给你一个数组或数据向量，我会说好，如果你要做一个选择，在此数组选择上排序排序排序使这些扫描在数组中一遍又一遍地进行。

数组会是什么样子，在你扫了三次之后，是这个还是这个还是这个，其中一个是正确的，一个或类似的东西，这很简单，但如果你不知道算法，你就做不到，与合并类似，也许你知道如果你把数组分开，你们又在一起了。

比如这些照片中的哪一张，大多数看起来像什么会是那种东西，这有点像，我想让你明白的程度，这些就像，能够跟踪我们在课堂上讨论的算法的执行，我不会让你写函数，这是其中一个算法，你必须完全用C++实现它。

加上我确实有一个，我想是在练习考试中，三个，我得看看，一定要，那个在哪里，我所做的就是说好，如果我有选择排序呢，但我用以下方式修改了它，这对算法的大O有什么影响，有时我会问这样的问题就像我看到的那样。

如果你明白算法的本质，算法的大O是什么，一些这样的东西，所以这就是我希望你知道的，答案是什么？或者你的，还有什么，是啊，是啊，他们会关心那些不喜欢，特别是问他是个大O之类的，是啊，是啊，总的来说。

你要担心大O井吗，就像你们知道的那样，我认为在考试问题上，你大多要写代码，我不在乎你的风格，我不在乎你的变量名，你的压痕，你的冗余，像这样的事情对吧，我唯一在乎你风格的时候，或者你代码的性质。

是当我觉得你是那种试图绕过的方式，我想让你解决这个问题，例如，如果您正在处理链表问题，我想让你浏览一下名单，然后操纵它什么的，您可以做的一件事是，您可以将整个链表复制到一个向量中。

然后做所有我让你做的关于矢量的事情，然后把它放回链表中，然后你基本上把我的问题转化为向量问题，就像嘿，我不想让你给我看，你可以做一个矢量，我想让你给我看看，你可以做一个链表，所以有时候当我说好的时候。

我不希望你在这里使用辅助结构，这就是我想让你解决的问题，在某种程度上，你展示了这个概念，我想测试你，对呀，所以出于同样的原因，有时我会说好，你需要在n平方的大O或更好的时间内解决这个问题。

这并不是因为我想问你关于大O的问题，这是因为有一些低劣的解决方案，就像第五局结束一样，在那里你做了一百万圈，然后你最终解决了它，但这就像非常糟糕的算法，这完全不是正确的方法，我要你设法解决它。

所以如果我有关于大O的任何关于这些问题的信息，会更像那样，为了阻止你做一个非常古怪的解决方案，但总的来说，如果我说任何关于大R的事情，以某种方式约束它，那很合理，在那里你可以选择一个合理的结构和算法。

算法会对我需要你做的大O没问题，我认为生物会更容易出现问题，你有问题吗，还有，是呀，我想知道根本不必知道如何做操作员的能力或只是，啊，啊，啊，也许我说了一点，正是这样我说的是重载运算符有些运算符。

我根本不在乎，有一些关于禁止抄袭某类课程的材料，这涉及到一个等号运算符之类的东西，我不在乎你是否知道，但我有时会问你这些问题，写类或做继承或其他什么，偶尔那些我有你写的不到不到喜欢。

打印一个对象或类似的东西，所以我想说有一些基本的运算符，我可能会要求你写，当然，像往常一样，我们不是超级骗子骗子，关注微小的语法问题，所以如果你忘了和号，什么地方什么的，就像你知道的。

这不是我们给你打的大部分分数，但是，关于期末考试还有什么问题吗？幻灯片就像，你打算怎么测试这个，好好记住你给我们的东西，是啊，是啊，我在听你说话，嗯，那我怎么测试你，像堤坝或任何星星，嗯。

如果我没记错的话，我并不总是这样，因为我相当老了，但我想一些图形算法在你的参考书上，在背面，对呀，所以他们在这里，所以说，我不是特别要你们背诵戴克斯特拉的算法，我把它给你，嗯，但我的意思是。

尽管我把它给了你，我可能会给你看一个图表，告诉你额外的顶点会访问什么，或者德克斯特会找到什么路，你可能会说，好吧，不是那么容易回答吗，如果你有这个，就像嗯，如果你从来没有学过戴克斯特拉的算法，你得喜欢。

读这个了解它是什么，那是件很压缩时间的事，所以我仍然认为你会想知道那些算法，即使你面前有这个，所以所以是的，我是说，我希望你熟悉他们，能够喜欢，看图表，谈谈如果你在图表上运行这些算法会做什么。

但我不指望你能完全死记硬背，因为你知道，你不应该把你所有的笔记和东西，所以没有你的笔记，我会发现很难记住所有这些东西，都是伟大的问题，还有其他关于考试的问题吗？是的，是的，这不是直接利亚姆。

但因为你是伟大的，嗯，我知道，就在期中考试之后，我们喜欢，有一个链接，可以知道你在年级的每个部分都有什么，像家庭作业，之后有什么方法可以得到这些信息，现在我们去这里拿，是呀，所以他在问，那种网页。

在那里你可以查你的分数，期中考试之后，实际上有些学生对我说，就像嘿，我的页面过时了，它不见了，它不会随着我的新分数和其他东西而更新，是的我觉得原因是，就像我必须在年级数据库上运行一堆代码。

为了得到那一页，所以我不想每天重新运行那个东西来更新它，或者我当时给你一些季度中期的东西，所以你可以看出交付日期快到了，我有麻烦了吗，我应该考虑这种事吗？我想帮你做决定，但我还是会。

我会重新更新那个页面，在所有的成绩都完成之后，期末考试全部打分，所有作业都打分，因为我想让你们有一个完整的审计，就像我们为你准备的一切，你是怎么得分的，你得到了什么，你的一般排名或百分位数大致在班上。

那么什么样的字母等级导致，你也会看到同样的字母等级在上升，你的访问权限和你大学里的所有东西，你知道你这样做的登录，是呀，考试评分后我会更新那一页，如果里面有错误，随便啦，那对你来说是个好办法。

去看看他们，帮我们修理他们之类的，但那将是，我想你知道星期一考试，我想我们要给他们打分，比如周三或者周四，我忘了，所以大概在那个周末，也许我会有那一页，你知道，因为我得给SLS一些时间来喜欢成绩。

所有的作业，你还没上交的艾滋病，你知道所以我不能，我拿不到，我很想告诉你周一晚上，你这门课的成绩是多少，但我还没有所有的数据，所以你可能知道，那个周末，大致上我会把这些都给你，还有考试的事吗？好啦。

我会尽量给你们写信的，一个会挑战你的公平测试，但不会令人沮丧、不公平或不安，或者我所知道的，考试压力很大，我想我可以通过取消考试什么的来缓解压力，但我还没有接近，好到可以做那样的事。

但你知道我我知道这对你们来说不好玩，所以我要试着，我是说，我想做的是让测试不那么噩梦般，只是给你很多练习题，然后希望真正的测试至少主要是像这些问题一样，这样你就知道你会看到什么，你知道你会得到什么。

希望考试那天不要有太多惊喜，很难保证，但我尽力向你保证，希望一切都会好起来，如果分数太低，如果考试太难，我会把分数拉高，一切都会好的，我们会想出办法的，如果测试太容易，而且分数太高，就这样吧。

你可以有你的高分，我只是弯腰，我不弯腰，是呀，期中考试练习，练习期中考试，嗯，我们在网上的帖子有更多的问题，比我们有更长时间的问题，那真的很像吗，案例练习决赛，所以我只是重复一遍，因为视频采集卡要求。

就像，期中考试出现了更多的问题，但它们更短，实际上，在练习中，问题更多，但它们更短，在真正的期中考试中，问题更少，但它们更大更长，难度更大，我也会在决赛中这样做吗，你知道的，我还不确定。

我还没有最后确定问题的确切清单，我还在调整，但这是我有时会做的事情，所有的练习测试都会有12个问题，然后真正的测试有十个什么的，然后它几乎就像我创伤你认为，会有十二个，然后你感激得到十个而不是生气。

你得了10分什么的，这一切都是关于设定期望，对嗯，有时我会这么做，有时我不知道，我想总的来说我想说的是，我尽量不去参加真正的决赛，有比实践更多的问题，嗯，有些人有时会说。

他们觉得真正的考试比练习考试更难，或者类似的东西，我知道有时候这是真的，我不希望那是真的，但有时是因为我必须喜欢，想出这些问题，有时你会想出一个更难的问题，但我的目标是，问题的数量将小于或等于这些。

困难的总和将接近等于，尽我所能，虽然我不能保证完美，对呀，当然，我不能保证难度会相等，但我保证如果困难太大，而且是有害的，你的分数很低，我会调整和修复它的权利，那是，这是我能得到的最好的，嗯，是啊。

是啊，还有别的吗？你们真聪明，我知道你有这个，他们告诉你，如果你告诉你的学生他们能做到，那么它实际上是可以衡量的，它提高了他们的分数，你知道，所以我认为你可以，高分考试更容易打分，所以我只想快点评分。

所以好好干，让我轻松点，好啦，所以是的，那是决赛，你知道的，这个周末留出一些时间学习，星期一早上见，但现在。

好啦，所以让我们做，我们甚至可能提前结束，我不知道，如果我需要整个剩下的演讲时间来做这个，但我想稍微结束一下，好好谈谈，你可以像这样，季度结束后，你知道的，在CS或编码中前进，或者别的什么，嗯。

这些我可能会跳过一些这些第一张幻灯片，这就像嘿，我们学到了什么，我们从哪里来，就像，是啊，是啊，你知道你在这里，剥夺，你曾经，你看过这样的电视节目吗，就像我妻子喜欢菲尔博士秀一样，她喜欢这些垃圾。

就像脱口秀，真人秀什么的，他们喜欢做的是，他们会说就像上来，他们会告诉你下一步是什么，然后他们会去广告，然后他们就会回来，他们会说就在一分钟前你看到了这个，所以他们经常给你看，一些他们将要做的事。

或者他们刚刚做了，如果你看看现在时的内容，有一个，有像五分钟的内容是愚蠢的，所以我觉得我在这里做，如果嘿，记住我们学到的所有东西，所以说，是啊，是啊，我们学到了很多东西，挺酷的，我们了解了收藏。

我们了解了它们是如何在内部实现的，我们学习了算法，你可以在收藏上做，我们学习了递归，递归很酷，嗯，我们学到了一些关于对象、面向对象和继承之类的东西，它在C++中实现得不是很好。

所以我们有点不强调它，所以是的，这之后我们能做什么，我想这是个大问题，嗯，我的意思是，一零六是你们的基础，你知道你学会了编程是如何工作的基本理解，循环、变量、数组、数据、方法和参数。

所有的东西都是零六个，然后我们的类更像是数据和算法，就像我有大量的数据，我该怎么处理它，如何存储，我可以用什么样的算法来处理它，我是说我们才刚刚开始，但这是我们的计划，我们就是这么做的。

既然你已经完成了这门课，你能做好什么，我是说你可以，如果您想做更多的编码，你可以拿七个中的一个，如果你想做理论计算机科学，你可以一比三，你们中的一些人，我想现在就在那里，对呀，谁在一零三，现在，是啊。

是啊，好啦，因为你可以带着它和我们在一起，所以你可能现在就在服用，你可以把下一个季度，所以这是两道主菜，人们拿下一个零七和零三，七个中的一个是一堆更多的编码，一零三是一堆不编码。

虽然我想他们这次有一点编码，对吧，他们需要在里面做一点编码，是啊，是啊，巧克力和花生酱放在一起，管他呢是的，但它大多没有在三个中的一个涂覆，所以我想谈谈所有这些课程，还有一堆其他的东西。

所以我是说这两个我们的核心有两条知识轨道，就像系统和编程轨道的种类，我们在右边有一个理论和数学计算机科学的轨道。

嗯，让我们来谈谈一零零七只是一秒钟，我的意思是我有，我试着放一些教这些课的人的面部照片，一般来说嗯，所以一零零七是我们的计算机组织和系统课，就像你知道，盗梦空间，我们要去一个梦中的梦，我们得深入一点。

有点，一零零七的计划就是这样，我们必须更接近硬件，真正了解内心深处的一些事情，比如计算机是如何计算东西的，它如何在处理器中做算术，就像它用来计算加法和乘法的指令，所有这些不同的操作逻辑。

如果不是这样的话，处理器实际上喜欢什么，做那个，所以在低处，会理解它用来做这些事情的原始机器指令，伴随着所谓的汇编代码，稍微高于计算机语言，那是，你知道的，非常非常原始和基本。

所以你学会了如何用这种格式编写程序或读程序，你还学习了c编程语言，所以你知道我们一直在做C加+，我的意思是，基本上C语言就是C++，但是把一堆东西拿出来，以一种奇怪的方式，我其实更喜欢c而不是c加。

因为它简单得多，只是少了很多，功能少了很多，您知道的特性和需要学习的语法片段更少，所以有可能，我认为掌握C是可能的，把整个C语言，我不知道c加+能不能掌握，因为事情太复杂了。

在C++里有这么多疯狂的事情发生，所以c是一种非常低级的编程语言，实际上你写的一些程序，你被要求写出这些你本可以轻松完成的非常简单的事情，在Java或C++中，比如，我记得当我上这门课的时候。

当我还是个大学生的时候，他们有一个作业，就像写选择，对字符串数组进行排序，我觉得这听起来很简单，但在C中，这并不容易，很难，所以，因为字符串是硬的数组是硬的，所有你在高级语言中认为理所当然的计算。

像C++或Java在C语言中更难做到，所以我想有些学生不喜欢，因为感觉就像是在挫折中练习，你为什么，为什么你要我用锤子和钉子，你能给我一些更好的工具什么的，但我认为这个想法是为了深入理解计算的步骤。

而不是有很多神奇的帮手来帮助你做到这一点，为了你，所以不管怎样，你在更深更低的层次上学习编码，您将更多地了解代码是如何编译、链接在一起并执行的，您知道编译项目时的生成文件夹，所有这些文件。

然后它就变成了一个可执行程序，我们在课堂上很少讨论这个问题，你只需点击编译和点击运行，就这样了，你知道的，一噢七，他们真的在谈论那里发生了什么，而不是处理，它是如何工作的，诸如此类的东西。

以及图书馆是如何联系在一起的，以及编译后的目标文件是如何链接在一起的，所有这些有趣的事情，以及代码是如何运行的，就像内存在程序中的布局一样，当你运行程序时，当你有你的堆栈，你有你的堆。

你有这些不同的数据片段，你与之交互，超级有趣，我想很多人从107中走出来，他们对程序如何运行和计算机如何工作有了更好的整体理解，以及编程的真正意义，所以你知道，这就是我们认为对你们来说最重要的下一件事。

在我们的课程中学习，你还会学到一些操作系统的东西，比如如何在UNIX中四处走动，一点点，如何使用版本控制签入和签出项目，做这种事你会好很多，总体程序员，我想在零七之后，一零七的敲门声。

有几件事要人们批评什么，你们听说过107吗，街上有什么消息，那很难，分配器，堆分配器，编程作业难，听着你们一周要完成三项任务，你不会有事的，别担心，他们一次只派一个任务，所以他们不知道你们有多辛苦。

你听说了那很难，部分项目车，你们还听到了什么，我只是好奇，是呀，往前走很久，这需要很多时间，是呀，我想那是真的，我想那是真的，你还听说了什么，除草课除草课，这是一个有趣的说法，就像除草一样。

那些不打算在大调中削减它的人，或者类似的东西，是啊，是啊，是啊，是啊，我是说，我不知道，我不知道我是否同意这种描述，但我以前听人说过，我想我有一张幻灯片。

那是哪里那是这里，是啊，是啊，好吧零七，杀了我嗯，所以你看，我想，我是说，也许你们中有多少人报名参加，我只是对下个季度很好奇，你们中的很多人已经报名参加了这门课，对呀，所以我不认为我需要喜欢。

在这里投得太狠了，但它确实有一点这样的名声，超级硬需要大量的时间，某些项目本身就有声誉，这是一个除草课程，对呀，我觉得有点言过其实了，我想让我告诉你我认为这种名声主要来自哪里。

我想部分原因是他们没有一层，他们有助教，他们有办公时间，所以你可以去找帮助教练在办公时间，你知道你可以在一零零七得到帮助，但你知道这一层就像打开很多小时，里面有很多人，有这样的空间。

你可以在许多不同的日子去，很多不同的时代，在那坐上几个小时找人帮忙，好吧你在107里找不到帮手，我认为有些学生真的很依赖这一层，是时候熬过零六了，当它消失的时候，他们真的很怀念。

他们在1-0-7中有点挣扎，所以我想说如果你不经常使用图层，或者你有时去，或者你把它和其他资源混合使用，就像广场、电子邮件和部门领导，而那种事情，你可能不会发现这样一个不和谐的转变，如果你去层一吨。

你真的觉得没有那层，你在挣扎，那么这可能是一个艰难的转变，但我认为这更像是一个零六A和B问题，我发现大多数学生，我不觉得这种转变很艰难，因为你们已经面临了一个非常有挑战性的课程，现在我要让你。

所以无论如何你得多帮助自己，就像，如果你被困住了，你需要能够去看文档，你可能需要去谷歌一些东西，或者尝试一些东西，让自己半途而废，然后问老师或者助教，或者谁帮你完成剩下的路让你摆脱困境。

如果你继续这样做，我觉得你应该没事，但你知道，我会说，我认为这个班组织得很好。

这些人，朱利安·泽连斯基令人惊叹，克里斯·克雷格也很棒，他们都花了很多时间制作精心制作的材料，写得好，这不是一个马虎的破车路线。

一切都安排得很好，他们知道这很有挑战性，但他们有多年的时间来上上下下地拨号，弄清楚他们想要的挑战有多大，有很多众所周知的问题和答案，bug和修复，所以他们知道如何帮助你完成课程。

所以我认为总的来说还可以，这很难，我觉得你听到的可能是对的，这确实需要很多时间，但我不认为你们会淹死在这门课上，如果你担心这个，我想说我想你可能会没事的，所以我鼓励你现在就试一试。

好啦，话虽如此，还有另一个阶级，一零七，E是的，你们中的一些人听说过这门课，E代表嵌入，这基本上是一零七的新版本，它专注于编写运行在覆盆子圆周率上的程序，董事会我不知道你们是否知道这些事情。

但它们就像蹩脚的廉价电脑，基本上，有最起码的硬件，就像电脑一样，你知道他们有一个，我想这是张老照片，但他们有一个HDMI视频端口，他们有一个USB接口，为了键盘和鼠标，你就像把一个硬件连接到它上。

一个显示器和一个键盘，然后你按下某个地方的电源按钮，它就启动了，它就像一种廉价的小电脑，和这个东西一起工作有什么乐趣，就像你用任何语言写一个C程序或程序，你的程序就像圆周率的操作系统，圆周率打开。

它不会引导到Windows或Linux或其他东西的GUI中，不不不，它就像立即运行你的主要方法，但你是操作系统，这个设备上没有其他事情发生，但你和你的计划，所以这很有趣，你会学到很多很酷的东西，比如。

例如，这个东西有一些像灯一样的东西，你可以打开和关闭，你可以发出哔哔声，然后去做，你就像去记忆中的某个地址，就像在那里写值一样，所以如果你像你知道的那样去做，记忆，零x 7 ff，你在那里放一个二。

你会听到哔哔声，它让我想起了，如果你轻拍某人的膝盖，然后他们的腿踢了出来，就像这个东西，你只是喜欢，在不同的地方敲击他们的记忆，灯亮了，什么的，然后嗯，你知道的东西，一分钟前我说过107是比较低的。

在这里更是如此，因为我是说普通的117，你还在笔记本电脑上编码，还有你，你编译程序，你在你的机器上运行它，或者在学校的服务器上或者其他什么机器上，所以它仍然在普通计算机上运行，你知道的。

但这就像你只是在为这个不同的设备编程，你知道什么更好吗，是不是更糟，是不是更难，是不是更容易，我不知道这是一种，这是不同的，你知道你学到了很多同样的东西，但我想你在这里找到的就像。

你被卡住的东西可能是不同的，就像我上个季度和一个学生说话一样，他们只是不知道他们的程序出了什么问题，然后他们最终发现就像短路一样，在他们覆盆子圆周率的一个别针里，就像硬件真的坏了一样。

使他们的程序不能正常工作，这不是他们代码中的bug，就像他们不得不点一个新的小馅饼，或者从覆盆子皮盒里拿一个新的，你知道这就像这不是一个错误，你在正常情况下会有的，这是一件要处理的奇怪的小事。

反正你也知道，或者喜欢，有时你的程序不起作用，所以你打开那东西，你只看到任何东西因为它试图启动，你的东西不能正常工作，它就会爆炸，也不管用，它不会真的爆炸，但不管怎样。

你会遇到一些不同类型的错误和不同类型的问题，所以如果你想知道你可能想要哪一个，我的意思是我认为他们都是有趣的课程，我没有特别偏好的建议，但我想大多数人都拿107，那仍然是主要的。

大多数人拿一零零七更光鲜，它存在的时间更长，材料很像凿出来的，他们非常，bug率很低，零七内容，你知道它已经用了很多年了，如果E较新，则为一个，它更像是粗糙的。

你知道他们并不总是对每件事都有那么多详细的指南，你有时得自己想出更多的东西，否则你和你的伙伴们得想办法，在某种程度上，还有更多这样的事情发生，但我的意思是，你有一个整洁的背景，你可以了解。

我想如果你对嵌入式计算或设备感兴趣，或者这样的事情真的很酷，你必须填写申请才能进入，他们可能已经为本季度选择了，但是嗯，所以这就是这两道菜的区别，我觉得他们都很有趣，实际上，我觉得特别有趣的是。

我相信朱莉泽伦斯基下个季度会教e，她就像一零零七生态系统的女王，所以我相信她会做得很好，你们还有其他关于1 0 7或1 0 7 e的问题吗？当他们在屏幕上的时候，你能比较一下，啊，好啦，呃，一零七。

做1-0-7和1-0-6需要多少时间，我听大多数学生说，他们在六个A中拿一个B，然后是1 0 6 b，他们告诉我一零零七是一个跳跃，对他们来说，这是一个相当重要和明显的跳跃。

但是我和大多数从X出来的学生交谈过，他们说感觉更平淡，或者只是为七个中的一个跳起来，实际上对你们来说，我给你布置了更多的作业，比我以前在一零六课程中给任何人的都多，所以你们可能会觉得这并不坏。

在一个零七，只有一个任务，不是三个，我真的为你们感到难过，你知道的，通常这些家庭作业只是一部分，我想去他的，我要给他们三个部分，一开始只是做作业，一个是为了吓唬应该换B的人，但后来我就像嗯。

也许我会在所有的作业中都这么做，我只是好奇，如果你们都放弃，你们中的很多人留下来了，很奇怪，我不知道，我以为你会叛变，就像在第四周捅我一刀，但是嗯，哦好吧，还有时间，我明白了，我听得清清楚楚，好啦。

那是那是不愉快的，不，但对不起，所以我不知道，如果我真的，我不能完全说话，因为我觉得有一件事，在那里来到一零六的人，他们来自不同的地方，你们中的一些人以前从未编码过，春天夏天什么的。

你们中的一些人在高中机器人团队，你十二岁的时候就开始为iphone写应用程序了，地图上到处都是，好吧等你到了这里，这门课给你的工作量，或者A或B中的一个所做的工作量，你可以到处都是。

对你们中的一些人来说，没那么糟，因为你以前见过一些材料，或者你拿的所有材料，你看到了很多这样的东西，所以这意味着你在这里经历的，我很难知道那到底是什么，你们中的大多数人都没有见过很多这样的常规。

以前的一零七或一零七E材料，所以这对学生来说是一个真正的不同，他们没有意识到为什么106会这样，对他们来说，每周花很多时间是因为他们已经知道递归，或者他们已经知道二叉树，或者别的什么，你知道的。

所以我认为这是完全可行的，总的来说我想说的是，这是一个，这是一门很有挑战性的课，所以不要像这样报名和其他四门硬课，同时，这是我的建议，但这不会毁了你的生活，你不会有事的，即使是一堆碱基。

关于117还有什么问题吗？或者E，我对这些课程一窍不通，我一般不教他们，但我很乐意尽我所能回答，因为计算机科学主要是关于抽象的，在七个或十个中的一个之后，其中有多少会延续到其他人身上，是啊，是啊。

问得好，比如抽象和层次，我们好像要深入到电脑里去，现在呢，我向你坦白，我认为每个计算机科学家都有自己的领域，他们觉得更有趣或更不有趣，那也没关系，我们并不都喜欢同样的东西，我个人真的很喜欢。

比如编写面向用户的应用程序，我喜欢写网页，我喜欢写手机应用程序，坦率地说，我对，就像碎片和叮咬，还有哔哔声，还有胸部，和喜欢，我可能不会接受，因为我永远不会想编程这些东西之一，我不想喜欢，影响。

你们喜欢，这是个很酷的小发明，我只是碰巧是个高高在上的人，然后不下载硬件，那种人，但我不想让你也这么想，你知道对我来说，我更感兴趣的是从C+上升，我不想担心指针、删除和释放内存。

我想担心动画和三个D和UIS，而这种东西，但如果你想知道我们也有，只是我们一开始喜欢这样，我想每个人每个大学，每门计算机科学课程都要决定，入门编程之后接下来会发生什么，不同的学校走不同的路，老实说。

这有点取决于部门里真正有权力的人，他们作为博士所做的有点像，所以我们系统的力量是强大的，所以他们就像我们下一个要做这个，你知道有些大学有一个非常强大的理论小组。

所以他们就像每个人在介绍后都要拿一零三等价的东西，你知道这有点，这就是这些部门做事的方式，好的，好的，所以是1，0，7和1，0，7，e，你可能会在下个季度拿走这些，我还想谈一下123。

这是计算CS理论分支的数学基础，更像是铅笔和纸的课，与计算机和代码类相反，有些人喜欢那样，有些人不喜欢那样，我是说这是，这是我们领域的一个完全不同的方面，但我会说，我认为这真的真的很重要。

我是说你在课堂上思考非常重要的问题，我是说你开始学习一些证明技巧和数学技巧，数数和设置，以及逻辑和计算机科学的基础，但你也会学到一些东西，比如算法和计算的极限，你能计算什么，不能计算什么，你能做多快。

你能做什么你能做什么，这里有很多有趣的基本原理，这些都是计算机科学的核心，我听过一句很棒的名言，但我忘了，如果这是迪克斯特拉的名言，它的报价在哪里，计算机科学不再是关于计算机的。

那么天文学是关于望远镜的，对呀，它就像一个工具，我们用来学习一些正确的东西，所以这堂课我认为代表了，因为我们在思考计算和编程背后的思想，以及计算机是如何工作的，然后嗯，你知道的，有这个真的，有很多真的。

你在我们的理论课上谈论的非常有趣的大问题，其中之一就是著名的p对np，你们以前听说过吗，P对NP，也许你拿了一零三，你听说了一些，简短的回答是，这是一个关于，计算机可以在合理的时间内解决哪些类型的问题。

这两个不同的大类问题是相同的还是不同的，我们不能决定，我们还不能以这样或那样的方式证明这一点，但我们正在努力，如果我们能以这样或那样的方式证明这个问题，那将是一个非常非常大的里程碑。

我们会利用这一点来取得各种其他突破，这些都是悬而未决的问题，我认为CS最酷的事情之一是，我们还没有完全弄清楚，我们还没有得到所有的答案，所以这种材料是一个很好的例子，所以超级有趣。

教授这些课程的人真正知道他们在做什么，这很有帮助，Keith Schwartz可能是大学里最好的老师，不仅仅是在部门里，他经常是这里的教练，辛西娅·李也很了不起，她也在教，我想他们下个季度会一起上课。

所以我认为这将是非常棒的反正，这是一种不同的看法，CS，你不写它曾经是，你不会真的在这个类里写任何代码，但我相信最近他们增加了一点，主要是为了说明，让我们学习这个理论概念，然后很快地写一小段代码来验证。

或者举例说明，但它主要不是关于编写新代码，你们中的一些人现在在那个班上，我总结了吗，好啦，比如，你想补充一些关于这门课的内容吗，或者在那个班上是什么感觉，有人想跳进来帮我吗，太好吃了，我没有。

我不是付钱让她来的，这是一个真正的斯坦福学生，这么好，为什么这么好，基思是一个非常非常好的演讲，他的作业真的很难，但我觉得他们真的很擅长教你，材料，或者像找像戳洞，就像你不知道的地方。

然后像教你如何喜欢，学会它，我不知道如何解释清楚，但我只是觉得这是一门很有质量的课，我真的很喜欢我找不到比这更好的插头了，如果我从另一个教育者那里得到输血，我要基思施瓦茨的血，他有点不对劲，他精力充沛。

如果我能得到一点，我很想从他那里偷一点，他是个了不起的教练，他是个很棒的讲师，他很在乎，他写的作业很棒，是的，是的，他真棒，他和辛西娅下个季度会做得很好在1：03。

所以你知道有些学生避开零七是因为他们觉得太难了，一些学生避开一零三，因为他们不想学习映射证明理论，别担心，它们都很有趣，都很有价值，你会，你穿上会很好看的，你会对它们感兴趣的。

接下来还有一大堆其他的计算机课程，你通常想拿你的117然后拿你的123，我会说，但在那之后很多东西都打开了，一旦你知道了一些基本的东西，你可以拿很多其他的，在这一点上，依赖关系树打开了很多，嗯。

你可以拿一百零八，这就像用Java构建更大的应用程序，比如学习如何写作，你知道我们写的大多数程序都没那么大，就有多少文件、类和关系而言，我是说，也许斯坦福一二三开始有很多，但是一百零八。

你真的做了更大的事情，花了更多的时间，更多的星期，你可以和团队一起工作，我相信现在他们也有一些安卓应用程序，所以你学会了如何做得更大，里面有真正的应用程序，那很酷，九对一是下一门概率论课程。

真的给了你很多关于概率和统计的好直觉，我们用在，CS，克里斯·皮克教导他也是一个非凡的教练，我很羡慕我的很多其他同事，我喜欢Web开发，所以你可以拿着，那是一四二。

他们想让你在学习Web开发之前先学习107，只是因为他们想让你有那些编程的肌肉，他们想让你知道，UNIX和Git以及诸如此类的东西，嗯hci真的很酷，你设计和规范，你知道你想出了计划和设计。

还有一个大应用程序的用户界面，然后你花了整个季度的大部分时间在一个团队中建立它，这真的很整洁，所以这就是你在课堂上，您构建自己的项目，你不遵循别人的项目规范，然后当你用完它，你就会喜欢，向人们炫耀。

你可以去参加工作面试，告诉他们这件事，诸如此类的事情，所以还有一大堆其他的东西，我想提到几个课程的数字，你可能不会想到去看，我们的第一道菜是93号，这是一种捕获所有课程的号码，我们在那里讨论特别主题。

这就像如果有人只是随机说嘿，我想在春天教一门大数据课程，去提交一个新的课程号需要一点工作，按时间表做的，所以他们就叫它193，他们只是把它放在那里，他们说X区是教授教的大数据课，琼斯什么的。

所以在任何给定的季度，如果你去看看，可能有一些很酷的东西只在那年的那个季度提供，有些会复发，有一个特别的，九十三便士，哪个是iPhone应用程序开发课程，每个人都喜欢，如果你有一部iPhone。

或者如果你想为iPhone开发应用程序，那是一门很好的课，很多这样的课程都需要一个零七作为预科，所以你想先拿那个，他们中的一些人会让你跳过零七，但最主要的是他们不想让你跳过，因为他们希望你知道一些。

还有一堂课，不幸的是，它只提供，通常在电话中，但它叫CS 9，在为面试做准备，你可能想看看明年秋天，一整节课，你在那里练习面试问题，如果能得到实习机会就太好了，大二，如果你想看看课程编号，少于一百人。

两位数字的航班号，这些通常是由学生讲授的课程，你可能会说我不知道，我不知道我是否想像一个学生一样相信自己去做一门课，但这往往是像部门领导或前SLS的人，他们非常喜欢教书，他们就像，我想就像。

现在组成我自己的整个班级，他们通常做得很不错，他们中的一些人不断重复，他们要把它们传给另一个学生，当那个人毕业的时候，所以其中一些课程已经提供了十次，有关于JavaScript和Python的。

这是个接东西的好地方，就像一个小技巧，像一种语言什么的，那里有，是啊，是啊，Web编程，下面有各种各样的小东西，所以不要睡在，就像，低于100个课程编号，事实上，我应该列出一个，但我忽略了，在那里吗？

我相信它的编号是CS 50，这是社会公益的CS，就像嘿，我们能用科技来帮助人们吗，那就太好了，所以你可以上一整节课来找出如何帮助，我觉得这样做很好，这也是学生驱动的，所以有很多好的课程，就像一百个南方。

去看看那些，所以无论如何，是啊，是啊，所有这些都向你敞开了大门，一旦你走出一零零七，你可以在春天或明年秋天看很多这样的东西，或者类似的东西，嗯，关于这些有什么问题吗，或者到目前为止的任何其他课程。

我一直在展示，只是想给你一份菜单，列出你在这之后可以做的事情，你知道的，好啦，最棒的是所有这些课程都是由伟大的人教的，这些都是关心教学的人，他们办得很好，我只是很自豪，你知道的，我不必告诉你们。

别在春天拿零九什么的，因为琼斯在教，你知道我不必喜欢，把这些纸条传给你们，这些都是伟大的人，他们做得很好，如果你爱上了CS，也许你们中的一些人已经有了，我们有个少校，你可以，你可以，你可以主修这个。

如果你想，我们基本上可以说是世界上，呃CS现在排名部门，我会说这些排名是因为这基本上是基于研究，所以他们把我们排在第一，那是因为我们在某个会议上发表了一些论文，可能不是你最关心的地方，就像，课好吗。

我在这里会有很好的体验吗，作为一个学生，这可能是你真正关心的，但我会说我认为我们，他们没有评级，但我敢说，我想如果他们这么做了，我们也会得到第一名，因为我知道我有偏见，但我认为上下教职员工。

他们中的很多人都很关心教学，坦率地说，有很多学校不是这样的，在那里他们更关心他们的研究，关于他们的赠款和资金，你们就像最后的优先事项，我不认为这里的情况是这样的，我很自豪能和这些伟大的人一起工作。

这里的学生真棒，大量的能量，看看经济，科技行业现在很棒，现在是学计算机的大好时机，有很多工作，大量的研究，很多机会，如果你对这个不太感兴趣，或者你已经在学别的专业了，否则你的父母不会让你主修计算机。

或者我所知道的，事情就是这样，有时你可以辅修CS，你要做的就是完成1 0 3 1 0 7，然后是另一门理论课，你再吃两颗就完了，这不是那么糟糕的小调在cs，会给你很多地方，你也可以。

如果你要完成其他学位，你快做完了，也许你可以考虑成为一个伟大的，你知道的，主码头，艺术系硕士学位，即使你来自其他部门，你还可以和我们一起做，我们有一大堆其他专业像CS，和其他东西混在一起，你知道的。

SIM有很多不同的学科，比如语言学和心理学，和艾，有监控录像，这是迈克数学和CS的混合，大多数情况下，E是一些管理业务的东西，与CS混合在一起，总是有这么多度，你知道的，如果你买的是我卖的东西。

但你不想为了见我们而改变你的一生，我们有很多选择来吧来吧，你知道我们有很多选择，如果你想做更多，如果你不想做这些事，再上几节课在你的简历上还是不错的，所以你知道，你知道的越多，是啊，是啊，继续谈论感官。

我仍然不明白那是什么感觉，它与CS和CS加号有什么不同，另外，在什么意义上，你只是喜欢上计算机课，还有心理学课，就像，我觉得辛普森一家也很难简洁地描述，但它是几个不同领域的混合体。

你专注于符号、语言、交流、智力等等，所以你学习自然语言处理之类的东西，比如你如何看待句子并理解它们的意思，你是学语言学的，口语和计算语言，比如你学习的语言有哪些有趣的性质，比如人和电脑是如何互动的。

你怎么知道图灵测试，制造模仿人类行为模式的机器人和系统，你做了很多这样的事情，它把很多不同的学科聚集在一起，它是为那些对许多不同领域感兴趣的人设计的，他们喜欢CS。

但他们不只是想每个季度都拿走CS的一切，我是说我们有很多不同的专业，我们加上其他东西，这可能是非常非常有趣的事情，我的意思是我鼓励你去谷歌更多关于它，如果你想，或者我们可以下课再谈，我只剩一两分钟了。

所以让我再说一两件事，嗯，如果你想了解更多，这里有一些快速射击的东西，我只需要在这里一两分钟内完成，但你只想做得更多，有很多在线课程，你可以去看，你知道的，Coursera或斯坦福，YouTube讲座。

就像我写的一样，你知道的，但还有其他像，有一个叫黑客阵列，在那里你黑客攻击并处理代码问题，有很多很酷的游戏，你可以在那里获得积分，每周进行挑战，保持编码技能新鲜的好方法，如果你想实习，你可以做很多事情。

嗯，我们的第一份材料包含了很多实习面试之类的内容，去电脑论坛，这是我们主要的行业联系，如果你申请少校，或者你去找这些人，去他们的网站注册他们的邮件列表，他们发送了很多行业招聘公告之类的东西。

你现在就会得到那些，你可能会说很好，我只是个新生，或者我只拿了X，我不知道我是否准备好了，好的，就像他们中的一些人想要更多的经验，你有，有一堆公司为新生提供实习机会，我时间不多，但在幻灯片上。

下面是一些应用程序的链接和另一张幻灯片，有一大堆工作需要新生，或者想让那些只做介绍性工作的人，他们想让你申请这些，如果你今年夏天想做点什么，稍后去看这些幻灯片，点击其中的一些东西，还有一大堆。

只要谷歌为CS，大一实习，他们称之为，他们经常称他们为新生实习，即使你不是新生，这基本上是类似的代码，我只上过两三节课，但我想实习，基本上，是啊，是啊，我要说的最后一件事是CS的伟大之处在于。

你可以自学很多东西，所以如果你想在休息时间做点什么，去自学如何创建一个html页面，或者事情不需要那么长时间，你可以想办法或者去谷歌，就像，如何用Python什么的重写你的家庭作业。

只是如果你想要一些小项目，做些简单的事，可能会自学一些东西，所以我没时间了，所以我只想说，非常感谢，你们是很棒的班级，星期一见，祝你好运，谢谢伙计们，哎呦，好啦，我取消期末考试，每个人都得a，我爱你们。

那是个玩笑，那是个玩笑，谢谢再见，星期一伙计们。

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P3：Lecture 03 - Strings, Streams, Grids - 加加zero - BV1By411h75g

好啦，所以说，我们何不现在就开始呢？好啦，嘿嘿，欢迎回来，这是我们的第三堂课，今天是星期五，希望你们一切都好，在我开始之前有几个简短的声明，一件事是在这个周末，我希望你们都去我们的网站填写你的偏好。

你什么时候可以去一个部分，下周初我们会把你分配到一个部门，现在呢，通常在我的网站上，在班级网站的首页上已经有一个链接可以做到这一点，但它有一些问题，所以我会在课后发布一个链接，的。

部分注册是通过这个其他网站完成的，叫做CS一九十八斯坦福EDU，他们告诉我链接在那里，但我看不出来，我不知道，也许我没看到，因为我是老师，也许它没有显示链接给我，但他们告诉我。

如果你去CS一九十八斯坦福大学，你会看到一个链接来注册你的部分，但又一次，就像我找不到我版本的链接一样，所以不要看，好啦，上面写着适用于，如果你想当组长的话，所以无论如何，好啦，误导，哎呦，所以在这里。

如果你是个学生，你可以报名，好啦，凉凉的凉凉的，所以我会发布一个直接链接到那个，下课后，你可以一直做到周末，这不是先到先得，所以你不必比赛，也不必做对，这一秒钟他们等到星期一，然后他们抓住所有的名字。

他们运行一个算法，他们指派你，所以你会，你周末再去，我会发邮件提醒你的，我们的第一个家庭作业结束了，我以后再谈，但它使用了今天讲座结束时的材料。

它有三个部分。

你得做一个疯狂的Libs节目，一个生活游戏程序和一个Photoshop程序，你还记得我说过，你呆在这个班就是个白痴对吧，仅供参考，这部分是一零六乙的家庭作业，所以你必须这么做，再加上另外两个节目，嗯。

这又是因为我不是个好人，但是是的，无论如何，第一个作业已经完成了，它将使用第一周的材料，下星期五到期，所以好吧。

说了这么多，我想我现在要开始上课材料了，所以我们一直在讨论如何做弦，或者对不起，如何在C++中做函数，下一个主题是字符串，你们已经知道另一种语言的字符串了。

像Java、Python或JavaScript，所以我不想把所有的时间都花在重新学习上，字符串从一开始就是什么，但是让我们来谈谈字符串的C++问题，对呀，所以如果你想用字符串。

您必须包含一个名为String的库，我在这里用方括号，这是引号，这说明了字符串库的什么，这是一个，是啊，是啊，这是一个，这是一个系统库，那不是斯坦福，本地项目库，它只是C++语言的一部分。

所以如果你想使用字符串，您必须包含这个字符串文件，所以一旦你这么做了，可以创建字符串变量，作为这样的问候，小琐事，我想再次回答关于这些空间的一百个问题，但是类字符串来自std名称空间。

所以如果你不说使用命名空间，STd，你必须写STD冒号冒号字符串，但不管怎样，这就是创建字符串对象的方法，你们知道弦是什么，它们是一系列的人物，让我们来谈谈C加的区别。

就像在Java和大多数其他语言中一样，字符串有索引，其中字符索引为零，一个，二三以此类推，嗯，字符串用引号表示，就像在Java中一样，大多数其他语言都使用前面有反斜杠的序列。

比如用斜杠t表示制表符或斜杠，引号的引号，很多东西都是一样的，但也有一些不同，就像一些方法的名称，对字符串调用的函数，你们的名字不一样，它们的行为略有不同，所以我会给你看那些，还有。

有一些结构上的差异很有趣，最令人惊讶的是，实际上有两种不同类型的字符串，C加加，我一会儿会更多地讨论这个问题，但这就像是学习C++语言的乐趣之一，基本上又是这样，字符串的字符具有从零开始的索引。

每个单独的字符都作为类型care的值存储在其中，您可以使用方括号访问单个字符，这实际上是一些语言做不到的，比如Java做不到，您必须调用一个方法才能在Java中取出字符，你可以用这些括号。

就像你用数组或类似的东西，所以如果我说括号3，这意味着索引3的字符，它是一个大写的T，还有一种方法叫ACT，就像Java Care Act方法，完全一样，你通过一个索引，它会返回存储在那里的字符。

但大多数人只是用方括号，如果你学过整数和字符，大多数语言在两者之间都有某种映射，字符实际上存储在计算机中的地方，带着数字代码，就像ASCII码或Unicode，或者类似的东西，实际上等价于整数，七十二。

你可以在这两个东西之间键入强制转换，在这门课上，我们不会做很多这样的事情，但这个概念是，你知道在很多编程语言中很常见，好的，好的，所以这是一种基本的东西，下面是一些你可以用C++用字符串做的事情。

你可以用加号把它们连接起来，比如m a r加a 2，我觉得马蒂，这在Java中是很正常的，对吧，在C++中可以做的一件事，在很多语言中都做不到，你可以使用大于或小于这样的运算符来比较。

订购是根据ASCII值完成的，基本上意味着区分大小写的字母顺序，与，我觉得大写比小写少是有原因的，但是嗯，也可以使用等于运算符和不等于运算符，问两个字符串是否相同，如果你是一个Java人，你还记得吗。

或者你真的不能在Java中做到这一点，对吧，你如何比较它在Java中是否相同，是啊，是啊，再次感谢，如果你不懂Java，那也没关系，但是你写了一个叫做dot equals的方法，情商，如果你不这么做。

它的行为不太正常，你不需要这么做，C++加上运算符将只是工作侧记，原因是，是因为C++有一个Java没有的特性，这就是运算符重载，我稍后会讲到，这意味着您可以定义操作符来处理其他类型。

他们以前没有合作过，所以它在C++中工作，做你想做的事情，是啊，是啊，那么使用加号运算符和，如果你想去中国的溪流，在打印出来之前，就像你用，当您使用计数时，然后你用其他的运算符，所以他的问题在这里。

我在做加号，蓝色的琴弦在一起，但在以前的讲座中，当我想打印，就像一行文字，然后一个变量什么的，我以前喜欢小于小于，我为什么不直接用加号呢，加号在这里我们有加号，为什么我不直接用加号呢。

原因是因为加号只适用于带有其他字符串的字符串，不是绳子，加上一个int而不是字符串，加上一个双不串，加上任何东西，所以你必须在最后调用一个转换函数，所以决定就是，小于小于是一种更好的风格，所以是的。

这是个好问题，虽然是的，当我试图连接，当连接在一起的时候，两根弦，当我不和水力压裂操作员一起出去的时候，他给了我一个，你在连接字符串时出错了，嗯，给大家看一下，我觉得这可能和。

我会在接下来的几张幻灯片上给你看，它是关于这两种不同类型的字符串，我仔细挑选了这些例子，因为与这些例子有轻微的偏差，突然就不起作用了，所以我对你撒了一会儿谎，然后我要让你看看这一切有多糟糕，但我想现在。

我试图建立，你知道我想，我想要一个情感上的转变，就像讲座中间的结局，你知道查一下，我想让你这样想，你知道吗，我打赌你们中的一些人现在很酷，这看起来很酷，就像它和Java或其他什么差不多一样，哦。

我可以做的更少，更大，等于，哎呦，这样比较好，这太棒了，这太酷了，嗯，我给你看，我给你看，但我马上就到，所以C++中字符串的另一个不同之处，在许多其他语言中，如Java，Python。

JavaScript是在C++中，你可以变异，您可以更改字符串，这里我有一根绳子，是存放马蒂的，如果我叫一支笔，它现在改变了一个来储存马蒂的脚步，你可能会说很好，这不就像加等于吗，我是说。

当然你可以把它从马蒂舞改成马蒂舞，但不同的是，在大多数语言中，更改字符串的操作，实际上返回一个新字符串，如果你想把新的字符串存储在旧的字符串中，你可以，但这不是回报，这就像进入现有的字符串并扰乱它。

所以就像一个，我不知道有一个微妙的概念，但我正在修改一个现有的对象，而不是在旧的基础上创造新的，这两件事之间有一个重要的区别，所以有像擦除这样的方法，您可以从字符串中删除字符，他们现在走了。

所以这很有趣，好啦，下面是一些你可以用字符串做的事情，但让我再给你看一些，所以这张幻灯片只是列出了字符串内部的一堆方法，技术上C加+，我们不用方法这个词，你应该叫它成员函数，它是一个对象内部的函数。

它是一个成员函数，但有时我会说方法，但这些函数中的大多数与某些函数几乎相同，你以前用你的语言看到过，像java之类的，就像有一个比较功能，与Java相比，这有点像，有趣的是，就像Java中的索引。

有和Java相同的长度，有替换相同的，有一些骚动，这与Java中的子字符串相同，所以很多这个，我不打算在这张幻灯片上花很多时间，因为大多数情况下，这只是你听说过的名字的映射，到C++使用的名称。

其中一些函数具有轻微的，哦哇哦，哇塞，巴顿·奥斯瓦尔德在推特上谈论他的青春期，那太好了。

我们能不能静音？那怎么样，好啦。

什么对不起，我已经我已经得到了各种各样的东西，我在一次演讲中得到的最喜欢的弹出窗口，我弹出了一个说，我得到了很多东西，我收到我女朋友的消息，现在的妻子，我可能不想出现在屏幕上，我有各种各样的。

我要说的就这些，问题，是啊，是啊，有屏幕尺寸吗，这个不行，他们是一样的，为什么有两个名字，这是因为它们想与某些其他对象兼容，有大小方法或长度方法的，在某些情况下，他们希望同样的方法可用。

在很多不同的班级，是啊，是啊，当你谈论追加和喜欢加等于的区别时，那是不是意味着追加更有效率，或者不知何故，我不太担心这些方法的效率，我是说其中一些有效率方面，就像如果你做了一根全新的弦。

它可能得把它复制到内存中，我想说这些事情更重要，当你在处理一根很长的绳子时，如果字符串短，这真的没什么大不了的，或者如果你在一个循环中做了一百万次这个操作，开始重要了。

我们稍后会讲一大堆关于算法效率的问题，所以有些情况下我们会关心这一点，就像，一个例子是，如果我要在一个字符串中建立一大堆数据，然后把所有这些都转储到一个文件中，数据可能很长。

然后我调用什么方法可能很重要，但实际上我要教你一些技巧，即使在今天的讲座中，有一些方法可以逐渐建立一个结果，作为一个不涉及昂贵计算的字符串，所以我的意思是我不会太关注性能的影响，但我想我要说的是，那个。

这些函数的许多实现是，你可能会猜到，如果你说嘿，我想找到这根绳子，它必须喜欢，在字母中循环找到它，所以如果有更多的信，需要更长的时间，所以很多时候，你对什么需要更多时间或更少时间的直觉。

就像问绳子的长度，它只是把它作为一个int存储在里面，所以这是非常快的，即使你叫了很多次，但我们会更多地讨论性能，当我们走得更远，是啊，是啊，应用程序中没有真实，嗯，有，但是他们有偏好吗，A加等于针脚。

嗯，我在可能的时候使用操作员，一支笔就像，你知道的，修改到位，所以你可以用加号而不用加号，如果你明白我的意思，所以我喜欢加和加等于，因为我在学C++之前学过Java，但我不认为他们中有一个是对的。

另一个是错的，你可以用任何你想要的东西在你的家庭作业和塞在后面，这样的处理怎么样，哦哦耶，我对记忆还没怎么做，我不打算多谈，基本上，所有这些方法都做了合理的事情，就像你在想的那样。

它有足够的内存来存储字符串中的这些字符吗，一切都会水落石出的，它会，会处理好的，你现在还不用担心记忆之类的问题，是的，是的，所以我们你用，Plus等于上一张幻灯片中的字符串，但是加等于。

在角色上不起作用，加上这里的流示例的相等工作，但还有其他类型的它不起作用，就像你说的，是啊，是啊，我一会儿再谈这个，但这适用于连接其他字符串的字符串，还有很多其他的事情是行不通的，所以它在这方面不像。

Java、Python或JavaScript将是，这些方法中我想强调的唯一一个，这些方法中的大多数都是明智的，简单的事情，我要提到的一件事是发现和我们的发现，就像，从后面开始，找到大多数搜索东西的方法。

你知道他们就像索引的结尾一样回报你，它在哪里找到了那东西，所以你可以想象，如果它找不到那根弦，也许它会像负数一样返回，无效索引，它实际上不会返回负1，它返回一个常量，称为流，冒号，停顿中的冒号。

这意味着它不是位置，我不知道所以喜欢，这是当我回到C++时的一件事，我开始用字符串编码，那是我经常忘记的一个功能，哦耶，如果你检查它是否等于负1，它实际上从来不等于负1，所以这是错误的测试。

所以我确实写了一些东西，比如用这三个字符串，那么我们应该写字符串冒号冒号和，哦，这个极端，嗯是的，看起来需要空间语法，但我想你导入了性病的命名空间，但这类似于访问类的静态成员的语法，在Java中。

你用C++说类名点成员，你说类名冒号冒号，记住，所以我认为即使使用和进口之类的东西，你还是要说，你不能只是写和停顿，我想你得写字符串和输入，好啦，还有一些其他的方法可以处理字符串。

我们斯坦福项目的本地产品，我们给你的，如果包含我们称为字符串库的本地库，或者你现在得到一些这些，它们的语法有一点是它们不是，流内部的方法，像s点法，取而代之的是，它是一个全局函数。

我们将字符串作为参数传递，这些不同的原因，因为我们在斯坦福，没有能力修改流和类的内容，你知道我的意思，我们不能向现有类添加方法，我们有一些方法将字符串作为参数。

这些方法大多是为了复制java特性而设计的，就像没有结束和开始，你可以打电话，找到并检查它是不是零，看看它是不是以什么开始的，但这更容易，我们还有转换功能，这些都很有帮助，你问的是。

有人问普林在离职声明上的事，如果你说整数加字符串，您可以用这种方式将字符串与提示连接起来，但当然瓦卡瓦卡可能比那干净一点，但这些是在类型之间转换的有用工具，你不会相信在C++中很难做到。

所以只有很少的功能来做到这一点，很不错，以及其他一些，一些其他的东西，是啊，是啊，所以序列没有像，类似于默认强制转换函数，哦好吧，铅字铸造有几种方法，但你不能在你的绳子上投下一个末端。

字体铸造在那种情况下不能正常工作，如果你想让它成为一条小溪，你真的想写出这些看起来像结尾数字的字符，这就有点复杂了，所以基本上这样做有点烦人，没有帮手，所以我们提供这些，所以当你用字符串来整型时。

你有一个由字母表组成的字符串，那是什么，哦如果你，如果你试图把这些和非法移民联系起来，像你一样，你说直线整数，如果你通过一二三四，然后回到最后，一二三四，但如果你像马蒂·斯德普一样，它不是。

我想他们抛出了一个错误异常，类似的事情，崩溃被动非法数据，还有其他方法我没有在这里列出，就像有一个叫字符串是整数，它是一个布尔值，所以你可以说，如果字符串是整数，然后将字符串转换为整数。

图书馆里还有其他东西，我鼓励你看看文件，所以让我提一下我们已经讨论过的几件事，在阅读中看到和看到，你知道用户的输入和输出，我以前教过你，你可能不想直接使用cn，相反，您希望调用这些帮助器函数。

比如得到整数，获取线路，这种东西，所以如果你试着阅读流，用z可以做到这一点，但它读一个字，然后你剩下的输入，它会读其余的，如果你再叫一次，如果你再读一次c in，有时你不想要一个字，你想要一整条线。

我们斯坦福图书馆要做到这一点的方法是调用get line，不管他们打什么，整条输出线将是，输入将被读取，有一个标准的功能，那不是斯坦福，那叫得到线，但这需要两个参数，它带你去你想读的地方。

您想将其存储在哪个字符串中，嗯，这个get行命令，我没有使用任何返回值，那么你认为我是如何从get line函数中得到答案的呢，输出橙色，你在后面看到了什么，是啊，是啊，你到这里来，你要说什么，是啊。

是啊，是啊，是啊，它是一个参考参数，它作为输出参数存储在其中，如果我是说你在幻灯片上看不到，很抱歉，但不管怎样，主要是如果我想从用户那里读取行，我把这个叫做，用大写获取线函数，我呃，这里有个练习。

但我落后了，所以说，我不会做的，不过，我告诉你，如果你想用溪流练习，这只是一个循环的东西，打印单词的子字符串，将其作为参数发送，我还没说呢，我有一个工具，我想你可能想试试，它是一个练习工具。

这叫做一步一步的代码，我把我的名字放进它的名字里，无耻阴谋，但不管怎样，这是一个只有一个小文本框的网站。

您可以键入代码并运行它，它会帮你测试的，所以如果你去那里。

你可以说我想做这个名字，钻石的事，你在这里打你的答案，你提交它，它会告诉你。

如果你答对了什么的，所以你知道有些幻灯片有一个小标志。

这意味着该练习可以在该网站上获得，然后如果你去班级网页，它与其中一些问题有直接联系，您可以尝试。

所以我相信实践，不管你用不喜欢我的哑巴网站，我觉得练习很好，我认为这就是学生学习的方式，只是通过去尝试一些东西，听我说话，你可能不会学到很多，但去试试吧，你会做得更好的，不管怎样，这是一个练习。

你可以看看，这里有一些代码，如果你，如果你想偷看它的解决方案，在这里的幻灯片里，但是嗯，我提到过C++中有两种类型的流，所以现在一切都分崩离析了，到目前为止还好，但现在情况变糟了。

C++是建立在另一种叫做C的语言上的，他们试图让它不相容，使用C语言，C有自己类型的字符串，C++加上了我刚才给你们看的所有幻灯片，我之前给你看过，这些是c加上字符串，那些是那些是好的溪流。

我们喜欢那些，他们大多以明智的方式行事，古老的语言有它自己的弦，那些也还在那里，它们都存在于语言中，你必须主要，你不必处理C类型的字符串，但有时你会，因此，我必须稍微谈谈他们，所以如果你写字符串引号。

从技术上讲，这是一个C字符串到旧的类型，但是，如果你说字符串s等于引号中的东西，它会把它转换成一个很好的c+，所以我的大部分代码，这就是我要做的，但是，我以前给你看的东西都没用，你不能对它们调用方法。

比如长度、查找或子字符串，这些方法都不存在，C字符串根本没有任何方法，你不能把它们和，加等于，可能是你的窃丨听丨器，你有我给你看的所有东西，对C弦不起作用，他们基本上什么都不做，我想获得有效字符的括号。

但几乎没有别的，为什么它不支持任何东西，因为C语言是一种非常小的语言，它只是没有提供很多东西，C++流提供了更多的东西，所以好吧，如果不想使用这些C字符串，一般来说我想说的是，让我们尽可能地避免这些。

如果你不想用它们，确保将字符串存储在C++字符串变量中，如果您确实需要将C加号字符串转换回C字符串，有一个函数叫C，但我们不会经常用那个，所以好吧听着，让我试着告诉你在哪里你可能会遇到C字符串。

以及它会如何扰乱您的代码，所以如果你打个招呼，加上那里看起来很无辜，这在Java中很好用，但技术上是行不通的，因为那是个c弦那是个c弦，我试着把它们加在一起，也许你会说等等，我早就想好了。

我以为你告诉过我，如果我把它储存成那样的溪流，它会很好地转化它，但是请记住代码是如何运行的，它先从右边跑，然后它储存它在左边出售，所以它不做转换，直到它完成大惊小怪和东西，所以这实际上是糟糕的，事实上。

这不仅不好，但它甚至不会导致编译器错误，它让你写，然后当它运行的时候，它只是做疯狂的事情，程序中断和崩溃，现在呢，它实际上做得好的是什么，从技术上讲，它所做的与一个叫做指针的特性有关，我今天真的不想谈。

它正在获取这个脚本的内存地址，并将其添加到屏幕的内存地址中，不管那个内存地址，它把它变成了那个，这可能是一些垃圾或出界什么的，程序要么崩溃要么崩溃，只是这样很傻，但这是语言的一部分。

这是一件非常常见的事情，学生们这样做在C++中是行不通的，是啊，是啊，你说过我们有很多强项，除非我的草原从种子，但对类似的人来说，我不能涂得像条带子，嗯，您可以写出这样的东西，而不包括流库。

因为这些是c弦，但是如果要声明这样的变量，你现在需要包括那个屏幕，如果您有一个不包含字符串头的文件，你可以宣布这些，这可能是因为项目中的其他文件确实包含了流，他们也在每一个。

所以如果项目中的其他文件包括，然后通常它也会传播到您的文件中，但总得有人把它包括在内，否则就没用了，是啊，是啊，所以那不起作用，断了，嗯，那不管用，那是那是相似的，是一根弦加上一份牵挂。

像猴子一样用内存地址，所以那也不好，一个字符串加上一个整型数对于内存地址也有同样的作用，它转到字符串high的内存地址，并向前移动4-1字节，哦天啊，所以实际上真正有趣的是，如果你有一根很长的绳子。

然后你说那根很长的绳子，加十，它会给你第10个字母的直，因为那是10字节前的东西，反正，什么都不能用，Plus不适用于C字符串，它产生垃圾，所以这里有另一个案例，这个看起来可能更好。

所以我实际上把它存储为一个C++字符串，然后我加了四个一个赞，我想说五个换一个，但它却飞得很高，括号，4-1碰巧是括号字符的讨厌数值，所以它认为我在添加一个字符，不是整数，所以它没有做正确的事情，是啊。

是啊，有人问我，你能把字符串传递给int吗，这就是我在这里做的，我有一个三，四，二，我把它转换成一个int，一分钟前我说不，你不可能做得那么好，比那更糟，你能做到的，当你试图这么做的时候。

它会做一堆废话，所以它把这根弦，不管内存地址是什么，流恰好存储在那里，将内存地址转换为int并将其存储为inde，所以就像你认为你在储存四，二，四，二，但实际上是八百万，二十七万六千，随便啦。

只是一些恰好存储在里面的内存地址，就像这个十六进制的位置，哦，天哪，所以这些最糟糕的不是，它们是错误的，编译器不会告诉你任何事情，它很乐意编译，这些示例中的大多数取决于您拥有的编译器的哪个版本。

但大多数都编译得很好，当你运行它的时候，你的程序会做疯狂的事情，很容易意外地做这些事情，是啊，是啊，在前面的幻灯片中，代码是1加上引号，差不多吧，是啊，是啊，是啊，是啊，这是可行的，因为我把它转换为。

一个c+的字符串，但是t y是c没错，所以这仍然是一个c字符串，但是c加上字符串加上c字符串，它做了正确的事情，所以只要他们中的一个或另一个是，你知道增强的，一切都会好起来的，所以是的，很微妙。

但是如果你把这个加T移到这里，它在转换前做加法，但这强制转换为这里的好字符串，然后这个就会被那个拯救，但是是的，你要担心这些事情是不是很疯狂，所以嗯，这只是不幸，只是我们在这里必须忍受的事情。

所以这些是你可能会遇到的bug，哦耶，问题是的，所以在你说控制h之前已经包括了引流库，所以如果你放两次，不错嘛，如果两次包含同一个库，还不错，不会弄坏任何东西的，他们有警卫检查那些东西，一切都会好的。

所以这里有一些方法可以修复上一张幻灯片上的这些bug，所以哎呀，对不起，嗯，如果显式地将字符串括号写高，它基本上调用屏幕C加加字符串构造函数，并传递一个现在已经转换的C字符串参数，再加上那个管用。

或者我们回去的那个很高，加上一个工作良好的C流，那些很酷，这个实际上工作于一个被转换的字符串，再加上有效的护理，因为当你添加一些东西，它假设它是一个角色，所以没关系，嗯，如果你真的想转换字符串四。

两个什么的，您可以使用这些转换函数，如字符串到整数整数区，所以所有这些事情都有解决办法，但你必须意识到他们，对射线进行操作的函数，也在相同的，问题是字符数组和c字符串，是啊，是啊，我的意思是。

我想主要是在这个问题上下注，我是说在C弦的老风格中，它们实际上是一个存储护理值的数组，那都是c弦，真的是，它是一个字符数组的内存地址，所以C++函数，要求字符串参数，有可能给他们传递C字符串。

或者C加上字符串，甚至是字符数组，它会以某种方式处理所有这些，但总的来说，我会尽量避免显式地使用c字符串，所以我不会在课堂上遇到这种情况，但是有一些微妙的语法问题。

当您尝试将两种类型的字符串混合在一起时，只是一个例子，这样可以让你有你的，是啊，是啊，如果它是高的加上那里加上马蒂加步骤，那就没问题了，如果只有第一个被转换，因为每一个加法都是按顺序进行的。

这个加号表示c加号是直的，嗨，在那里，加上马蒂做了一个C加上它就像消耗了整个，是啊，是啊，其中一个第一个是，是啊，是啊，但如果你有高加那里加字符串边距，那么第一个广告就是非，是啊，是啊，所以你可以。

有这么多不同的方法，你可以打破这东西，你所做的工作，在本例中，圆周率加上弦，高加弦也行，只要你在做二进制加法，其中一个很好，那么整体效果会很好，他们喜欢四个我们被塞进其中一个弦里，但不是第一个。

我应该用绳子，它是什么，我是说，我想有些东西你可以自己去试试，但基本上如果你，如果你前两个不是，他们中的任何一个，C加加字符串，你会有麻烦的，但只要你在做加加加，只要前两个中的一个是C。

加号加号应该没问题，我说看，我很难记住一些微妙的地方，我尽量避免代码，我想可能会和这些东西发生冲突，所以最重要的是要小心，你要知道，如果你看到一些奇怪的东西，你可能会遇到这种事情。

我只是想让你意识到这一点，所以没关系，都说了，我想跳到另一个滑梯上，我想谈谈流和网格，我可能得加速一点以确保，我今天做的够多了，所以溪流是用来阅读和写作的，文件和网格是一个二维数组，像数据结构。

我们两个都要用，和所有其他的东西，我们一直在谈论我们的第一次家庭作业，所以让我试着在这里开始，如果要读取文件，有一个图书馆，您可以包括它称为F流文件流，那是一个系统库，从括号里可以看出，F流是一个库。

其中包括名为if流输入文件流的类，和两个F流输出文件流，这些是您可以用来读取输入或将输出正确地输出到文件的东西，好消息是它们的行为几乎完全相同，c out和c n see out是一个对象的例子。

这很像它去，f流和cn是一个很像i f流的对象，它们如此相似的原因是因为它们使用了一种叫做继承的东西，它们彼此共享代码和特性，所以这很酷，因为一旦我们学会了怎么做。

您实际上可以用非常相似的语法写入文件和从文件中读取，那太好了，今天我不打算教你们太多关于物品和继承的知识，但这是在这一切的背景下发生的，如果创建一个文件对象和一个输入文件对象，如果街道。

以下是它的不同成员，你可以打开一个文件，把某个文件传给它，现在你正在从地图文件中读取数据，您可以使用，获取行或此箭头运算符，然后当你做完，你可以把文件附上，那是我变成蓝色的时候。

我认为你在这里真正需要的，还有很多其他的方法，但主要是这样，我是说，如果您必须在以前的课程中读取文件或数据，使用缓冲阅读器或扫描仪，或者某种文件对象，这和那没什么不同，是啊，是啊，如果文件不存在。

那么打开是否返回负值，或者是的，如果你试图打开一个文件，我很确定，这样做的结果是，它将文件置于所谓的失败状态，所以你可以说打开，然后检查，如果文件失败，基本上，好啦，这里有一个简短的例子。

如果要打开文件，循环读取每一行，对线条做点什么，然后关闭文件，你是这样做的，声明文件流，您打开文件并编写一个循环，如下所示，你做一个弹簧叫做线，虽然有一个混合线，我可以得到，我把这条线打印出来。

然后我会关闭文件，我想大部分都没问题，但是这中间有点奇怪，向右看，就像我说的，直线，野生盖特林，那么像这样的事情是什么呢，当循环，我想把注意力集中在那句狂野的台词上，输入逗号行。

那么我对这个参数了解多少，这是一条参考得到线，看这里，从这里阅读，将结果存储在这里，它是通过引用出来的，这是一个参考参数，我们上次就知道了，然后我说，而这，那么我怎么能在一段时间内调用函数呢，像这样。

这个函数是什么意思，它返回一个布尔值，是呀，它返回true，如果它能读懂一行，如果它不是这样，它是假的，这看起来很奇怪，但是一旦你习惯了，你就是这么做的，还有一行要读，用线条做点什么。

有几个东西看起来与Java之类的东西不同，就像在Java中一样，你会说喜欢，如果输入等于新，如果流，或者类似的东西，那是Java语法，那不是c加+的方法，是吗？C加加使一个对象，你只要写它的类型和名字。

这相当于说新的，无论您创建了什么，现在都打开一个新对象，现在初始化它以从后面的某个地方读取数据，如果你把一个表情放在一段时间内，条件或，又不是说，会尝试，C++在其他布尔类型之间确实有一些转换。

所以如果你有一个整数，您可以在if语句中使用它，如果整数值为零，这被认为是假的，任何其他值都被认为是真的，所以有一些c加2布尔值的转换，不是每个类型都这么做的，规则可能有点棘手。

你可以从那里得到一些虫子，比如，例如，有些语言有字符串，如果字符串为空，那是假的，如果它不是空的，那就是真的，在C++中不完全是这样工作的，所以我以后会教你一些规则，但是是的，有专门针对数字整数类型的。

您可以使用布尔转换，是啊，是啊，你说过，如果你输入了，或者如果您确实喜欢打开一个名称不存在的文件，它失败了，有没有一个函数可以让你创建，是的，是的，制作新文件。

我们将使用一种叫做O F流输出文件流的东西，我马上就给你看，但是这张幻灯片还没有涵盖这一点，是啊，是啊，所以你宣布，I，什么事？我会记住的，是啊，是啊，我是说，你可以想到这个，如果你是一个Java人。

以为我写的等于新流，我去创建了新的对象，已经初始化了，它不是空的，如果你知道，空是，这东西不是空的，这是一个真实存在的物体，它已经被分配到内存中，我可以调用它的方法，这只是C++和Java的区别。

如果创建对象，它在那里，是呀，为什么输入，啊，那倒是真的，所以实际上这条线，这两个参数都是通过引用传递的，我把注意力集中在引用中的字符串上，但是输入文件流是一个引用也是正确的，这是真的。

因为我不想复制文件，或复制文件的读取器，我想从您正在使用的对象中读取，以便读者随后进入下一行，所以我想把那个对象共享到那个函数中，所以实际上在这张幻灯片中，很难写一点关于它的东西，我写了f和s。

并引用了一个文件，引用了一个字符串，我就是这个意思，是啊，是啊，所以在这张桌子上，上面说就像，我认为只有开放的方法，c c样式字符串除外，却看不到我们这些人，所以这个开放，你应该能在这里传递一根绳子。

这恰好是一个C字符串，但通常你也可以有一个c++字符串，我们以前在老麦克斯身上发现，有一个奇怪的旧编译器，你不能通过一个C+加字符串，您传递了一个C字符串，所以如果你有一个c+的字符串。

你得在上面写点c r，但我很确定苹果已经更新了他们的编译器，这样就不需要再打字了，但我不知道你们中的一些人还在像雪一样奔跑，豹和OS什么的，得到一个新的，OS将是，所以如果输入不是作为引用给出的。

但如果不是，它会创造出一个完整的副本吗，如果它是按值而不是按引用传递的，它会试图复制，实际上它会导致编译器错误，因为文件流对象没有提供复制功能，所以它不知道如何复制它，所以它会出错，所以是的。

我们会教更多关于这一点的，当我们上课的时候，但是，嗯，是啊，是啊，还有一件事我想继续前进，是啊，是啊，这是可能的，就像直接流一样，哎呦，你喜欢从输入文件到输出文件的管道吗，不是一行。

但是做一个O流很容易，然后从if流中读取并写入off流，而且是的，我们能做到的，我们一定会做那样的事，常见的错误方式，人们又这样做了，对不起，滑梯上很低，是人们说好，当输入文件没有失败时，我会读一行。

然后我将打印出与幻灯片上的代码非常相似的一行，你看到了吗，你知不知道，也许为什么红色的不那么正确，是啊，是啊，因为第一次它会失败，你得打个电话，要失败了，但你还是要处理这条线，即使这是不对的。

所以如果你打电话，也没有更多的线了，它将把文件设置为故障模式，但我还是要把它打印出来，然后我绕过去，看到它处于故障模式，所以我实际上要打印一行太多了，实际上它会把最后一行打印两次，基本上是这样。

我经常看到，很多学生都这么写，然后他们在广场网站上发布的bug说，为什么最后一行要打印两次，你知道我应该告诉他们，是啊，是啊，是啊，是啊，也许像循环一样使用，它在事后检查，您可以使用不同的循环。

你可以做一会儿或者休息一会儿什么的，但我只是觉得这太简洁了，我想这就是我会做的，好啦，还有一个大于它的箭头运算符，从流中读取某种输入标记，就像一个词或一个数字，被空格隔开的东西，所以如果我有这个文件。

马蒂十二岁了，如果你把这个字符串单词，然后你就这样读，你要读，马蒂，所以说，它只是寻找空格或换行符，现在只需要空格字符来划分，它把它读成字符串，但是你可以把它读成一个int，就像年龄一样。

然后输入有效的箭头年龄，因为零运算符理解如何转换类型，那样挺酷的，或者你可以把它读成一串，然后将字符串调用为整数，那也行，所以这很可爱嗯，很多时候你想做一些混合的事情，比如，读几行。

然后看看每行上的单词，我将向你展示如何在一个，但这是一种，啊，另一件事是，如果尝试执行此运算符，没有更多的数据，然后运算符的总体结果将变成一种假值，你可以，如果否则打开或同时循环打开，所以你可以说。

当输入时，箭头词，打印字，把文件里的每个字都打印出来，这就是台词，那是读字，代币，随便啦，如果你想混在你读一行的地方，然后你想把它切开，只是那一行的字母或单词，你能做的就是。

您可以创建一个名为i流流的对象，这就像另一个流阅读器用同样的方法，像开合箭，所有这些东西，但它从一串数据中读取，不是从文件中，就像，如果这是我的溪流，C加加或C字符串，然后我可以从中读出令牌。

把名字念给我听，然后姓，你的电话号码，它会读出这三件事，所以这有点酷，有时将if字符串与i字符串流混合，从if流中读取一行，然后用字符串流把单词分开，下面是另一个例子，我说生存还是毁灭。

然后我做了一个一会儿循环，当我能读单词的时候，接受这些话，所以它打印出生存还是毁灭，所以在这些例子中，在最后几张幻灯片上，你应该可以切片和切丁，你将要看到的大多数类型的输入，是的，是的。

您能使用流流从文件中获取输入吗，好吧，好吧，你能把这些混合起来吗，你能从文件里读出来吗，使用i流流，嗯，不直接，但你要做的是让如果流，你读了台词，那你就做吧，我溪流溪流，你过了线，现在你读了那行的令牌。

所以你把两者混合在一起，不能用这个替换if字符串，但你可以把它们当作音乐会，还有一个o字符串流，它将输出写入字符串，我要告诉你的是，它基本上是这样工作的，那很管用，如果你做一个O屏屏幕。

你可以少于少于向它发送信息，你基本上是在建立一根弦，我们谈过，嗯，很慢的方法，这将是一种积累的方式，构建一个高效的字符串，然后当你做完，你说，好啦，把屏风拿出来，所以佐伊伯格的年龄是4岁2岁。

他的智商是95左右，你为什么要这么做，我是说为什么不把这个打印出来，也许我想把这根绳子，然后把它展示在一个粘稠的东西上，在按钮上，或者我想把这个弦，然后我想把它打印出来。

你知道可能有一些原因你想建立一个字符串，但你不想直接把它送出去，就像你在建造一样，所以哦，字符串屏幕更快，什么是耶，如果创建字符串对象，然后你移动，你做加号，加号，加号，它所要做的有点像。

调整缓冲区大小，复制类似的东西，所以这是一种更直接的，我想很多语言都有这样的东西，就像Java有一个叫做字符串构建器的东西，它允许您随着时间的推移高效地增量构建字符串，所以实际上在你的家庭作业上。

我想让你做的一个问题叫做疯狂的libs，所以你读了一个文件，里面有一些空白，像名词和形容词之类的，然后你翻看文件，找到所有的空白，然后你让用户告诉我一个名词，告诉我一个形容词，告诉我一个人的名字。

在你读了所有这些话之后，你填好空白处就把故事倒出来，所以为了做到这一点，你要做的就是读取，如果流，然后在你前进的过程中建立你的填充故事，使用o字符串流，最后，一旦你完全做完了，全部打印出来看看。

但你不想边走边打印，因为有了疯狂的libs，如果你以前做过你别说，给我一个名字，他们告诉你一个名字，然后你告诉他们故事的台词，否，你等着他们把一切都告诉你，因为那很有趣。

因为所有的词放在一起没有任何意义，所以你会在你的家庭作业上做这种事情，一个，到上一张幻灯片，上一张幻灯片，这就对了，这是标准，有时对于初始，是啊，是啊，所以构造对象的语法是写类型，然后写名称。

然后一个分号，有些对象基本上将参数带到它们的构造函数中，这就是传递参数传递给对象构造的语法，在变量的名称和分号之间，我是说，基本上这就像工作一样，除了这里，你会说等于新的冰淇淋流，就像那部分是不存在的。

只是为了说明双箭头和截止日期的作用，当有，他们读，你知道当你不能做某事，那就会返回一个假的返回，是啊，是啊，当这些箭头或得到线失败时，当没有什么可读的，表达式的结果将是一个假布尔值。

或者一些c加+会理解为等价于false的布尔值的东西，因此，您的代码将知道停止while循环，否则if语句将不会输入，或者别的什么，好的，好的，所以溪流，有一些用于流的斯坦福方法。

如果您包括我们的文件库，我们只是有些东西你可以查一下，如果存在文件，你可以，呃，你知道的，删除文件，这些都是你在常规C+中可以做的事情，但它有点不同，无论你是在Mac、UNIX还是Windows上。

或者一些废话，它是如此，我们试着为你从等式中剔除一些，我们还有这个方法可以读取整个文件，那有点酷，所以你甚至不用做循环，您可以将整个文件读取为一个大字符串，有时这很有帮助，你做作业不需要那个。

但有时这是一件有用的事情，重命名文件，我不打算在这张幻灯片上花很多时间，但这些都是使用函数的有用方法，好啦，所以我想在这里继续前进，因为我没多少时间了，我要和你谈谈一个叫网格的集合。

我不需要太多时间来谈论这件事，因为它不是太复杂，不过，你要用它做作业，所以当然你总是在最后五分钟做最重要的事情，对呀，这来自下周书的第五章，我将谈论一大堆关于数据收集的问题，那是下一个大单位。

让我们看看我们要涵盖的下一个材料单位，但这只是让我们开始，所以我想你可能知道什么是收藏，它只是把数据存储在里面，有时称为数据结构，你放入集合中的数据片段，我们称它们为元素c+，附带一套可爱的标准系列。

它被称为STL，标准模板库，大多数cplus程序员都会学习如何使用stl，你就是这么做的，在斯坦福大学创建课程的人，觉得这些集合和stl对学生来说很难使用和学习，例如，如果你的索引出界了，它不会崩溃。

它只是进入垃圾内存，给你垃圾数据，这对那些试图找到错误的学生来说是令人沮丧的，在许多类似的奇怪故障中，这些收藏真的很好用，如果你知道如何使用它们，但它们很难学，所以我们为斯坦福大学写了一套自己的收藏。

所以我们打电话给我们的，斯坦福收藏图书馆让名字真的很相似，天啊，嗯，所以我们有自己的收藏，我要教你如何使用我们这里的藏品，在本季度的课程中，它们更容易学，当我刚到这里开始教书的时候，我就像，哎呦。

那是个瘸子，我们应该做真正的收藏来吧，尤其是一零六x，我们都是硬汉，对嗯，但别担心，因为我们的实际上真的真的很相似，只是我们的检查出界了，检查记忆错误之类的，所以一旦你学会了我们的，切换到这些超级容易。

你很好，在十二月下课之前，我告诉你够多了，你可以用这些，如果你想的话，别担心，你得到了像一堆假收藏品在这里，就像没事一样，就像给我几个月时间和这些骗子在一起，我们会切换到真正的东西，嗯，但不管怎样。

只是让你知道你的家庭作业，如果你真的想，你可以用这些，但我建议用这些，调试更简单，嗯，我要告诉你们的第一个集合是一个网格，它是一种二维数组类型的结构，你可能会说很好，为什么我不直接用一个二维数组。

那么C++确实有二维数组，但是C++中的数组有点糟糕，如果你出界了，你会得到垃圾数据之类的东西，所以这个东西在二维数组的版本中更容易学习，所以你在每个上面都包括网格，你做一个网格，当你创造它的时候。

你告诉我什么尺寸，多少行多少列，你还告诉我你要存储什么类型的数据，在网格的每个单元格中，如果您使用Java或其他方法，您可能会看到元素类型括号，Java在C中调用这些泛型。

加上我们调用这些类型参数或模板，所以它是一个存储其，你得把字体写在这里，你没有，因为它编译，这意味着三行四列的ins，现在如果你想访问单个元素，您编写网格的名称，后跟行，后面是列。

然后设置一个值存储在那里，还有一个更短的语法，在那里你用卷曲的神秘大括号告诉它元素是什么，它会初始化所有的，如果你提前知道元素是什么，你可以利用这一秒钟，这个英国人初始化矩阵中的值。

或者只是没有人能告诉你矩阵是什么，你得自己去找，你真的会鼓掌，如果你走了，喔喔，那就太好了，嗯，我知道，但是呃，它确实回答了你的问题，它确实将所有值设置为零或某个等价值，MD，如果是替身，是零点零。

如果是嘘声，全都是假的，大多数语言，C++的大部分部分，不要那样做，但我们的收藏是这样做的，为了让它更容易，你必须具体说明你要回什么年级吗，当你试图，当您返回网格时，是啊，是啊，作为回报。

我会给你看参数，我想等一下，但是是的，你，你总是要写这些括号，类型是斯坦福的东西，这是斯坦福的事，是啊，是啊，引号大学，你看出来了，它是我们的，所以是的，下面是成员函数，你可以在网格上调用的方法和东西。

您可以访问元素，您可以以相同的值填充每个元素，您可以询问给定的索引是保持界限还是超出界限，零到你知道，减去1，您可以询问行数和列数，你可以调整你可以，你知道的，将内容打印到输出流中，并查看其中的数据。

所以总的来说，这是一种标准的东西，就像你们可能学到了一些东西，比如射线表或矢量，或者一些你添加的东西，然后随着时间的推移而增长，这东西不长了，除非你告诉它成长，你说吧，我要五排四列，就是这么大。

如果你用完了，不会给你增加更多了，除非你说，我想调整到新的尺寸，它做到了你可以，我觉得，当你阅读的时候，如果你想去看文档，你可以，有一些这样的方法，您可以传递参数，比如调整大小。

我是想保留现有的一天还是抹去它，你可以做所有其他的事情，所以大部分都是很简单的东西，二维数组状结构，用那些括号到达里面的元素，OTR是什么意思，哦耶，什么是Ostin输出流，所以就像看，一个文件。

或者一个o字符串流，所有这些你都可以写一个网格，它会以合理的方式打印出来，这是关于内置STL集合的另一件事，它们没有任何打印功能，所以你不能打印出来，里面有什么，来吧伙计们，他们在想什么，哦好吧。

所以我快没时间了，所以让我们看看我想告诉你什么，所以我想说的一件事是，当你按参数传递网格时，作为参数，您想使用与号通过引用传递它，因为如果你不，它会完全复制整个网格，所以很多时候你在网格中通过。

因为你想修改它，或者填上数据之类的东西，所以你总是想通过引用来传递它，如果您知道您的函数不会修改网格，你也可以在它的前面写这个单词常量，意思是不变的，我不会改变网格的内容，我没时间了。

所以我不想留你过夜，真希望我还有五分钟，但我星期一会继续，但是嘿，如果你想早点开始做家庭作业，网站上有，去看看，至少变得可爱，创作者周末成立。

我们星期一从这里开始，非常感谢。

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P4：Lecture 04 - Vector, Big-Oh - 加加zero - BV1By411h75g

下午好，很高兴再次见到大家，希望你一切都好，今天电视和互联网上的新闻有点令人沮丧，我真的不想谈那个，因为我认为课堂应该是一个避难所，在那里我们不用去想可怕的事情，如果我们不想，但我希望你一切都好。

我希望你所爱的人都过得很好，今天我们要谈谈一些收藏，在C Plus Plus斯坦福收藏库中，尤其关注一个叫做矢量的，我先宣布几个事情，我想提醒你家庭作业一出来了，因为这个星期五下午，如果你还没看过。

去看看吧，请开始吧，我想对于那些还在购物并试图决定，如果你想在这里或一到六B，我认为做作业是一个很好的方法来衡量这一点，记住我们的家庭作业有三个部分，我们的三个部分叫做疯狂的libs。

Photoshop中的生活游戏和一六的家庭作业只是Photoshopped，所以我想你可以从那个开始，然后如果你说哦，你可以切换，但是，我确实认为Photoshop是三个中最难的，为了它的价值。

如果你喜欢，从那里开始，因为那是可重复使用的，你在考验自己，家庭作业最难的部分，所以你知道有些人问过关于团队合作的问题，我想我们的第一张信息表上写着你不能参与这项任务，你不能把我们的头，塔米有一颗心。

她说服我让你去完成以后的任务，我会在之后再谈这个，但这次是个人任务，因为我想让每个人都在他们的机器上设置可爱的创造者，我希望每个人都自己解决了一个棘手的问题，在我们前进之前，那出局了，星期五6点到期。

我们的图层本周开始，那是我们的帮助实验室，如果你想找人帮你做作业，欢迎你这么做，如果单击此链接，上面写着层小时，它会告诉你，今晚六点开始那里就有人，那是我们的部门领导，他们很乐意帮助你。

如果你需要可爱造物主的帮助，不起作用编译器错误，我不明白规格的这一部分，你想要什么都行，他们不能确切地告诉你如何解决这项任务，但他们会帮你调试，不回答问题，他们知道所有这些任务是怎么回事。

所以我鼓励你利用这种资源，那是我们最主要的帮助资源，如果你不能在其中一个晚上，你也可以去我们的广场论坛，在那里发消息，你有一个问题，是啊，是啊，网站是否进入维护阶段，是时代的。

这个层网站关于这些时间正在维护中，好的，好的，我这里的网络信号不好，我晚点再看，但我要告诉你，那层是在特雷斯德联合公司的一楼，在我们的信息表中提到了，今晚营业，六点开始，所以如果你想去那里。

不管愚蠢的网页，会有人帮你的，好啦，我稍后会查看网站问题，很抱歉，那是我不维护的外部链接，所以说，我会调查的，嗯，在这方面，我提到过这句话，这些人将在实验室配备人员，那些是本科生，像你一样。

最近谁上了这门课，然后他们申请为我们工作，帮助你完成任务，嗯，你这周要去见你的部门领导，你们大多数人，希望你们周末都记得这张表格，注册区段的可用性，你会收到我们员工的回复邮件。

我相信明天下午会有关于你被分配到哪个部门的信息，如果你忘了填写农场，没关系的，我们有一个迟到的报名，但你会有机会在这周提交这些信息，部门领导做完之后，把其他人分配到，他们有很多工作要做把所有的名字。

所有的盒子都想明白了，所以他们明天会发邮件告诉你，我想明天下午，以上是我的声明，我想跳入一些材料，上周我们讲了几个话题，我们开始了解C++语言，我们开始谈论收藏，上次我们收集的是什么，谢谢你。

那么什么是网格，有人只是简单地，什么是网格，它有什么用是的，先生，所以站在斯坦福，特别是数组中的本地库，但是有了更多的功能，比如检查，如果你出界了，是啊，是啊，它本质上是一个数组，一个重要的二维数组。

但是有一些额外的函数，比如边界，用数据检查和填充数组，这种东西对吧，所以这基本上就是网格的作用，关于成绩，有几件事我想提一下，我认为这很重要，我以前提到过其中的一些事情。

但我只想强调一下，如果你用它们做作业，你在家庭作业1中所做的。

这是网格，网格点H，在那里你可以指定元素和东西的大小，然后你把这些元素储存在那里，在尖括号中指定数据类型，我想在这里提到的事情是，我想谈谈传递一个网格作为参数，我简短地提到了这个，但我们要收拾行李离开。

我只想再次强调，我们说好了的，这是什么意思，参照行为参照权，您应该始终通过引用传递网格，如果您将网格作为参数传递，从一个功能到另一个功能，你应该这么做的原因是网格是一个很大很大的东西，那需要很多记忆。

如果你不通过参考，C加加是什么，它把整个网格做了一个完整的副本，不会破坏你的程序，它不会导致程序行为，但是效率很低，今天我首先要讲的是效率，祝福你，你只是不想每次都复制一个网格。

你现在把它作为一个网格传来传去，当然如果你通过引用传递一些东西，这意味着您的网格与其他函数共享，对呀，所以其他函数可以修改你的网格，这很危险，这对调用此函数的人来说是一个潜在的危险，我把我的网格给你。

但你能不能不要乱来，如果你想通过引用传递一些东西，但你要保证你不会修改它的骗局，你可以传递所谓的常量引用，在那里你写了这个词，类型的恒前，然后它在这里，你看不到你是否在后面，但是如果你写常量这个词。

这类似于java中的final这个词，如果你懂Java，它使这个网格不能被改变，所以如果你想打电话，设置或清除，它不会编译，所以这实际上是一个很好的恒定引用，是分享和提高效率的好方法。

没有被后面的功能修改的风险，是啊，是啊，如果你故意想，我们正在做，如果你故意想复制，忽略一个值是可以的，你想这么做的情况很少，事实上，我认为更好的风格，作为个人的选择，我无论如何都会通过参考。

也许通过常量引用，然后在函数里面，我会说网格拷贝等于g，当你做等号时，并以C加加的形式将一个对象分配给另一个对象，不像在Java中，我想我们可以复制那个东西，在Java中。

如果将一个对象设置为等于另一个对象，它们指的是同一个物体，它不会复制，但它会用c++复制一个副本，我认为这是一个更好的，更好的一般风格，即使他们最终基本上做了同样的事情，所以好吧，所以请记住。

当你通过收集，通过引用，您应该通过引用传递的另一种数据类型，如果您正在传递一个文件流，类似于if流作为参数，你想通过引用传递，因为您不想复制文件阅读器的多个副本，当您遍历代码时，所以无论如何。

另一个问题，是啊，是啊，你把常量也放在原型上，这个更多的骗局，你得把它，如果你做了，带有分号的原型，你得在那里穿上东西，你得把犯人放在下面，当您编写函数的主体时，事实上。

也许我应该在这张幻灯片上添加一些东西，如果你，如果它们不匹配，如果分号原型说函数体的常数，没有说缺点，反之亦然，你会得到这个令人困惑的错误，上面写着建筑找不到的符号，八六六四，这就是它告诉你的一切。

它甚至通常不会给你一个行号，所以这是一个可爱的创造者真的真的很有帮助的例子，其实呢，我能演示一下吗。

基本上是我对C++语言的憎恨，我对可爱造物主的憎恨，我只是在教这门课的时候很有攻击性，所以如果我做了无效的Foo，常量int x您可以将int作为控制台传递，那就没那么有用了，但在这里，如果我说。

让我们看看四十二，但是现在如果我写void foo，我说int x，我相信我现在会得到错误，否，我没有到那里，好极了，这就是为什么我，是啊，是啊，如果这个没有常量的话，而这个有，我不知道。

这种语言太愚蠢了，你们真的，它甚至不会失败对吧，你知道吗，等等，好啦，哈哈哈等等，啊，我应该运行它，哦天啊，我很害怕，如果这个的int引用，另一个只是int，那怎么样，好啦，我得到一个不同的错误。

我忘了，我等一下再找，但基本上，如果你的缺点不匹配，在某个地方，而不是在其他地方，您经常收到错误消息，作为我的观点，这不是很有帮助。

所以不管怎样，注意引用和常量问题，你传递参数，如果你想练习网格，我不打算在课堂上做这道题，只是为了时间，我想研究一种新材料，但是有这样的练习，上面写着，编写一个函数，它接受一个网格并尝试计算这个。

或者您也可以尝试在我们的代码中解决这些练习，逐步网站，如果你想在开始做作业前试着用网格练习，是啊，是啊，在后面，你可以在某个地方使用常数。

重复一遍，哦所以，如果你在一个地方说常量，但你在另一个地方不说常量，就像原型一样，对不起，你能再说一遍吗，你定义了两个不同的函数，使相同的，哦好吧，我想我认为这种情况发生在学生身上最常见的方式。

您是否编写了一个名为foo的函数，你取一个矢量或一个网格，或者某种集合作为参数，然后你就要上交了，你认为，哦，马蒂说我应该参考一下，所以你加上一个与号，但你忘了把它加在两个地方中的一个。

你把它加到分号原型中，但是你忘了把它加在下面，反之亦然，或者常量也一样，你一开始，你不做任何常量，然后你回去，你去，哦，马蒂说我们应该做些东西，康斯特，所以你，您将常量放在一些参数上。

但你忘了两个地方中的一个，这通常是引入这种错误的地方，然后编译器的消息有时不太容易理解，所以这是需要注意的，如果，如果这些信息，我看到你的手了，如果您看到这些编译器错误，你很难理解。

尤其是如果你在这里连行号都没有，这有时会发生，你能做的，是不是有个标签写着编译器输出，看它旁边有一个小数字4，如果你点击它，它就像编译器的原始输出，出于某种原因，可爱的造物主拿着这个。

试图把它打扮得漂漂亮亮的，但它并不总是做对的，就像这里，这个会告诉我，哦，在这条线上错误，或者别的什么，有时在这个问题选项卡上的主要问题，很难读出错误，但有时在这个编译输出选项卡中，你可以读。

所以要注意这个问题，现在又有一只手举了起来，是啊，是啊，我还有一个问题，你说的等于运算符复制和对象，是的，是的，因此，如果您想使其成为对对象的新引用，哦，等于运算符做了一个引用，它复制了一份。

那么你怎么做参考，您使用相同的与号引用语法，但是您使用该语法声明变量，我将在以后的课程中谈到这一点，但这就是你要做的，是啊，是啊，你喜欢那样，所以一旦你用了，你没有百分比是。

啊，问题是常量和与符号是否需要一起使用，或者当你这么做的时候会发生什么，或者不要一起用，我记得你说过，如果我用缺点，那是不是意味着，我不再需要使用符号，我想说那不是真的，我不同意那种说法。

但他们确实把事情分开了，与号的意思是不要复制共享的权利，常量的意思是不要让这个函数修改这个，所以它可能是复制品也可能不是，但你仍然可以锁定它进行修改，所以有一些不同的观点，常量基本上使某些方法不再编译。

如果你想说清楚，装满了，那些方法无法编译，如果你说康斯特，这些方法将编译，不管你说的是不是符号，但它们是否影响均值是不同的，是啊，是啊，为什么你要用球杆，没有与号的a常数，我不知道对于一个物体。

像一个网格，你可能不会喜欢，有时你传递一个常量或一个常量字符串，因为你只想要函数的代码，不是为了改变什么的，但它更罕见，我再同意一次。

然后我想继续前进，是啊，是啊，如果您使用原型函数定义，把函数的文档放在原型中更好吗，用于执行，是啊，是啊，这是个好问题，你把你的评论写在原型上了吗，还是把你的意见写在这里，我会让你选择你喜欢的任何东西。

我想更常见的是，把它们放在这里，不要对尸体发表任何评论，因为我觉得你应该只看这个，然后知道你需要知道的，您不应该阅读所有关于它如何工作的实现代码，为了使用这个功能，所以这就是我认为的想法。

它是针对此代码的客户端的，好啦，所以说了这么多，我离开了网格。

实际上要谈论另一个叫做Vector的集合，所以你们之前有一些编程知识，你们可能听说过Java中的一个集合，它在Python中被称为数组列表，它在JavaScript中被称为列表，它叫做数组。

所以大多数语言都有某种结构的概念来存储元素，以零为序，一二，上面有三个索引，这就是我们所说的C++中的向量，这就是我今天要讲的，在某些方面，矢量比网格更简单，所以你可能会发现我们先覆盖网格很奇怪。

我承认我们先掩护网格，因为我需要它做家庭作业，所以如果没有家庭作业，我会在周五谈论矢量，今天谈论网格，但是哦，好吧，管他呢嗯，所以矢量，有些语言称之为列表，如，我说，它是具有以0开头的索引的元素集合。

有些语言有一个单独的概念，就像从一个叫做灰色的列表中，这是一种固定大小的东西，而列表可能是一种动态调整大小的东西类型，我将重点讨论动态调整大小的那个，如果使用Java和数组，一旦确定数组的大小。

它永远粘在那个尺寸上，但是如果你做一个数组列表，它又长又缩，让我们看看你是否想在C+中使用向量，加上这个库包括向量h，上面有引号，这意味着这是一个斯坦福本地项目图书馆，我们在这里写的是关于这所大学的。

您可以通过说向量要存储什么类型的元素来初始化向量，如果你知道一开始的值是多少，你可以让他们参加卷曲比赛，所以这是一个由五个元素组成的向量，或者你可以做一个空向量，然后你可以通过点f来添加元素。

所以它从一个空列表变成了一个单元素列表，到双元素列表，到三元素列表，它根据需要生长和收缩，就在滑梯的底部，我有一个数组的示例，因为同学们总是问我，为什么我们要学习向量和列表，我们没有学习数组。

但是什么东西没有数组呢？它确实有数组，但他们很烂，所以我还不想用它们，也许以后我们会用它们，语言里有一堆愚蠢的东西，我不想谈这个，如果我能逃脱惩罚，其实呢，你知道周五下课后肯定有很多人。

他们问了我一堆有趣的问题，关于语言，关于语法之类的，我很高兴总是谈论这些事情，但我确实认为这门课的禅意是，C加+不是重点，它是一种用于某些情况而不用于其他情况的语言，在这之后。

您可能再也不会编写C+Plus代码了，所以我想，迷失在C++的细节中并不是这门课的真正重点，真的吗，我想谈谈管理数据和编写算法，还有其他更大的图景，尽管细节可能很有趣，也是，对呀，是呀。

所以如果你只是想要一个列表，列出哪种固定大小，有什么不对，啊，如果你想要的只是一个固定大小的集合，为什么不直接使用数组，因为矢量的好处是它会生长和收缩，如果我不想成长和缩小呢，我想说总的来说是的。

如果要修好，好处会少一点，但是常规数组丢失了，很多事情，比如你不能要求它搜索一个元素，否则你不能轻易分类，如果你试图在数组上出界，你可以，C++会给你垃圾数据，而这个东西会给你一个错误消息来帮助你调试。

所以我认为这样做还有很多其他好处，事实上，关于C++数组，我最不喜欢的一点是，他们甚至不知道自己的大小，所以你甚至不能问它有多少元素，当然让你问了，所以说，我想说总的来说，因为光线不太好。

他们几乎什么也不做，是呀，像这样的问题，所以在向量库中，我们使用右边，C++附带了那个stl集合库，它也有一个向量类，用尖括号而不是引号导入，那个和这个有什么不同，我是说，我想说我现在不想讲太多细节。

因为我不想在课程结束前教收藏，就像我想教你我们所有的收藏，你习惯了他们，你试试看，你跟他们一起做作业，后来在课程中，一旦你的收藏忍者，我会说嘿，这是另一个，这真的很简单，你很容易转换过来，嗯。

我的意思是给你一个非常简短的回答你的问题，他们有很多相同的操作，但它们使用的名称略有不同，语法略有不同，所以如果你学会了这个，很快就会映射到另一个，如果你好奇的话，您可以谷歌搜索STL矢量教程。

你说的是旧的大O，我想在后面的课上讨论这个问题，是啊，是啊，是的就是去掉矢量，或者是一个网格，向量的向量，它是使用，我相信内部的二维数组，如果你想知道，实际上，您可以在一个项目中打开网格h。

然后再查看一个，然后我会继续前进，是啊，是啊，等于向量声明中的边，或者就是这样，哦矢量数等于0，这招管用，这是一个法律语法，是啊，是啊，你不需要等号，它将用等号编译，但你不需要有点奇怪，这就像一个语法。

C加+有好的，所以矢量，是呀，为什么我们不使用数组，我想我已经说过了，这张幻灯片上有什么，他们什么都不做，他们不知道自己的尺寸，他们不知道他们的平衡，他们错过了你想要的所有手术，我已经说过了。

所以我不打算继续下去了，下面是向量最常见的一些方法，我想你用矢量做的是添加元素，取出元素并移除元素，可能会问尺寸或冰箱一个矢量，这些是你会做的最常见的事情，但也有很多其他的方法。

向量允许您使用此括号语法访问元素，或者你可以说，它看起来更像Java，两者都是平等的，您可以使用这两个索引，所以这很酷，当您在控制台上打印出矢量时，它显示了大括号和逗号之间的元素。

所以很容易打印一个用于调试，是啊，是啊，问题是C++是否意味着两个字符串，如果你是为了看，更好地使用，我喜欢你的，哎呦，是啊，是啊，在Java中，当你打印一些东西，它隐式调用该方法。

在那东西上加两根绳子来弄清楚如何打印它，C++实际上没有作为一种语言内置的概念，所以这个类在技术上提供了一个双字符串方法，而且是可以打印的，但从技术上来说，这些代码是完全不同的，碰巧做同样的事情。

因为语言没有赋予这两个字符串方法特殊的公民身份，实际上要做的是编写一个名为小于的运算符，它描述了如何打印矢量，我真的不想去，是啊，是啊，反正，两个字符串返回字符串，而输出操作员在控制台上打印东西，后面。

是啊，是啊，我只是说输出流，可能是C出来的，可能是个文件，可能是O弦气流，是呀，对不起，这些幻灯片有时会有点浓缩--再来一张，是啊，是啊，所以当当前向量像这样。

它包括小于beta的小于和大于的数据和签名，你把类型，你必须总是，让我们说，如果你要做一个新的矢量，你说等于两个修女，你能直接说矢量吗，你总是要说括号int，每一次，C++从不推断数据类型。

您必须始终将类型写在括号中，只是语法的一部分，好啦，所以这些就是方法，我不打算在他们身上花那么多时间，因为我打赌你用的结构和这个差不多，在你来这里之前学的任何语言，所以你去那里。

大多数语义对你来说并不震惊，我想如何在向量上迭代，你如何在元素上循环并很好地观察它们，从零到大小的相当标准的循环，打印元件支架，我那就像，可能是在矢量上循环的最常见的方法，我相信你以前写过这样的循环。

如果你想倒退，你可以从减一的大小活到零，你以前可能做过类似的事，每个循环都有一个，你说每个屏幕，在这个矢量中被称为名字的东西，记住这里是字符串名称的向量，所以对于里面的每一根弦，我把它打印出来。

如果您以前没见过这种语法，基本上和上面这个差不多，只不过它将这个变量名设置为名称零，然后说出一个，然后说出两个，它把每个元素都拉出来，将其存储在这个局部变量中，然后让你访问它，然后循环。

对下一个元素做同样的事情，内部，这是使用一种叫做迭代器的结构，它在向量内部帮助实现此行为，每个循环都有一个变化，如果你写与号，它通过引用这两个循环之间的差来为每个循环执行一个，你基本上只用第一个。

但是如果你用与符号的第二种形式，那么如果你真的改变了这个局部变量的值，它实际上到达向量并改变向量的元素，所以你实际上可以循环它并使用语法修改它，在蓝色的后面是真的，是啊，是啊。

所以一个向量只有一种类型的向量，只能存储一种类型的值，是啊，是啊，如果要存储多种类型，有一些黑客可以做到这一点，我是说，其他语文，在C++中有一种叫做like object的类型，另外。

您必须使用一种叫做指针的东西来帮助获得这种功能，但在大多数情况下，我们只处理给定向量中的一种类型，如果你有矢量，其中每个元素都像一个网格或其他您为，这是个好问题，我有张幻灯片是关于收藏的。

如果你的向量存储了其他向量，你为每一个人，它确实复制了每个内向量，当它循环通过，所以你特别想通过引用来循环这些，是啊，是啊，那很微妙，但这是会出现的事情，基本上有一个c加+的规则，每当你有一个物体。

创建一个新变量来与该对象对话，那不是参考变量，它将创建一个对象的副本，并将其放入该变量中，所以这是你必须注意的事情，在蓝绿色的后面，你必须为每一个，保证按索引顺序通过它们，它按索引在它们上面循环。

你从零到，你不能改变顺序，这只是它给出的命令，如果你关心的顺序与此不同，或者如果你想知道索引是什么，当你循环的时候，你不应该用这个，你应该用普通的，基本上你可以修改四个内的向量，每个循环。

或者如果你在这里使用这个参考表单，您可以尽可能地修改元素，你喜欢，从此处或在此处插入和删除元素，如果你打电话，删除或插入，嗯，会混淆矢量，因为你在改变它的容量和大小，当你迭代的时候。

它可能会导致异常崩溃，如果你或腐败，是呀，我是否得到每个循环的每个规则，按从零到结束的顺序循环，就像一个常规的循环，好啦，所以呃，有一件事要注意，你知道的，矢量的好处是，你可以在任何地方向它们添加元素。

它将为新元素腾出空间，例如，如果你说，插入索引二，四十二的价值，这就是矢量的整个状态，就在索引2之前，它会把房间里的每个人都滑过去，然后它会把新元素放在那里，那很巧妙，Java中的规则数组之类的。

不知道怎么做，如果您告诉它要删除一个元素，它将删除该值，然后它会把每个元素都滑过去，向左一挡遮挡现场，把房间都用完了，所以这很好，偶尔，这会导致您正在循环的bug，你在插入，或者类似的东西。

其中一个问题是问，但这些都是很好的插入中间的功能，在最后，几分钟后我要谈一件事，是因为矢量，这个，暗示插入的速度较慢，把靠近矢量前面的东西去掉，因为如果你在这里插入一些东西，你得把每个人都滑过去。

但是如果我在这里删除一些东西，我没必要把任何人滑过去，如果我在这里删除一些东西，我得把其中一些滑过去，但不是所有需要时间的，你要滑动的元素越多，计算机需要更多的处理时间来做到这一点。

我们稍后会更详细地讨论这个问题，但我认为现实世界的类比是显而易见的，对呀，就像如果我在前排选一个人，我说嘿让开，我有个新学生，我需要一个座位，每个人都得站起来挪过去，做那件事需要更多的麻烦，对呀。

所以无论如何，这是矢量的一个很酷的特征，我这里有一些代码练习，我想我要做其中一个，我要和你一起写一个叫搬家的，其中将字符串向量作为参数传递，传递一个元素值，你想摆脱的，我会把所有出现的值从，好啦。

如果我有一个矢量，你说把所有的蜜蜂，你只剩下一个。

所以如果我去做我的项目，如果你想合作，这个项目在今天的课程日历下的班级网页上，让我把之前的这些foo东西删掉，所以我已经有了一个方法，主要功能主要，在那里我做了一个矢量，我把矢量打印出来。

然后我去掉所有的B，然后我再打印一次矢量，你看，我只是想看看你有没有做到这一点，在这里我有函数的标题，给我一个矢量，去掉所有这些字符串，所以如果我编译并运行它，我想我会看到的是，它只是没有去除任何东西。

对吧，因为我们还没做对，在去掉冒号之前，让我把这个改成v2，这是在说V之后，告诉我你想让我怎么做，我得到了函数头，有那种表情吗，好啦，这是你想让我在这个函数中使用的标题吗。

这可能是我作为教师在教学生涯中的第一个错误吗，会是什么你不喜欢我的头的什么，是呀，大人，我应该参考一下，好啦，是啊，是啊，有道理，因为我调用这个函数，我希望之后的矢量会有所不同。

主要是因为人的功能发生了变化，需要参照传递，好啦，应该是常量引用吗，否，因为函数的全部意义就是把愚蠢的事情改变对，所以是的，我不想让它保持不变，我想改变它，好啦，帮帮我，我该怎么做，好啦，迭代。

在上面绕一圈，什么样的循环，常规用于循环，或对于每个循环，向前向后，我们在伟大的，是呀，你说呢，我说，向后，向后，经常或，我想你可以，但你可以倒着做，因为这样你就会把你避开的元素弹出来，就像所有的转移。

好啦，所以你是说，你想让我把这个东西倒过来，所以你想让我为每个人存钱，我是小于或没有，你想从另一端开始，V点尺寸减一，只要i大于或等于零，然后你想让我做什么，每次你遇到和我们匹配的号码。

如果v元素i是我要找的字符串，然后去掉那个元素，所以说v点，移除，是啊，是啊，好啦，让我编译并运行它，那是一段很短的代码，嘿嘿，看那个，我想所有的蜜蜂都走了，那太好了，所以好吧，我只想指出，我的意思是。

那是正确的解决办法，我喜欢这个解决方案，很多，我想指出几个变化，有一件事我想提一下，你很聪明的说，让我们回到过去，让我们从头开始，如果我改变了它呢，并说，让我们从零开始到最后对吧，所以让我们做int。

我等于零，我小于v点大小，我加加，然后呢，它擅长什么，让我们一探究竟，怎么会有一个留在里面，我打赌你们很多人都能看到这个，所以我从那里开始，那个小胡萝卜是对的，所以i int i=0。

所以如果vi等于啊，B不，它没有，所以我有，我加加，好啦，现在我在这里，啊哈，Vi等于s，所以我去掉那个值，对呀，所以是的，然后我的循环绕回来，所以我有，我加加，所以我去了那里，所以现在我说的是。

这等于我想删除的东西，是呀，它是如此的移除，以至于一个，好啦，现在就把它取下来，我的循环绕回来，所以我有，我加上，加，你看到了吗，所以我实际上，当两只蜜蜂排成一排，前循环错过了第二个，因为它会删除。

把每个人都滑过去，我增加我的指数，把我推倒，所以从技术上来说，我在那一刻总共有两个动作，因此有人可能会错过，所以向后循环效果更好，因为你右边移动的元素，是你在某个特定时刻已经看过的，你通过改变，如果我。

啊，那很有趣，所以当v i等于s表示移动时，我嗯，那可能行得通，除了我认为可能有一个错误的情况下，就像如果它结束了，就像，你知道三个B不是吗，我要去汇编，我要跑了，它撞车了，因为我认为发生的事情就像。

它在啃那些蜜蜂，但最终没有元素留在那里，它说嘿是下一个元素，a b，就像，啊，我从矢量的边缘掉了下来，这里没有元素，你可以说，你知道的，当i还小于b的时候，但我认为实际上在这一点上，它并不干净。

我想我喜欢另一种方式，所以我会回到，如果和我回到这个，然后我觉得我很好，我们也可以加一条线，作为，那是另一种方式，当然你可以把它留在这里，它在哪里，如果你能移除，你可以说I减去哎呀，我减去减去回去。

然后你的泡芙加会让你回到原来的位置，这也有效，我有点不喜欢，因为它有点笨重，就像，为什么这里有一个i-，我认为最好的解决方案是这个，但其他方法也可以奏效，是呀，大人，外面也是，不断地重新评估。

这就像大多数语言一样，在循环开始时，这里的这一部分被评估一次，而且只评估一次，这里的公园在每次通行证之后或之前都要评估，我想是的，如果我突出显示的这部分包含V点大小，它会一遍又一遍地回忆V点大小。

如果v点大小在变化，所以它会看到这些变化，这里的这部分是在每次通过后实现的，所以是的，三大块中的第二和第三本书在每份请愿书上进行评估，但第一块只是在这些陷阱的开始，去掉for每个循环。

关于每个循环的问题是，它很适合改变一个元素。

就像这里，其中有一个现有的字符串，并且希望更改它，很难让人喜欢，删除字符串，所以它就这样消失了，您可以想象将它设置为一个空字符串或其他东西，但是现在你有一个向量，其中的元素是空字符串。

而不是缺少一个元素，所以这不是一回事，所以是的，反正，好啦，这只是一个简短的编码示例，如果你想玩小编码向量示例，书中有很多步骤和其他地方，还有各种练习，大多是，我想矢量对你以前见过的东西很熟悉，我猜。

所以我不会花太多时间在它是什么上，以及它是如何工作的，嗯，我想简单地谈谈收藏的收藏，几分钟前有人问过这件事，所以你可以有一个矢量，我不知道这段代码是否难读，但是你可以做一个矢量，几个向量。

然后你可以做一个向量的向量，你可以把向量的向量加到向量的向量中，然后你就可以打破向量中的向量，看起来是这样的，你可以用模糊的括号访问，意思是去划船，把索引一的元素，就是这一排，然后在这一行中。

转到索引1的元素，所以应该打印三个，您可以在一行或一条语句中初始化整个内容，如果您想使用这种语法，所以这看起来很像一个网格，对吧，这是一种二维的东西，这和网格有什么不同，不仅仅是，向量这个词的次要用法。

而不是网格，他们有不同的名字，道路的长度可能不同，是呀，它可能更像是三角形，而不是网格，必须是长方形，所以你可能会说，哎呦，这个更好，我不知道，我觉得，如果你知道你想要一个长方形，伟大就是好。

但是如果你对每一个都有不同的链接，出于某种原因，也许矢量是好的，另一个问题，是啊，是啊，我们会做一个，具有不同类型元素的向量，我今天不能教你，因为我们必须知道指针，基本上，但你可以做到这一点，这很复杂。

但你能做到，是啊，是啊，我注意到当你写矢量和矢量的时候，两个直角括号之间的空隙，以防止它，从把它和操作员混淆到对，正确现在看，我你们，我喜欢得到对自己的赞美，从你的无伤大雅的陈述中，不是为了赞美我。

因为你看到他做了什么，他说，你为什么在这里有空间，你需要那个，他没说，嘿嘿，哑巴，你搞砸了，如果你放了一个不是，他相信，我不可能只是搞砸了，把事故放在那里，两地，但实际上在这件事上你是对的。

我确实这么做了，但我只是想说谢谢你假设我想做的，那表示你认为我很注意细节，或者我选择这样解释你说的话，还是没说，嗯，你知道的，我们需要理由来自我感觉良好，对呀，所以那是我的，我知道，什么时候放空格。

我觉得你应该一开始就去太空，摇摇晃晃的，它是不平衡的，所以你想在这里听，呆在你的车道上，Pal，呃不，不管怎样，呃，为什么很快就有，我在这里有一个空格的原因是旧版本的C++编译器。

如果你把两张结案陈词的唱片放在一起，你以为你在读箭头操作员的文件，它可以使用编译器，但是五年前他们把它修好了，但大多数人还是这样做，万一你有什么人可以起诉，C加+太愚蠢了，但是是的，技术上来说。

如果你把空格去掉，对你们所有人都有用，因为您最近才安装了编译器，所以你很好，但是是的，好啦，反正，你可以有一个集合，我不认为这个特殊的例子是超级常见的，但你有时会有一个矢量的网格或地图的矢量。

或者所有这些不同的东西，我会告诉你随着我们的继续，是啊，是啊，有没有办法在你的源文件中知道你需要，表示您想要什么样的编译器，你可以，但讽刺的是，就像编译器一样，在你想要的之前，不会明白的。

如果你要求你想要的，因为它就像，我从没听说过，如果你说我想要2011年的版本，就像，没有那样的事，因为现在是2007年对吧，那是我出生的时候，所以你明白我的意思，你不明白的编译器，不会做你想做的事。

我是说，你可以，您可以编写这些构建文件来检查类似的事情，这有点超出了课堂的范围，我是说我不会逼你做任何事，得担心那些东西，但我想当你遇到它的时候就像，如果你必须在一些古老的服务器场上运行。

而这些服务器场不是你构建的，然后你发现你试图编译你的C++程序，你会有一些新的警告或错误，你没想到，你用谷歌搜索它们，你发现，啊，他们在2009年的语言中改变了这一点，啊。

所以这台服务器一定是2000年8年或7年左右的，但它发生了一点点，但不管怎样，好啦，所以我想少谈矢量是什么，因为我觉得你能弄明白，或者至少已经知道怎么做了，我想更多地谈谈它是如何建立在里面的。

我想谈谈效率，讨论我们所说的大o符号，大多是，它来自书的第十章，向量内部，有一个数组，当我说数组，我是说，这个固定大小的内存块可以存储东西，在Java意义上的数组，或者单词数组的C含义。

向量实际上在很大程度上存储了三样东西，它存储一个数组，它存储了两个整数，称为大小和容量，所以如果你把这个矢量，它有六个元素，所以作为向量的用户，你认为这是一个，就像一个六号数组，基本上是对的。

但如果你需要它，它可以生长，在这里面，它通常比六号大，可能是十号的，也可能是十号的，也可能是二十号的，可能有一百个，至少要六个小时，但可能不止六个，他们这么做的原因不是让它正好是六个。

是因为如果你想添加第七个元素，它可以把它粘在数组的末尾，如果你正好有六个，但是你想加入第七个元素，你觉得你该怎么做，您必须创建一个更大的新数组，并复制所有内容，然后现在为将来使用这个新数组。

因为数组的大小不允许增长，他们不会，它们没有生长特征，你用它来筹集比你告诉用户的更大的资金，所以用户认为这是七号的，但实际上不仅仅是那个或六号，好啦，但我们有六号的，我们有十人。

这意味着总共有多少空间可以使用，如果大小和容量一样大或超过容量，复制到一个更大的数组，现在它确实提出了一个有趣的问题，虽然，就像暗地里有另一个元素在这里，即使你没有要求，如果你试图要求元素，本指数。

它会给你这个零吗，因为那会很奇怪，它在矢量的实现中的作用，如果你问七号老人什么的，它会看到它的大小，它会给你一个错误，但从技术上讲，那里有一个元素，它就是不让你看到，好啦，这就是现在里面的东西。

如果你想插入，还记得我说过一切都会好起来的吗，如果你想在这里插入，好啦，我把这个移到这里，这个在这里，把这个移到这里，然后我会把你的元素索引，一次又一次，因为我还有空余的空间，我有能力做到这一点。

如果我撤下，我让每个人都站在这的对立面，我想我恢复了更多的能力，你可能会说，哦，会的，会的，就像，缩小数组以适应，通常没有，因为它不是很有用，我们只是在最后留下多余的空间。

我喜欢在这里做的类比是当你买房子的时候，我告诉过你我妻子和我，太棒了，我们住在一个小房子里，我们希望这是今天的笑声，我们希望能在湾区买栋房子，总有一天哈哈哈哈，如果你们都支持我的创业。

也许有一天我们可以，但是嗯，但不管怎样，当你买房子的时候，好像我们有两个人，所以我们可以买一个一居室的房子，因为剧透警报，我们共用一间卧室，就像我们做一个卧室的房子，但那不会有很大的空间，嗯。

然后我们有了一个孩子，现在一个孩子需要一个房间，所以我们要去买一套两居室的房子，我们会把所有的东西都搬到一个有两间卧室的房子里，哦，又有一个孩子要出生了，我们去买一套三居室的房子，我们会再次搬家。

真是件苦差事，每次你再生一个孩子都要搬这么多东西对吧，所以我在这里的意思是同样的，所以你通常会去买一套四五间卧室的房子，不是在这附近，因为没人买得起，但我很高兴能在湾区工作。

房地产咆哮进入我们今天的矢量讲座，但你买了一栋有额外容量的房子，所以你可以用它，当你需要的时候，如果你把它装满，就像你发疯一样，你就会说嘿孩子们，或者当你需要的时候去买更大的房子，把所有东西都搬进去。

但你不想经常搬家，所以你可能想买一个，那比你以前的那个大很多，同样的想法，但没有那么令人沮丧，我觉得，有一件事我想指出，我们说过当你插入，删除，你得滑动元素，你从左边插入的越远，或从。

你要滑动的元素越多，这意味着这些操作的运行时相对于，您要求在其上执行它们的索引，想想很有趣，因此，让我们用一分钟的时间来讨论运行时和效率，效率这个词是一个笼统的术语，它是程序对资源使用的度量。

所以当我们谈论效率时，我们是说时间，跑多久，这个算法效率有多高，但可能是内存效率，就像，存储所有数据需要多少内存，可能是网络效率，有多少请求，我必须发送到服务器来解决这个问题，因为网络速度慢。

所以我想在最少的网络请求上进行优化，可能有很多资源对吧，但如果我只是说效率没有上下文，我可能在说运行时，那么你如何谈论程序效率，这实际上很难解释，原因有很多，嗯，计算机硬件复杂，软件和编译器复杂。

代码中的许多层都在干扰，但我们必须简化才能有一个模型，所以我们可以谈谈这些事情，因此，让我们决定单个语句运行需要一个单位的时间，这不是真的，因为它需要更长的时间，你知道的，乘以它所需要的加法或什么。

但我不在乎，我不想去想那个，所以像声明和初始化变量这样的语句，我们在调用函数什么的，语句需要一次，如果调用函数，所需的时间是该函数中语句数的总和，所以如果我调用函数foo，foo中有四个语句。

那么函数调用的这一行的代价是4，因为U中的四个语句现在又来了，那是不正确的，因为跳转到一个函数需要一点时间，或者往回跳什么的，但我们要简化一点，最后，如果你有一个循环或重复，重复n次。

那么循环所需的时间是，n乘以循环中的语句数，如果您有一个在正文中有三个语句的循环，重复十次，那么循环要30英镑，就这样，很简单，我想我没说这里还有什么，但就像，如果有一个如果和其他。

然后像填充物的成本如果牙套，还是馅料的成本，另一个是牙套，取决于代码最终是正确的，就像那个简单的模型，基于那个模型，如果你看一段这样的代码，所以我想说清楚，所有这些从语句1到最后的大括号。

所有这些就像一大块代码，你要说，我对这个代码了解多少，现在代码引用了一些我没有指定的变量n，假设这是一个很大的数字，一些变量，好吧好吧，如果你看这一行陈述，一个需要一个单位时间来执行的。

如果你看这个循环，有一个n的循环和一个n的循环，然后是c，所以这个循环的运行时为n，但我重复了N次，所以这个块的总运行时间是n乘以n，你知道n的平方，这里的循环进行了n次，里面有自由语句。

所以是3乘以n，所以这整个过程就像n的平方加3 n加1，基本上通过我们的哑模型，所以我是说这只是数学，但如果n是一千，那就是你知道一百万加三乘以一千加一，所以你知道这是大量的陈述，对吧。

我想让你从这件事中带走的是，某些代码块比其他代码块昂贵得多，事实上，这个说n的平方是超级昂贵的，如果n是大的，对吧，这里的这个看起来可能只是很大，是这个，我想有些人有直觉，就像它在屏幕上的大小是昂贵的。

或者线路数使其成本更高，有时这是有关联的，但这真的取决于线条的嵌套，重复是非常昂贵的，这是主导的东西，整个代码所需的时间，什么构成陈述，喜欢是int，I=一个不同于i冒号和i=，哦耶，你想对它挑剔。

就像你可以说的好，从技术上讲，这是，这第一部分是一个声明，然后这张支票是一份声明，而且是的，你当然可以这么想，就像我的模特，你可能会这么说，但我认为这是一个很好的循环标题，我知道循环会重复给定的次数。

我将把它简化，只需乘以，时报，身体里有什么，即使它可能是再加上一两个检查，你知道其中一些，这些测试什么的，是啊，是啊，如果你不，将语句定义为一行，其中使用如下操作，把某物等同于某物。

把某物赋值到某物的分数加法附近，是啊，是啊，我是说你可以想我们喜欢的不同的事情，一天的结束，你的计算机要计算或查看的一切，对的东西很重要，而且这个模型有很大的缺陷，是的是的，呃，直观的模型。

那是真的真的很简单，我承认这在各方面都是不正确的，嗯，但是，你去这里，它是嗯，它仍然有助于推理，我想我的声明仍然有效，代码的n平方部分是坏的，慢的那个，所以当你有一段代码。

想象一下你有一个更大更复杂的代码，你分析它的方法和我们在上一张幻灯片上做的一样，你想出了这个，你说这段代码运行点4和q加2，五分钟平方正加，这是声明的数量，我想这将基于我对代码的研究，如果你想推理算法。

如果你想对它们的速度或速度有一个很好的直觉，你真正想看的，并不完全是这个数字加起来的结果，你想不想考虑一下所谓的增长率，如果你有这个值n，你知道我的幻灯片和最后一张幻灯片的值是n，N是什么。

只是一些数字，但也许n就像向量的大小，我们将处理向量的所有元素，在找东西，或者是班上所有的人，我要去找一个学生，不管它是什么，n是输入数据集的大小，我在看，对于给定的算法，你真正关心的是，会发生什么。

如果我的输入数据量增加，会发生什么，如果班级扩大两倍，运行时将发生什么，很多人会说，啊，一个算法可能需要两倍的时间来运行，如果班级扩大两倍，但那不一定是真的，如果算法的运行时相对于输入大小。

这真的是你的n的翻倍吗，你知道的，使您的运行时在这里是双倍，双倍，在合适的时间加倍或八倍或其他什么，所以当我们试图解释运行时，这是你要做的，如果你能想出这样的表达，忽略所有常量，像这个25和这个8。

你只要把它们扔出去，他们确实很重要，但你把它们扔掉，就连这一点四，你把它扔了，你说，啊，它是正方形和立方体，加n的平方，加n加1什么的，然后你只关心最上面的术语，所以真的很喜欢这一切，现在唯一重要的是。

因为如果你增加n，您将在运行时看到一个相同增长的多维数据集，这才是最重要的，如果你有两个不同的输入，然后假设您有一条最多n的消息，另一个是n，您想如何使用，这是真的，这假设了一些。

它假设我们的算法只依赖于一件事，有很多算法依赖于两三个不同的东西，有多少学生，有多少个班，有多少所大学，不管有什么，有很多算法依赖于，您可以扩展这种逻辑来讨论每个算法是如何增长的，与这些事情的关系。

你可以对这样的事情进行多元评估，我认为它的核心，很多评估都简化了，这种事情重复并大于等于一次，你知道当我们谈论这个的时候，我们说这个算法按n到3次方的数量级运行，或者简短的说法，也就是说。

这个算法是第三步的末尾，N的大O到第三，再一次，意思就是，如果我增加算法运行时的变化，似乎是那个立方体，所以如果你看向量，你可以讨论向量的这些不同操作的效率，使用这种术语。

你可以说如果你想给向量加一个值，就是说，在矢量的末端放一些东西，添加操作，不需要花很多时间，你只要把一些东西放在那里，把矢量的大小增加1，当某些东西没有依赖于输入大小的运行时，名单。

你只要说它有一个恒定的运行时，它被写成一个的大O，并不意味着它只需要一个指令，这只是意味着它所需的时间与向量的大小无关，如果要询问元素的内容，使用需要恒定时间的方括号。

因为计算机只是为了跳转到内存中正确的位置，这与数据的大小无关，如果要删除或插入东西，它必须滑动所有这些元素，所以我们说它需要n的大O运行时，现在呢，当我们马上就要回家的时候，你可能会有一个问题，这里是。

但我想这需要不同的量，我想如果我在这里插入或删除，挺快的，或者这里是中等的，或者这里真的很慢，我如何决定在这里写什么，嗯，有人说最好的情况，平均案件，最坏的情况。

插入和移除的最佳情况是最后一个恒定时间的大O，一般病例居中，最好的情况或最坏的情况区域在最左边，看看所有这些，平均一下，如果你是，我们从很多不同的地方搬来，就像你在中间一样。

大约是n个元素的一半需要调整，n的一半仍然在，因为我们忽略了这些常数，所以我们会说，平均，这些操作需要n个，所以这是一种语言，谈论事情有多高效或低效的快捷表示法，如果你想说这很慢，而且这个很快。

说这是大的更准确，一个中的O，这些是大的，全都是，我没时间了，我要去我的办公室，在盖茨，一百九十五，如果你有任何关于家庭作业或可爱的问题，造物主什么的，我很想在那边见到你，我会在那里呆到三点。

祝你有美好的一天。

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P5：Lecture 05 - Stacks and Queues - 加加zero - BV1By411h75g

我也很伟大哈哈哈哈，我妻子今早告诉我，她觉得我长得像史蒂夫·乔布斯，或者黑衬衫，我就像女孩的工作，不会成功的，否，但在出去的路上，我就像，哦，还有一件事我爱你，是啊，是啊，是啊，是啊，很俗气，然后也是。

反正，然后艾米告诉我她觉得我也像史蒂夫·乔布斯，所以我想，好啦，我要买件新衬衫，今天是星期三，现在是第二周，我们在研究收藏，上次，我们讨论了向量，我和你谈过这个大O符号，呃，大o符号是用来做什么的。

效率代表什么，你要说，是啊，是啊，一个人很好地举手，然后其他人都喊了出来，这两种都可以接受，通信形式，它是用来提高效率的，有一个特定的，你可以说得更具体一点，虽然就像，如果我说n的大o对n的平方。

我到底想说什么，那个短语到底是什么意思，当我们提供给它的输入增长时，算法的运行时间是如何扩展的，重要的是增长率，这就是大课的真正含义，是呀，好的评论，你可以说时间复杂度或时间效率，运行时效率。

这些都是人们可以互换使用的术语，是啊，是啊，是啊，是啊，当然，所以我们今天和周五会更多地讨论这个问题，我还会教你一些其他的收藏，我们可以从本周开始使用你的部分，你们有没有收到邮件告诉你们在哪个区，是呀。

如果你不知道你在哪个区，今天找个时间去你的手机或电脑，去CS一98斯坦福EDU网站，如果你在这里登录，它应该告诉你你在哪个区，你可能想在课间或课后检查一下，因为有些部分是在今天的课后。

所以你不想错过第一节课，如果你忘了报名，你可以去同一个网站做一个延迟注册，我们可以把你安排到这周的一个部门，好啦，所以不要忘了切分，我们开始那些，我不想说太多关于部门的事，因为我们时间有限，但是区段。

我们提前一两天寄出讲义，如果你想看看问题，我们将讨论，问题也在我们的小在线工具代码中，一步一个脚印，你不必提前解决这些问题，你们进入课堂，一起讨论这些问题，并解决其中的一些问题，如果你不把它们都吃完。

没关系，好像有十个问题，你不会把它们都吃完的，你没做完的不是作业，那些就在那里，如果你以后想看的话，你应该在最后得到一个解决方案密钥，如果你想看答案，所以这些只是你在你的部门里看到的问题，除此之外。

就看你了，它是可选的。

好的，好的，所以我想回到我们说过的关于大O和增长率，所以我们讨论了如何，如果您有一个表示算法运行时的复杂表达式，真正重要的是最重要的术语，我们把前面的常数扔掉，我们只说n立方体是这个算法的阶数，当然。

这种力量越高。

你的程序越慢，或者你的增长率在给定的投入增长下更快，所以我们讨论了这些向量运算，其中一些是一个恒定的时间，其中一些是线性的时间，它们与向量的大小成正比，n当您从向量中的任意位置添加和移除元素时。

所有从左到右在元素上的移动和移动，这导致了n运行时的大O，好啦，我把它涂成红色，只是不要说这些是糟糕的操作，或者你不应该打电话给他们，那不是我的意思，我的意思是，你应该知道他们的成本略高。

所以如果有一种方法可以编写相同的代码，不太使用这些操作的，你可能想用那个，你只想知道代价，你就是，你在这里引起的，对呀，好啦，所以就像一个快速的，一种测量这些东西的方法，以下是算法运行时的一些主要类别。

我是说这些数字是焦点焦点，但就像给你一个例子，一个算法可能需要多长时间，如果它有这些不同的增长率，很快，如果你开始上升到这些增长率，就像在立方体变成第四个，不管它变得真的真的很糟糕。

对于一个在较低的增长率下几乎立即运行的算法来说，特别是，有一些算法，就像它们是成比例的，可以调整它，哪种方式，如果在向量中再添加一个数据元素，算法的运行时间翻倍，你可能会说。

我想不出有什么事情会花这么长时间，但是好吧，你们中的一些人会在编程中发现，但是呃，你们中的一些人会很好，以后再说吧，这些不同类中的一些算法，我想大多数人都能理解恒定时间和线性时间，我们看到了。

你知道你可以在n的平方中得到n的平方，如果你有一个矢量，你必须检查每一对元素，n种类型成对或两种准备的平方，这个对数类有点像用来解决问题的，一遍又一遍地把输入分成两半，就像你在做所谓的二分搜索。

我们以后再谈，你不断地从考虑中削减一半的元素，所以这与输入大小的对数有关，反正，这些都是运行时类，你会在不同的算法中看到，好啦，所以我想谈谈，还有一种叫做链表的集合类型。

您可能在以前的编程中看到过这一点，我不会假设你已经看过了，我今天要在一个非常高的水平上谈论它，在本课程的后面，几个星期后，我会回来的，我们将在内部实现其中的一些集合，但不是今天，斯坦福收藏中有一个类。

称为链表的库，链表的奇怪之处在于，它不会做任何矢量做不到的有趣的事情，它有完全一样的，它有同样的东西，你可以创建一个，你得进口，我没穿滑梯，你必须包括一个链表，但你，您用这里元素类型的相同语法声明一个。

然后我在之前的幻灯片上给你们看的所有关于向量的操作，这里也有，然后插入，移除到字符串大小为空，都一样，完全是同一套方法，所以这很奇怪，当你第一次遇到这个，为什么建造这个图书馆的人。

做完全相同事情的两种集合，好像是多余的，你可能知道计算机科学家描绘的三件事高于一切，冗余、低效率和冗余，是的，所以这违反了这三件事中的两件，所以冗余和冗余，对呀，所以我们不明白为什么我们会有那么好。

为什么会在这里，除了这里的矢量之外，它们是以非常不同的方式建造的，在里面，使用数组构建向量，它是一块大块内存，将每个元素存储到链表中，是由这些叫做节点的小盒子组成的，每个框中存储一个元素值。

然后节点连接或链接在一起，使用一种叫做指针的机制，我今天不想太多谈论，但可以说，你几乎没有，我说的是像，你知道它几乎就像小火车车厢，你知道在哪里，如果你想，如果你有一辆又大又长的火车。

你可以把车拆开重新排列重新组装，每辆小车都有一些货物，这有点像链表的作用，好啦，为什么它与矢量不同或更好或更差，嗯，你知道我们以后再谈，但我想我现在要说的是，其中一些操作在链表上更快或更慢。

因为不同的内部结构，例如，如果这是您拥有的链接列表，你说我想在索引3处插入4-2的值，链表的作用，而不是把钱转移到上面，只是告诉这家伙一个非常盒子，之后，你将是一个新的盒子，里面有一个42。

下一个盒子是有七个的，因为种种原因，电脑不需要把内存移到它上面，它就能工作了，因此，由于这个原因，插入现在有了不同的运行时，当然你知道当你有一个合适的链表，你必须在列表中找到做这个操作的地方。

所以我的意思是这有一些利弊，但我的观点是用不同的方式建造东西，内部可能会导致一个不同的大O，或者同一组操作的不同运行时，有趣的是，所以你说这可能会更快，因为你不必改变事情，但同时你刚刚提到你必须迭代。

直到你到达你想放在右边的元素，所以问题是，这是一个不同的大O，是不是更快，是不是慢了，嗯，好啦，我是说，我想描述一下如何添加到链表中的一般概念，我还没有真正回答，实际上是快还是慢，如果你用计时器测量。

哪一个会更快，我觉得像这样的作品，与矢量相比，这有一些利弊，但在某些情况下，链表显然比向量更好，例如嗯，如果要向链接列表的开头添加某些内容，真快啊，你只要做一个新的方框点，旧盒子上的新盒子，你就完蛋了。

对于向量，你必须用链表移动每个元素，你不必把任何元素运过来，所以前面的插入操作，对于链表来说，这有什么大不了的，它是一个或恒定时间的大o，与对向量来说是n的大o相反，就像我没有说很多细节一样。

我们会更详细地讨论这个问题，我想和你一起勾勒出大致的概念，相同操作的两个内部实现可能有不同的内容，哦，如果你看看这张图表，哦对不起，我的滑梯好像断了，但如果你看看这张图表，看起来链表更糟。

但这些是平均运行时，我想这些星号我想强调的是，就像，如果你在前面插入，链表实际上是一个大O，即使平均值是n的大o，所以我不是想说，你看，链表是坏是好，或者别的什么，我只是说，如果你要列出一个元素列表。

然后呢，你知道你将要做的，列表前面的一大堆插入和删除，您可能会特意选择链接列表而不是向量，因为这样会更快，所以你去那里，你有多种方法来实现相同的操作，我们称之为抽象数据类型或添加抽象数据类型的概念。

这是你想要的一套操作吗，这与你如何实现，保佑你，所以这里的a t可能被称为列表，我想要一份数据清单，列表操作的具体实现可能是一个向量，也可能是链表，所以名单A T，在字典或地图上设置。

这些是更普遍的事情，可以有多种不同的实现，是啊，是啊，我在搬家，为什么要加上间隔，我是零一，哦哦哦，为什么，如果添加到链表的末尾，为什么那快井，因为大多数链表维护标记以到达两端的末尾。

所以如果你加上前面，它可以很快地直接跳到那里，如果你加上最后，你可以直接跳过去，但如果你想走路去别的地方，你必须沿着这些链接走，找到中间，所以中间通常是不好的地方，是啊，是啊，但这取决于你如何实现它。

好啦，所以无论如何，这是一个有趣的想法，EDT的这个例子，当我们学习如何实现集合时，我们会考虑这个主意，很多，事实上，大多数语言在java中有多种adt实现，有一个数组列表类，你可能用了。

如果你来自6A或Java中的一个，P课程之类的，除了射线列表，还有一个类叫做链表，我不知道你有没有用，但它在Java中，有一种东西叫做哈希图，就像一本配对词典，还有一张树状图。

它是一本略有不同的配对词典，有一个哈希集和一个树集，在Java中，它们通常有两个或三个相同操作的实现，在许多其他语言中，所以这个概念在编程中很常见，所以没关系。

有什么问题吗，真实，在我跳之前快点，我想在这里跳转到另一组幻灯片，是啊，是啊，哦耶，所以对于链表，如果我继续搜索列表中的元素，程序是否，从第一个跳到一个一个跳，然后定位五个元素中的这个元素。

让它像在for循环中，我多次搜索某个元素，在搜索中它要做什么，嗯，我是说，我认为在这两个结构中的任何一个中搜索都是一种线性遍历，如果要在向量中搜索元素，你得在每只眼睛上打圈，查看每个框中的元素。

想搜索链表，它必须通过沿着这些链接跳跃并查看每个盒子来循环，所以我认为每一个都有一个线性的运行时，如果你做了多次搜索，您可以注意到链表上的减速，因为它要在列表中遍历很多次才能找到，但是是的。

他们都不适合搜索，说实话，如果要搜索元素的成员资格，有一个更好的结构，我们将在本周学习，例如，如果我想添加一个元素，哦，增加每个元素，是啊，是啊，有一种方法可以把这四个循环起来，每个循环都是通过引用。

在那里你可以做，加加将是和大正方形，这将是一个很大的o n，如果对每个循环使用，通过引用循环每个元素，加上这个值或者改变这个值，那很好，从比基尼上搜索，嗯。

no for a for each循环使用更高效的内部迭代结构，为了那个，所以你是对的，如果你用一个列表，错误的链表，您可能会产生很高的运行时成本，你得小心点，我们会回来的，更坦率地说。

我不会让你使用链表，在这周的家庭作业中，所以这就是为什么我要强调它，就我们花在这上面的时间而言，我想在向量上花更多的时间，因为这是典型的，我们想用于该类中大多数问题的一维结构，但这个对某些问题更好。

尤其是那些大部分的添加和删除都在开始的地方，如果是在最后，矢量就可以了，如果它在中间，他们两个都不好，所以主要是，如果你在前线做事，一遍又一遍，链接列表对此有好处。

反正，好啦，这是一个链表，这就是ADT的简称，我们会经常重温这个想法，所以我认为今天这堂课的两大主题是，我之前说的话，也就是说，通常有不止一种方法来实现相同的操作，每种方式都可能有利弊。

今天的第二个大想法是，如果你建造一个简单的结构，没有很多支持的操作，它可能能够更好地、更有效地或更简单地执行这些行动，这就是为什么我想和你们谈谈两个结构，称为堆栈和队列，这个内容来自教材的第五章。

就像其他的收藏品一样，所以堆栈和队列，它们是我所说的专业收藏，我想这对我来说很难，为了让你相信这些很酷，因为他们所做的一切你都可以用矢量，矢量可以做得更多，所以这些东西比矢量更糟糕。

但我不知道该怎么跟你说，就像你有能力利用这些强大的矢量，我想卖给你更坏的东西，但就像你们拿着电锯，我想卖给你一把牛排刀，你知道有时候我不想要电锯，因为我可能会把胳膊切下来，什么的，你知道的。

我不知道更多的权力并不总是更好，你为什么有一辆自行车，如果你有车，有时，由于种种原因，一些不那么强大的东西仍然有用，所以stat是一个以给定顺序存储元素的结构，您只能从该顺序的顶部添加和删除元素。

所以你可以把东西添加到顶部，它们就会堆积起来，或者你可以把上面的东西去掉，也就是说你最后加的东西会出来，那都是一堆，有吗，就是这样，嗯，还有一个叫Q的东西，就像一排元素在等待，其实呢，如果你来自。

如果你是英国人，你会，你会打电话给排队等餐馆的人，或者你称之为暗示的东西，所以它是添加在行后面的一行元素，从前线撤下，那都是暗示，又这样做了，这些不是很强大的结构，你可以用矢量来做所有这些事情。

但也许我们还是想了解这些，所以让我们先弄清楚为什么我们要做堆栈，所以再一次，你把事情堆积起来，你加上，他们以一定的顺序被记住，你说最早添加的元素在底部，最后添加的元素在顶部，如果要求堆栈移除元素。

出来的那个是在上面的那个，你上次加的那个，所以这就是为什么他们说，一些谈论堆栈的人说它有最后一个，是第一个出去点菜还是老，现在你必须考虑的一件事是，当你，当您使用堆栈时，你不太谈论索引。

就像int i等于零，我们用那些括号和索引，很多向量和网格，所以你们真的习惯了索引，作为喜欢的方式，伸手去收集东西，但有一堆，你不是真的那样做的，你得放弃这个想法，访问元素的唯一方法是说嘿堆栈。

请给我上面的元素，其余的元素是你无法到达的，你拿不到的，他们在下面，就像一个真正的堆栈，你去自助餐厅，那里有一堆盘子，你抓住上面的盘子，你知道顶板上有时会有粘液，你不要最上面的盘子，但他们就像。

有一大摞很重的东西，你不能伸手进去把底板拿出来，因为它们堆积如山，所以有点像，你只能到最上面的那个，所以放弃索引的概念，你只能访问这个，堆栈支持的核心操作是向顶部添加一些东西，我们通常称之为推到堆栈上。

从顶部移除元素，我们称之为从堆栈中弹出一个元素，通常您支持一些操作来查看位于顶部的元素，在不移除它的情况下，我们称之为堆栈峰值，你为什么想要这种东西，嗯，在cs中有很多问题都有类似堆栈的结构。

当您构建编译器或编程语言时，您经常管理像堆栈一样的数据，例如，当函数main调用函数a时，它调用函数b，它调用函数c，这些函数中的每一个都堆叠了一组关于函数和参数的内存，局部变量调用堆栈。

如果编写编译器并计算表达式，你知道a等于b乘以c加d，您通常会将要计算的表达式和参数堆叠在一起，堆栈对于匹配各种任务非常有用，事实上，如果你上了理论课，你就会学到，你知道的，基于堆栈的计算模型很有趣。

推下自动机和这种性质的东西，例如，如果你想知道一个字符串是否是回文，你可以把字母推到一堆上，然后把它们弹出来，看看它们是否以同样的方式出来，堆栈的一个有趣的副作用是，如果你向它添加五个东西，你知道一二。

三个，四五，如果你移除它们，他们出来五四，三个，二一，所以你最终看到他们以相反的顺序，你把它们放进去是有用的，如果任何形式的反转任务，如果堆栈对此有好处，以此类推，有很多算法。

我最喜欢的堆栈应用程序之一是，您可以用它来帮助您编写迷宫求解器，你把你想搜索的地方堆叠起来，你把东西拿出来搜查，它帮助你跟踪要看的东西的顺序，您还可以使用它来实现撤消功能。

就像你在写文字处理器或Photoshop程序，您可以保存用户执行的每个操作，你把它们放在某种收藏中，假设你把它们堆成一堆，然后如果用户单击撤消，他们想撤销最近的行动，就是在堆栈顶部的那个。

所以很多这样的任务对他们来说都有这种性质，在这种情况下，堆栈是一个很好的结构，这就是什么是堆栈的概念，对此有什么问题吗，到目前为止，哇塞，这个小组没有问题，我惊呆了，哦一个，是呀。

其中运算符在操作数之间，你可能会说，还能是什么，但有一些手术你说像加AB，意思是加上a和b，就像，如果你有一个坏的计算器，你得这样打，有时还是要感谢惠普，是啊，是啊，仅仅计算数学表达式，基本上。

如果您想实际编写使用堆栈的代码，我们在斯坦福收藏图书馆有一个书库，我们包括堆栈H，下面是你得到的几乎所有的函数，还有一些其他的，但这些是其中的大部分，您还可以打印堆栈以查看输出流，所以你可以偷看。

这意味着在不移除堆栈的情况下查看堆栈的顶部，你可以弹出，这意味着从堆栈顶部移除，或者您可以将一个值推送到堆栈的顶部，所以当你想声明一个集合时，您只需获得要存储的数据类型，你推，推，推，然后你推42。

负3和负17，如果你把东西弄掉，你会得到17负，三四十二，事情很简单，所以我不会把这个，是啊，是啊，你必须存储一种类型的数据，就像int到堆栈上，和其他收藏一样，是啊，是啊，很简单的事情对吧。

只是这里没有太多的行为，你会注意到没有索引，没有方括号，没有get元素，东西不见了，它不在那里，你做不到的，只是不是堆栈，不是什么，这是为了，是啊，是啊，假设你想把一堆物体，然后有一堂课。

如果您想使对象堆栈，是啊，是啊，你得你得用指针，基本上是为了那个，我们几个星期后再做指点，是啊，是啊，如果你想，您希望将对象堆叠在一起，你要么，把一堆东西，在这种情况下，它们会被复制到上面。

或者你做一堆指针，它不能很好地复制它们，我们会了解的，嗯好吧，所以这里有一些你不能用堆栈做的事情，我是想说服你，多酷啊，这是所有你不能做的事情，孩子，我是今天的不史蒂夫滴，对不对，他就是这么做的。

他只是把东西拿走，他拿着耳机，千斤顶走了，他把所有的功能键都拿走了，在键盘右上方，所以我有点蒸汽Chompsy，我把你的航向，但是现在我得到了i向量，它不再有索引了，它是如此的溪流右，现在是九十九。

九十九，嗯，是啊，是啊，我不是苹果的超级粉丝，但那是，反正，对不起，因此不能通过索引访问元素对堆栈进行循环，我只是不让你，它不编译，它不工作，你所做的通常是写一个循环，当堆栈不为空时。

我会从堆栈中弹出一个元素，我会用，事实上，我很确定即使是for每个循环在这里也不起作用，所以没有办法在元素上循环，你得做一个循环，把东西拿出来处理，当然这个循环有一个有趣的地方，如果你运行一个循环。

当堆栈不为空时，弹出一个元素并在循环的末尾打印它或其他什么，堆栈的状态如何，是空的，所以关于斯塔克斯的一个有趣的事情是，你不能在不把它们清空的情况下处理它们，你知道，因为有时你想在矢量上循环什么的。

然后当你做完，你希望矢量内容仍然存在，堆栈使您清除内容以处理内容，但又一次，如果这不是你想要的，也许您不应该在这个特定的问题上使用堆栈，大多数这类问题，如果要访问堆栈或使用堆栈，这就是你想要的。

所以效果很好，我想和你们做一个快速的例子，我想写一个名为支票余额的函数，这是我想看的一个字符串，它表示像C++代码这样的代码，我想要的是，我想找括号，我想找卷花括号，我想看看他们在绳子上是否平衡。

所以换句话说，如果你在这里打开一个括号，你最终必须像这样关闭括号，或者如果你在这里打开一个花括号，你得把这里的花括号合上，但这些东西可以嵌套在正确的地方，里面有圆括号的卷曲。

所以你不仅要关上你打开的东西，但你也必须有正确的相对顺序，所以如果我打开这些括号，然后我关闭一个花括号，这是不正确的理解，就像如果我打开什么东西，我得先把他关起来，我把他以外的人都关了，好的好的。

这是堆栈讲座，那么堆栈如何帮助我解决这个问题呢，你觉得怎么样，是啊，是啊，我的第一个猜测是，每次你看到一个打开的括号，堆栈的索引，然后每次你看到一个删除一个索引，然后每次你试图删除你首先检查它是否为空。

所以你知道，如果有像，如果你想删除太多，它就会指向索引，是啊，是啊，我想你有正确的算法种子，你说过，当我看到开括号和花括号时，我把东西推到堆栈上，当我看到关闭的东西，我会从堆栈里弹出来，我会比较一下。

看看我是否喜欢我所看到的，看看事情是否吻合，你刚才提到，我可以把索引推到堆栈上，我觉得只要把角色自己推就行了，我不太关心索引，我的意思是我最终必须返回索引，但我想我可以用不同的方式做到这一点，基本上。

如果我看到这些开放的卷发和王子，我可以推他们，如果我看到关闭卷曲，我可以把它弹出来，我想这是这里想法的核心，如果我们没发现绳子有什么问题，我们会说不平衡在指数负1，但如果我看到不平衡或有什么问题。

我将像这样返回发生这种不平衡的索引，我看到一个卷曲，但它应该是一个结尾插入语，我会退回14号索引。

所以我要在《可爱的创造者》中解决这个问题，我想我能做到，但我想玩得开心，去网站。

逐步网站，在这里有个练习，所以我可以在这里键入我的代码，嗯，那么函数的标题是什么呢？是一串代码什么的，对对你说，如果有人说堆叠得很好，我是说，我想用一个堆栈，但我想函数的标题不会让我通过一堆。

我想在这里用一个，嗯，你们看到了吗，把那里弄大一点，好啦，那么现在我在这里要做什么，是啊，是啊，这个东西已经包含了，我会包括堆栈点h，所以它已经知道了，所以我可以开始写这个代码，所以你想让我做一堆。

我们可以把括号，就像一堆被称为括号分号的忧虑，现在怎么办，好啦，循环字符串的字符，当然，对于每一个int，我从零到代码，点长度，我加加酷，所以现在你说，如果我看到牙套，我可以推到堆栈上。

所以我为什么不现在就实施呢，所以如果代码i是括号，或者代码I是，然后我会做括号，点推码，我把那个字符推到堆栈上，好啦，我想是从，如果是闭合支架，是呀，所以我想你会有这样的感觉，所以如果你按照这个算法。

推圆括号和圆括号，然后我可以看到一个结尾括号，所以堆栈会有像这两个东西，我看到了这个，所以我得确保这个和，上演什么？在堆栈的顶部，对呀，那么其他的呢，如果事情是一个结束，嗯，括号或卷曲，所以这个或那个。

你可能想要，你想让我做两个，好啦，当然可以，如果那样的话，当然好的，所以如果是闭合支架，我有一个，我有一堆字符，我可以说焦顶等于点，如何从堆栈弹出窗口中删除，这是正确的，所以说，对不起，那是什么？

你为什么要把你怎么知道的，当你把这些结合起来，你想让我把它们重新组合起来吗，不要这样做，好啦，我们会写的，然后我们可以决定我这里有300个编译器，帮助我，嗯，所以等等，就像如果上面的字符不是开头的括号。

那很糟糕，对呀，是啊，是啊，所以这意味着我会返回，这里有一件坏事，我们返回这个索引是坏的，这意味着索引，我是坏人，你明白的，好啦，所以你会看到一段类似的代码，如果这是个结案陈词，我会说我希望它是那样的。

否，开场，闭幕，我们需要检查，哦对不起，开场的那个，对不起，是呀，是呀，你最后也需要，好啦，我想有几件事我们还需要解决，我在这里听到了很多非常有用的不和谐的建议，突然告诉我一件事。

你想让我用眼镜在后面贴上地址或固定一下吗？是啊，是啊，等等，是不是有，不要，因为，如果你喜欢，像两个，像个普通的公主，然后就像一个的两个流，你不觉得这很有道理吗，是啊，是啊，这是个好问题，怎么样。

如果括号太多，相对于开头括号的数量，否，我遇到了不同的种类或太多不同的种类，是啊，是啊，我想一切都会好的，只要前面的堆积如山，然后我们把它们弹下来，当我们看到与他们匹配的东西，我想我们会没事的。

所以我认为这个代码会推，推，推，推，然后当我们看到他们的闭门造车者，我们会砰砰砰砰，我们会比较每一个，所以我想只要代码是有效的，这一定行，但可能有一些情况它没有妥善处理，比如哪种情况，可能处理不好。

它可能会被用在这些结尾的事情上，因为书库，如果堆栈为空，就像堆栈上什么都没有，就像如果我说打开，然后关闭关闭那一秒钟，关闭，纸堆上不会有任何东西，如果您试图从空堆栈中弹出。

它以一个坏的异常使您的程序崩溃，所以实际上我可以离开它，我你知道，我不知道，这件事你不必相信我的话，我来帮你解决，你说的对，那是个窃丨听丨器，在我修好它之前让我先修好它，如果我们一路，我实际上试图提交代码。

它说我的控制已经到了我功能的尽头，意思是我最后没有还东西，如果我一直走到for循环的尽头，那就是说绳子没有问题，我应该回一个负的，如果弦没有问题，弦是好的，好啦，所以我提交了这个，上面说我有个例外。

试图从空堆栈中弹出，我相信这在这次测试中发生了，这就是这些平衡的地方，但现在我有一个没有开瓶器的更近的东西，所以我想就在那里我有一个空的，原来你是这么说的，好啦，酷，“那么你想让我在这里做什么。

就像在我弹出它之前，我可以说如果是空的，那很糟糕，好吧，所以返回i，这意味着没有平衡的井，你们很聪明把这两段代码分开，爸爸：那完全不一样，我只是在为难你，好啦，所以现在我通过了那个案子，我通过这三个。

但现在这个失败了，这里的情况有什么问题堆栈在堆栈处是空的，最后不是空的，就像当我看到这个，它与此相平衡，但当我看到这个，对他来说没有平衡，我相信规格，我没有把问题的详细说明留在屏幕上很长时间。

但我相信我们应该做的是，有一些开瓶器没有关闭，我想我们应该把绳子的长度，作为错误可以接受的地方，那么现在我如何将它合并到这个算法中，在最后，是啊，是啊，当我完成我的for循环时，如果呃。

如果Paren堆栈为空，那很好，所以我会返回负的另一个，我将返回代码字符串长度，那怎么样，好啦，我们做到了，所以我曾经有像达斯·维德的声音和东西，但后来我想我可能会因此被起诉。

所以我把它改成了像模糊的电子游戏噪音，那口井不是晦涩而是像，我想他们不会知道的，任天堂从不起诉任何人，作为一家公司，他们不喜欢打官司，好啦，反正，别管把那部分从视频里删掉了，所以我们很好，我们做到了。

我是说，2。你看这问题的症结所在，我觉得我们应该，也许试图巩固这一点，不过没关系，我把这个留下，如果你想去解决，你可以，我只是想玩堆栈，做一个例子，我们推和弹出，我想我的论点是我们完全可以用矢量。

本来可以的，但我们不需要任何矢量的东西，这堆东西很好，我认为把东西推上去和把东西弹出来的想法，我们对这个问题有点直觉，所以有这样的问题，在那里堆叠就可以了，你可能还是不相信，因为你说看矢量很好。

我只想学会用矢量，我不在乎史塔克，我想我要说的是关于堆栈的另一件事是，因为它只需要提供一些操作，这可能意味着实现堆栈的人，以一种非常有效的方式建造它，一种非常轻量级的方法不使用那么多内存。

也许跑得更快一点。

其实呢，我想我有一个幻灯片来这里，我说的地方，等一下等一下，坚持住，我没有那种等待吗，我去找找，它在哪里，对不起，对不起，对不起，我这里没有大O吗，啊，我做它就在那里，好啦，所以我没提这件事。

我没有强调这一点，当我展示这些操作时，但看看你，堆栈执行的每一个操作都是高效的，我们进行一次恒定时间操作，所以我的意思是，如果你不提供那么多的操作，也许你可以确保你提供的，或者以聪明高效的方式实施。

那很酷，所以几乎不可能打错电话，让堆栈花很长时间才能完成调用，你明白我的意思吗，所以这是一种整洁，好啦，关于堆栈的其他问题吗，或者支票余额，或者我们写的源代码，后面，是啊，是啊。

我曾经在同样的时刻做同样的事情，这里也可以用矢量，是呀，如果我们以正确的方式小心地使用它，如果我们总是从向量的远端添加和删除，它的效率就和这个一样高，是呀，所以在这个地方使用矢量是绝对可能的，所以是的。

我是说，我不是想说斯塔克斯，做好这件事的唯一方法，我只是说这件事几乎迫使你以一种有效的方式去做，因为它什么也做不了，你知道这是牛排刀，不是电锯，好啦，如果您真的想知道堆栈是如何在内部实现的。

我不想在这上面花很多时间，但它通常使用向量或数组来实现，当您想向堆栈添加内容时，底部为零指数，顶部为最高指数，你觉得我们为什么要把它们按那样的顺序储存，而不是相反，是呀，恒定时间的去除操作。

我们不想移动东西当我们，是啊，是啊，就像如果我从这里跳出来，我得把这些家伙滑过去，那不好，我想把你做加法的地方推来推去，移除是顶部，所以这应该是数组的末尾，因为这就是从数组中添加和删除最有效的地方。

是呀，您可以使用链表，但更常见的是使用数组，一个问题，是的，是的，能力，我们上周讨论过，上课，在这种情况下基本上是自动的吗，还是有手册，哦对了，就像这个空间用完了，它会调整大小吗？它有点像矢量。

从某种意义上说，它可能有一些额外空间的数组，当空间耗尽时，它会自动生长，而你作为它的使用者，不用担心，如果您要从头开始实现自己的堆栈，如果没有堆栈这种东西，你想建立一个，你得考虑一下这个问题。

又是那个问题，那为什么，就像，哎呦，为什么插入一个大O，我们称之为摊销运行时，几乎所有的广告都是一个大O，偶尔也有一个不是，但如果你能把他的成本分摊到其他人身上，如果你仔细想想，你有N个快速的广告。

一个N加的第一个广告很慢，所以如果你把他的成本分摊，这几乎就像所有其他的成本是两个而不是一个，仍然是一个固定的摊销金额，所以总的来说加法是不变的，虽然是的，在最坏的情况下，它可能不得不调整大小，好啦。

所以说，让我们谈谈排队，另一个没什么作用的结构，但它是否以一种有效的方式，排队，这有点像一个等待名单上的人或类似的东西，你在后面加东西，名单的后面，你把清单前面的东西去掉，而我们，所以我们说。

第一个进来的是，第一个出来的人，这就像一个，不准作弊，没有削减，你不能站在队伍中间，我是那种喜欢追人的人，因为他们插队了，然后他们就走了，这是我妻子，我很抱歉，你跟你太太到后面去，头上的先生。

但提示是收藏版的我，它不允许任何人从中间切入，它确实以给定的顺序存储元素，好像它知道谁先插进去谁最后插进去，所以他们有一个命令，但我们并不真的认为它们有像零这样的括号索引，一二，你只在后面加。

你只从前面移开，队列支持的三个核心操作在队列中调用，有时候你叫它加法，排队，你也可以称之为移除和峰值，你可以从这里来，这个前面的元素，对呀，你为什么要排队，在计算机科学中有很多例子，如果您有一台打印机。

并且不同的计算机都可以打印到同一台打印机，打印机需要一分钟才能把页面打印出来，你得有一份工作清单，打印即将出来的工作，他们将按什么顺序出来，所以打印作业队列就像一个经典的地方。

您可以在其中使用这种类型的集合，有各种各样的东西，比如你有一个网络连接，像BitTorrent或下载什么的，它必须发送或接收一组数据包，它必须按一定的顺序做，所以它让他们排队。

但它会把他们从队列中发送出去，当连接准备好时，在编程中有各种各样的例子，你想排列的东西，然后按顺序做，事实上，很多情况下，你使用矢量，你可以用一个Q，完全取决于你在做什么，所以是的，好了。

现实世界的例子和东西，如果要在C Plus代码中使用队列，您可以包括库，这些是它支持的主要操作，就像堆栈一样，他们都是一个大O，他们都很有效率，你可以添加到后面，你可以从前面移开，你可以在前面达到顶峰。

你可以问它是不是空的，或者里面有多少元素，这里有一个快速的例子，三个元素的I队列，四十二人先排队，所以当我离开的时候，四十二先出来，不会是什么，DQ一号怎么，如果你必须从前面移开试着把整个东西移过来。

是啊，是啊，问得好，如果退队是一个大O是怎么回事，你的问题，我认为这是一个数组实现，因为它会改变，但答案是，这通常不使用数组来实现，我想我有一张幻灯片，我想前面有一个跳跃滑梯，但通常将队列实现为链表。

哪里，如果这是前面，我想让他离开，我只是抓住他，我总是把他从那里抓出来，然后我就把这个删掉了，现在我让他站在前面，如果你想结束，你通常有办法很快到达终点，一种快速到达前线的方法，可以使用数组实现队列。

你用一个叫做圆形数组的东西来跟踪，而不仅仅是零到大小类型的东西，当你离开时，你认为前面是向前移动索引一两个，这样你就不用转移你，您可以将队列想象为从索引1、2或3开始，但后来就变得混乱了。

因为你走到了最后，你喜欢绕着，你知道时间漩涡打开了，诸如此类的东西，所以不管怎样，但好消息是，它通常没有任何效率问题，它通常是在恒定的时间内实现所有这些操作，是的，所以实际上是一个向量。

如果你想做同样的事，要确保你有效地做这件事就有点难了，你经常会，如果你加到向量的末尾，从向量的前面移除，除非你很聪明，否则这些前面的移除往往会很大，所以你知道，这有时确实会让你得到比矢量更有效的结果。

到目前为止还有其他问题吗？我只是给你看基本的，就像用一堆，你不做从零到大小的for循环，通常你不会每一个循环都这样做，通常你会有一个这样的狼吞虎咽的循环，当队列不是空的时候。

您出列一个元素并对其执行一些操作，把一个元素取下来，如果是打印工作，把那份文件打印出来，或者扯下一包，如果那是个网络，它通过网络发送，随便啦，可以在队列上循环，有点像每个循环的a，但你得把它弄黑一点。

你要做的是如果队列的大小是10，你绕十圈，你所做的就是把前面，你看着它，然后你在队伍的后面再排队，所以如果每个人都离开队伍回到队伍后面，每个人都这样做了N次，那你做完之后，如果你想一下。

你有和你一开始一样的人，因此，您可以查看队列的内容，而不会以这种方式丢失它们，如果你想用一堆，你明白吗，你把一个拿出来，看一下放回去，如果你有一堆十样东西，你这样做十次，会发生什么。

就像你把最上面的拿下来打印十遍，你从来不看他下面的九行，所以这是一个稍微不同的问题，其实呢，如果要打印堆栈的元素而不丢失它们，你觉得你应该怎么做，只是在后面再说一遍概念，你会怎么做。

我可能得把它们存储在一个单独的向量中，我认为这是个好主意，是啊，是啊，也许保存一份副本，把它们备份到某个地方，把它们拿出来，打印出来，我不能把它们放回原处，我可以把它们放在别的地方，也许再做一叠。

把它们放在另一叠里，然后它们会在另一个地方堆积起来，然后当我打印完第一叠，我把它们从第二堆里拿出来，放回第一堆里，或者是的，差不多吧，你得把它们保存到备份或其他地方，如果你仔细想想。

就像记住事情是如何以相反的顺序出现的，你加一二三四五，他们出来了五四三二一，所以如果你把这些拿出来，把它们推到另一堆，它们是颠倒着进去的，到另一个堆栈，五个在下面，一个在上面，但如果你把它们拉出来。

他们翻回原版，当你把它们放回原版，所以你把它们反转两次，你明白我的意思吗？就像你说的，把它们放入辅助向量中，辅助堆栈，差不多吧，如果你把它们放在矢量中，然后把它们放回去，你得小心不要把顺序倒过来什么的。

反正，所以有一些可爱的循环来处理线索，最常见的是这个虽然不是空循环，但你可以做这个，如果你出于某种原因想保留里面的东西，好啦，您经常一起使用成堆的队列，他们就像最好的朋友，所以你可能会做一个提示。

然后你说，哎呦，我想颠倒立方体元素的顺序，所以你做了一堆，当队列不是空的时候，你把东西取出来，把它们推到堆栈里，所以现在队列是空的，但是这堆有一二三，上面有三个，现在，当书库空着的时候，你把它弹出来。

把它放回队列里，所以基本上把所有的东西都放回队列中，但顺序正好相反，在最后，这是个可爱的小把戏，对呀，好啦，所以让我们试着写一些代码，嗯，我想我想做这个这里叫镜子，所以给我一排绳子，然后改变队列的状态。

这样当你完成时，它就会以原始的顺序存储原始的元素，但它也以相反的顺序存储这些相同的元素，这有道理吗，这是什么，哦耶，对不起，我想我的写作有点模棱两可，前面是左边，后面是右边。

我想我们可以做这个，我们是X，我们什么都能做对，它在哪里镜子在这里，好啦，帮我做航向，Mirror和我要了一串叫做cue的字符串，我想它们碰巧是一个字母，但我想有双引号，所以我认为有弦，它返回什么无效。

因为它会修改队列，你发过来，意思是出了别的问题，权利必须是一个参考，是呀，好啦，凉快好，好啦，我该怎么做，那么现在我在做什么，如果我，如果我将队列清空到堆栈中，然后再把它放回队列中，我会把元素颠倒过来。

所以这将把我从CB ABC变成CBA，但我两个都想要，哦酷，好啦，所以我可以两样都做，我可以把它们拿出来，同时把它们堆起来，并重新添加它们，就像那样，好啦，不如就像，当队列为空时，是呀，你看穿我了，哼。

那么字符串s等于，Q dq，我以前学排队的时候，我不记得有多少，有多少这样的，或者像很多人那样写，就像我要离开我的Q不不，反正，管他呢嗯，叠起来推S，然后也把它放回队列中，q n q字符串。

这个代码有什么问题，是啊，是啊，我认为这是正确的想法，但这只有在队列最终为空的情况下才有效，但我要去掉一个，再加一个，我连一半都没赚到，但我很确定这意味着它的大小保持不变，每次我们经过。

那永远不会变得空虚，所以这可能不是正确的循环，你还有别的建议吗？哎呦，你就能知道，是啊，是啊，我想这是个好主意，所以也许像等于q点大小的东西，然后对于int i等于零，我小于尺寸，我加加或之前不加。

而像这样的事情，你们和我妻子会相处得很好，你们两个都是后座司机，从视频中删除那部分，嗯好吧，优秀的聪明人，我忘了什么，有什么问题，或者是的，是啊，是啊，所以我在这段代码的末尾是，队列恢复到原始状态。

我在堆栈中也有相同的元素，我得把这堆里的拿出来，把它们放在立方体的末端，对那又怎样，当堆栈为空时，我不必在这里使用for循环来调整大小，我可以清空堆栈，所以说，啊，那很有趣，那是什么哇，欧元符号。

未申报好，我想它堆积起来了，哼，好啦，我们做到了，我们真聪明，我们不为自己感到骄傲吗？是啊，是啊，只要九百九十九元九毛九，C加Q结构，我们不是这样说话的，对不起，我做不到，我不能做他的退出反正。

嗯，我想这是我想说的主要事情，我基本上没时间了，我唯一想说的是有一种结构叫做甲板，它是一个双端队列，让您高效地从正面和背面添加和删除，它结合了堆栈和队列的优点，它通常使用链表来实现，我们不经常用它。

但它就在那里，这三个都在我们的图书馆里，还有一个甲板点H，所以这些是堆栈和线索，我要就此打住，请检查您的班次时间，一定要去你的部门，祝你有美好的一天，别忘了，家庭作业一。

星期五见。

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P6：Lecture 06 - Sets and Maps - 加加zero - BV1By411h75g

星期五快乐，下午好，第二周结束了，今天很高兴见到大家，我们已经用四分之一完成了将近20%，那不是很疯狂吗，我只是不敢相信，就像我去了一个有学期的学校，你知道你从八月份开始，你一直到圣诞节的前一天。

你学到了一些东西，你不只是呆了十个星期，哦好吧，不管我是什么，我们今天要了解更多的收藏，尤其是，我们将学习布景、地图和你们的家庭作业，今晚六点交一份作业，今天有两个出去了，我想它神奇地出现在网站上。

十分钟前，就在那里，我不打算花很多时间谈论家庭作业，但正义的正义，你知道的，作业二有三个部分，第一部分叫做字梯，b部分称为n克，c部分称为迷宫生成器，仅供参考，如果你拿116b。

你得做这一部分和那一部分，但你不必做迷宫发生器，那是x部分，就衡量两道菜之间的差异而言，所以是的，今天就要出去了，一个星期后到期，这是一种惩罚养生法，你们这些笨蛋都报名参加了。

所以去看看这个周末的作业重点是收藏，你们刚上完第一节课，我想你们中的一些人今天下课后可能会有，但你的第一节课，家庭作业二是结对作业，如果你想，你可以和朋友一起工作，如果你和朋友一起工作，可以选择。

你得和你的朋友在同一个区，如果你和你想一起工作的人不在同一个部门，您可以交换区段，你可以去CS一九十八网站，您可以单击交换部分的链接，如果你不能交换，你可以联系我们的头像，你可以帮你解决分歧，好啦。

所以要注意这一点，如果你想和一个搭档一起工作，我会指出，如果你和一个搭档一起工作，一个非常诱人的策略是把这些分开，就像你做的A部分和杏仁B部分等等，我是说我真的不认为你应该这么做，那不是我真正想要的。

我更希望你们能一起合作，嗯，但是嘿，我不能跟着你，我还不能监视你，呃，手机技术还没到，所以我不能强迫你有一定的工作方式，但我会说，如果你不做所有这些问题，你可能没有练习过这些结构。

然后在考试中你可能准备得更少，所以我觉得你是在伤害自己，如果你不熟悉这些问题，无论如何，那是你们该考虑的，如果你真的想和一个搭档一起工作，我建议阅读这里的链接，它说配对编程，它对我们的政策有一些讨论。

你该做什么不该做什么怎么做，或者随便什么，看看那里，我敢打赌，这将回答你关于两人一组工作的大部分问题。

是啊，是啊，这就是我真正想说的，今天让我们来谈谈布景和地图之类的东西。

让我再次打开今天的幻灯片，这来自第五章，这周基本上是第五章，那么一套是什么呢，嗯，这是一个具有独特价值的收藏，无重复，集合通常是为了优化其行为而构建的，围绕着某一小套操作，这些操作是添加和删除元素。

然后搜索元素或测试成员资格，问这是在片场吗，或者不是一套能做的全部，我们在周三看到了一个想法，有时如果一个集合有更少的操作，那么也许它将能够实现它们，非常高效，这就是我们看到的堆栈和队列，嗯。

这里也会是这样，您还可以添加、删除和搜索向量或链表中的内容，但它不会像这东西那样快，希望我能在一分钟内告诉你，所以当你有一套时，你放弃的主要事情之一，你放弃索引和插入顺序的概念，所以如果你加上三个元素。

你不应该指望他们会在哪里，什么顺序，他们会在片场，事实上，我们甚至不认为集合是有顺序的，通常这就是为什么哎呀，检测到系统问题，哎呀没关系，嗯，希望我的电脑今天不会死机，所以当我画布景的时候。

我通常只是把它们画成这些无定形的斑点或圆圈，或者所有的元素都散落在里面，因为我想再次让你摆脱这种心态，像这样是第一个元素，这是第二个元素，好像我们不在乎似的，如果我们用一套，如果你这么在乎秩序。

然后用矢量什么的，所以你知道你问它，如果它包含两个，你问它吗，如果它包含单词B，它不是那么系统，问题，探长谢谢，如果你一直取消，最终他们会离开，就像童年的创伤，一样的按取消，一切都会好的，嗯所以是的。

这就是布景，真是一套，从概念上来说很好，这里有一个问题的例子，在那里你可能会使用一套，编写计算大型文本文件中唯一字数的代码，所以读读文件，找出有多少独特的单词，所以如果你看到像你好这样的词两次。

你只应该把它算作一个权利，你看五遍这个词，你应该把它算作一个词，当然啦，我在这里想说的是，一套词会很好，对吧，但我真的想开车回家，集合比向量更适合某些任务的观点，所以我想从错误的方式开始，使用向量。

好的，好的，所以我们就这么做吧，我有一个可爱的创作者项目，在网页上，如果你想，我想写一个叫做单词计数的方法，您传递一个文件名，我会告诉你现在档案里有多少独特的词，让我们用矢量。

所以我做了与集合或向量无关的部分，所以我打开这个文件，然后我有一个循环，从文件中读取单词，然后当我读每一个字的时候，我只是小写的，你知道大写Hello和小写Hello，你好，所以现在它说这样做。

让我们把单词做一个矢量，同样，这是字符串单词的错误实现向量，好了，现在我只说单词点添加单词点添加，那不太对，是吗，我在代码的这一部分缺少了什么，检查它是否已经在那里，我不应该把同一个词加两次，对呀。

好啦，那么我怎么知道它是否已经在那里了，比如矢量是否包含，所以好吧，如果文字点缀，没有包含，奇怪的神话，点细，没有罚款，是谁设计了这个愚蠢的矢量，不管是谁干的一定是个大疏忽。

忘了包括一个在向量中搜索单词的方法，嗯，没关系，我想帮我们，我写了一个方法，调用的函数包含，传递一个向量和一个字符串，它会告诉你，如果那个字符串在向量中，所以我们可以看看我是怎么写的。

一会儿我真的很擅长编程，所以说，或者我想如果它不包含对，然后把它添加到列表中，好啦，所以如果我们假设我的魔法功能起作用，那就太好了，好啦，所以现在当我们做完，它说单词的整数数等于零，但这不算对。

档案里有多少字？我知道文件中唯一单词的数量吗，向量字的大小，点大小右，好啦，然后只是需要多少独特的词，好啦，所以我会编译，所以你知道，大家这周都过得怎么样？大家都好吗？嗯。

我妻子和我最近发现我们真的很喜欢这个节目，瑞克和莫蒂，这很有趣，我不，我不知道什么阴谋什么的，所以我们一直在观察，昨晚我们看到了这一集，叫泡菜里克，就像整集一样，他是个讨厌鬼，他只是想。

你知道他被蟑螂和鸟吃掉了，他在太阳下晒太阳，就像这家伙是整集的泡菜，这是最滑稽的事情，我们有一个非常非常酷的时间看它，我真的认为这是我最喜欢的新卡通片之一，啊，它是，好啦，所以有三十七个，三万字。

花了42秒，不得不在那里消磨一点时间，谈论我有趣的个人生活，现在这似乎不是一个糟糕的运行时，对，但我不知道，是吗，我是说，也许这只是需要多长时间，也许这只是一个计算密集型的任务。

只是需要很长时间才能表演好，有什么想法吗，你觉得为什么要花这么长时间，它在干什么，太慢了，当它运行这段代码时，让我们看看我是谁在后面没有听到，是啊，是啊，你写的方法，它意味着我们迭代单词的所有元素。

所以让我们在文字的大小上和他们一起去，所以当你到达，添加，当我们到达，哎呦，你检查的单词，要花越来越长的时间，然后，然后，这就是为什么它需要一个，是啊，是啊，我想这是个好主意，嗯。

虽然我不得不说我有点生气，听起来你在暗示，这个函数我写得不是很好，你知道我不太喜欢别人的批评，所以让你说，你认为我的函数通过向量，所以让我们看看，下面是函数对向量中的每个字符串所做的操作。

如果那个元素是我要找的字符串，那么是的，我有这个词，否则，如果我走到最后，我说假权，所以这叫做线性搜索，只要在向量中寻找正确的单词，所以每次你去看，每次你从文件中读到一个字，我必须调用那个函数。

所以每一个字，我走完整个矢量，现在，你可能会说，Almarty，你的实现是愚蠢的，你应该做这个或你应该做那个什么的，但我只是说，这就是通常如何使用矢量来解决这个问题，我们花了四两秒钟才把它解对。

好吧好吧，还有一种方法，这种方法是使用集合结构。

有啊，在我们的库中有两种C++集合，一个叫做集合，一个叫做哈希集，我一会儿再谈区别，事实上，先别读这个，有一种结构叫做set，如果你，如果包括集合H，您将得到一个集合，其中添加了这些方法，移除并容纳。

所以这是三个主要的，它也有是空的大小和清晰的，你可以用小于小于，但那是标准的东西，所以你看，让我来破坏这里的美好时光。

解决这个问题的办法是，所以如果我在这里而不是弦的矢量，如果我做一组字符串，我是否导入设置库，我做得很好，所以我用一组字符串，我编译它不再喜欢这一行代码了，因为这个函数要求一个向量参数，这不是矢量。

所以如果我只是改变它，集合集合实际上有一个contains方法，所以现在我可以要求片场这么做，所以记住4秒2之前，好吧，那次花了三百毫秒，所以这样更好，哈哈哈，但我们怎么才能听到你的敲诈摩根，嗯。

我下次再告诉你泡菜里克的事，我想事情就是这样，少给你点喘息的机会，如果你想休息一下，也许你更像是一个载体，人的类型，快多了，对吧，所以我希望这个演示能说明这两者的巨大区别，在这种特殊的任务中。

现在我已经把甲板叠好了，我挑了个问题，布景会很好，但是有很多这样的问题，所以让我倒回去一会儿。

因为我说有个滑梯，我有点跳过了，我们图书馆里有两种布景，记住我以前教你的，关于如何有不止一种方法来实现相同的操作，我有个术语，你还记得吗，不是冗余，我叫它T，我听到有人说抽象数据类型，是啊，是啊。

有两个集合有相同的操作，有一个叫布景，有一个叫做哈希集，如果你是一个Java人，有一个叫做树集，一个叫做哈希集，那差不多，所以这两者的区别在于内部有不同的实现。

称为set的规则是使用称为二叉搜索树的结构构建的，我们以后会知道的，它以排序的顺序存储元素，速度很快，像字母顺序或数字顺序，或者类似的东西，另一个叫做哈希集，它是用数组构建的。

但是数组正在以一种特殊的方式使用，我们称之为哈希表，这个我以后再说，在课程中，还有，哈希集的排序有点不可预测，很难理解，但它比普通的快一点，所以我想如果你好奇。

我以前花了300多毫秒，如果我在这里说哈希集，然后运行它，稍微花一点时间，比普通的少一点，所以好吧。

所以有两套，你可能会说很好，哈希的是更好的，对呀，但我觉得这个订单问题，因为有时候你想保持秩序，有时你不会，所以你可能会牺牲一点速度来解决这个问题，或者这个，是啊，是啊，您还需要包含操作吗。

如果您正在使用，这是个好问题，在代码中。

我的意思是，如果词集不包含此单词，然后加上这个词，但实际上我没有花很多时间在滑梯上，但是集合的加法，它不允许复制，所以如果你试图添加一个重复的，它会默默地无视它，所以我可以说单词加单词，不怕损坏数据。

我想我们看不出有什么不同，真正在运行时，打电话不需要很长时间，包含在集合上，但是好吧，我确实节省了几毫秒，所以我把运行时再缩短一点，所以是的，你对那个问题完全正确，理查德，那么如何访问这种订单。

如何访问排序的，哦，我马上给你看，您可以对集合上的每个循环执行此操作，我想说在很多情况下，我们不太在乎点菜，在很多情况下，我们只是想测试会员资格，我们不想在布景上打圈，但这取决于我们在做什么。

我们看到哈希启动实现比集合实现快一点。

哈希步长比常数项快吗，或者是一些，基本上是其他的，哦耶，他的问题是关于，哦，比如这里的速度变化有什么不同，这里有一个更具体的答案，规则集的大多数方法都有log n运行时。

哈希集的大多数方法都有一个恒定的运行时，可能不太清楚，为什么会这样，这是我的一句话版本，几周后我会写张欠条给你更好的解释，当我们自己打开这些并重新实施它们时，这个集合把它的元素分成这个东西，称为二叉树。

在那里它不断地分裂，拆分，一分为二，当它搜索它的时候，有点向左，向右走，它沿着其中的一半，或另一个，所以这就像不断地把搜索空间一分为二来寻找东西，当你不断地除以或乘以2时，直到到达终点。

这就是我们所说的对数行为，日志基两个行为，哈希集里面有魔力，它有一个神奇的查找功能，你说的地方，嘿绳子，你在片场吗，实际上是一个大数组，神奇的哈希函数算法说得很好，如果我在片场。

我将是一个索引编号一八七五，所以它跳到那个索引，说你在吗，是的不是，这就是它所做的一切，所以再次哈希集，我以后会更好地解释这一点，哈希集，有神奇的算法可以把东西分类到非常特定的位置，并快速查找这些位置。

这是一个非常酷的算法，我以后会教你的，我只想让你明白这些是做什么的，当您使用它们时，如何成为这些结构的智能客户端，嗯，所以添加删除包含，这基本上就是你得到的，他们都很快，我想当我还是个学生的时候。

我学到了这个等价物，类似的事情，你知道它写在石碑上，而不是投影仪当时是1999年，所以当我听说这件事时，我就像，哎呦，什么更好的大目标，爱和你穿越，那太棒了，但就像原木底座一样，一个数字中的两个不太像。

你知道的，记住，这就像多么昂贵，这东西多慢啊，它生长得有多快，那么原木底座是什么呢？一千个中的两个，大概有十九个吧，是二的十分之一是一千二十四，所以如果你有一千种元素，它必须看起来像十个。

原木底数是多少？一百万中的两百万，千载难逢，二十分之一乘以二十分之一乘以二十，所以如果你在一个集合中有一百万个元素，让我们检查，他们中的二十个，那还不错，如果你有十亿个元素，三十万亿个元素四十。

没那么糟，log n也没那么糟，别担心，这两个都很快，好啦，所以这是我们图书馆里的两种集合，在stl中有等价的结构，C加加，我不打算教你，今天的设备也支持操作员，C++有一个很酷的特性，叫做运算符重载。

其中可以描述数据类型的运算符，如果你想，所以你不仅可以，你能问一下两个集合是否相等吗？它将告诉你如果相同的元素彼此，不管波特不在乎，你也可以做工会，使用运算符的交集和差分，你知道的，你知道工会。

你取其中一个或两个中的元素，把它们组合在一起，交集只保留它们中的元素，你设置了一个差异，你把它和b区分开来，它去掉了一个，B中的任何东西，我什么都不知道，因此，使用这些运算符设置标准集合操作工作。

还有这些的方法版本，我想有一个点联合方法和一个点交集方法等等，是啊，这些联合和十字路口运营商，只为斯坦福大学，当地图书馆也将，我想这些是斯坦福，只是，有一些方法可以用stl进行这种操作。

但我觉得语法有点不同，坦白说，我不记得到底是什么操作员，STL设置支持，我想他们支持其中的一些，但我不记得到底是哪一个，如果您想知道文档链接在网页上，你可以查一下，就像有时我们用正等，你可以有一套。

你可以说加号等于一个元素或者加号等于另一个元素，它就会融入那个元素，或者合并该集合的所有元素，所以如果我写了加等于，就像叫圆点一样，基本上加，是呀，其中一个是，另一个是一个普通的斯托尔。

他们一定要一样吗，是呀，问得好，你能把一个哈希集添加到一个集合中吗，我觉得你可以，我的意思是，我应该知道这一点，因为我写了一半的蠢话，但你知道你忘了。

如果你老了，你的大脑开始变成土豆泥，所以嗯，我是说，你看，如果我有一套字符串叫嗨，然后我做单词点，全部加高，是有一个人拿走了它，我觉得很管用，否，它不喜欢那样，嗯，是啊，是啊，我觉得没用，我猜。

我想写这个的傻瓜没有让它们一起工作，是啊，是啊，你知道的，你会发现一件事与语言有点不同，像java之类的，Java对不同类型的集合有很好的互操作，我觉得C++有点像，每个人的城堡周围都有自己的护城河。

他们在一起玩得不太好，但是嗯，你知道的，有些事情你可以做，你可以为另一组的每个循环做。

添加到第一组，差不多吧，你问的是订货的问题，所以主要的订购地点出现在，如果打印集合，它会按一定的顺序打印出来，就像看到外面，或者它可以对集合上的每个循环做一个，那是主要的方法，如果你需要移动一组。

不能使用大小为零的ini，使用括号的地方，我在布景上不起作用，无索引，但是如果你对每个循环做一个，它会为你吐出每一个元素，就他们出来的顺序而言，如果是普通的，它们是按字母或数字顺序出现的。

如果它们只是杂乱无章地排列在一起，你不应该指望任何特定的点菜，事实上，在程序的两个不同运行之间可能是不同的，所以这取决于内存地址和其他东西，所以说，所以这个实际上应该在它周围有一个X，哦，那里。

是那在那里不起作用，好啦，好啦，嗯，这里有个练习，我想跳过，如果你想做，去吧，有一个，这是我们的一步一步网站上的这个，基本上，你可以使用集合来跟踪你以前见过的数字，你想找一个快乐的数字，把数字加起来。

我要跳过它，但因为我没有足够的时间，所以要一步一步地去做，如果你想或在可爱的创作者上做，如果你想这样等着，还有什么，我在这里做结构，那么让我们来谈谈结构，我不打算在这上面花太多时间。

但是c plus可以让你用java创建新的类型，你可以做一个新的类，大多数语言，你可以做一个新的类，或者一个新的对象，或者类似的东西，C++有类，他们的语法有点恶心，所以我还不想谈论他们。

但你可以做很多同样的事情，用C++类，你可以用Java类或Python类或其他什么来做，嗯，C++也有一个类似的东西，叫做结构或结构，结构基本上是一个类，但它通常只用于存储几个变量。

它是一个只存储数据的类，通常它可以做得更多，但它大多是这样使用的，因此，如果您创建一个名为date的结构，你在里面放了一个月零一天，这是新数据类型的模板，您创建的每个日期对象中都存储了一个月和一天。

这是一个没有构造函数和方法的类，但只有两个实例变量或两个字段，所以你今天可以说日期了，你可以把日期定在5月13日7号，也可以用括号创建，括号中的值将用于初始化这两个，这两个领域，所以我的意思是。

为什么我给你看这个，这和我们现在讨论的不太吻合，但我觉得，有趣的是，当你试图将结构放入集合中时，像一套，啊，你有一个问题，去吧，是啊，是啊，我们的压力，喜欢数据，Indexable看起来像索引索引，嗯。

就像所有的月份都是括号，零什么的，是啊，是啊，你知道不，它不支持索引，此语法只是特殊的初始值设定项语法，如果将值放在当前大括号中，十一版中的C加加，二千零一一版，他们添加了所谓的通用初始值设定项语法。

这意味着您可以通过放置花括号来初始化几乎任何内容，然后按顺序写出构成那个东西数据的值，按它们之间用逗号声明的顺序，这就是为什么向量，让你做那个结构，任何事情，几乎任何事情，现在可以这样初始化。

这对语言来说是一个很好的进步，所以嗯，我再给你看这个的原因，我觉得就像，我刚才在课堂上突然转向。

但如果你想确定一个日期，就像，哎呦，这些是我日历上的重要日期什么的，所以想象一下我有一堂课，在这里，我有一个月，我有一天，我是说你可以在一年里拥有任何你能拥有的东西，你可以想写多少字段就写多少字段。

但现在在这里，如果我做了，你知道圣诞节12点25分，然后我说约会B天，我的生日是九十九，然后你知道如果你只做那些在它们下划线的日期对象，因为我还没用过，但如果我说我想做一组日期，日历。

然后我做了日历点添加圣诞节和日历点添加B天，我会得到一个奇怪的错误，它说废话废话废话废话废话，操作员不匹配，小于操作数类型在状态上为con state，这是C++的一个很好的例子，编译器错误很难理解。

有时人类对这里发生的事情的解释，那是我以前告诉过你的一套吗，一个集合喜欢把它的元素按顺序排序，哈希集将它们混乱成不可预测的顺序，所以当你说你想建立一个基地，你想把这两个，剧组在想办法，就像。

我如何对它们进行排序，你可能会说很好，很明显，九月在圣诞节之前，或者，但是C+不明白这一点，然而，为了使数据类型能够被放入集合中。

你必须写一个叫做运算符的东西，小于功能，这需要一个日期和一个日期，并告诉你第一个是否比第二个少，这允许集合理解如何比较它们的顺序，这是运算符重载的一个例子，我在做什么，我不知道语法是否真的很神秘。

但我是说我想定义新的运算符，小于运算符的使用，它将返回一个恶霸，因为较少名称总是一个逻辑运算符，以及清单两边的论点，这将是一个日期和一个日期，虽然我把它们写下来作为迄今为止的参考。

所以他们不会复制和常量引用，因为我不会改变他们，是呀，你喜欢，或者你可以的东西，有一个允许您过载的操作员列表，我不记得上面到底写了什么，但这是一个可怕的大列表，你可以覆盖，就像逗号的作用，而且很有趣。

你可以覆盖，加法做减法，就像你的朋友偷偷溜走，他们不像，你定义了你，然后他们就像一个，再加上一个一直给我零，什么是，这是如此向上，我能让它不回报10亿吗，我不知道发生了什么事。

我认为您必须遵循运算符的语法头，我不知道这是否能让你，我是说C加+，让你做一些可怕的可怕的事情。

你知道的，但你不应该总是这么做，只是想让你看看，我看到又有一两只手举起来了，但是很快，如果我说布尔运算符，日期参考日期一，常量日期参考日期二，你怎么知道第一天比第二天少。

日期一个月是否严格少于日期二的月份，或者如果月份相等，第一天，一天比一天少，星期二，在这些条件下，第一天会比第二天少，所以这是一个小于运算符，现在呢，我希望我的电视机能让我储存这些东西，日期，没有编译。

啊，因为现在它不知道怎么打印日期，因为它有不少于一个日期的运算符，所以如果你想这么做，那是，哦天啊，我不想谈这个，小于它需要一个恒定的引用，D和它，哦等等，你得把输出流传出去，哦天啊，外面太可怕了。

丁点月，返回，好啦，哎呦，从来没有没有，我们改天再谈，但如果你想做一些可打印的东西，你必须重写鳄鱼操作员对这种类型的操作，别介意，所以我运行这个，上面写着日期是圣诞节生日和圣诞节，耶耶，所以这一切。

反正，我本来不想教你的，我想我提到这一点的原因，哎呀哎呀，它去哪儿了？我知道我关上了，对不起，我之所以给你看是因为，一旦你开始使用集合，你想在一套里开始你自己的东西，然后你会得到这些奇怪的错误。

我想让你明白为什么，发生了什么事？以及如何修复它，是啊，是啊，弦呢，它存储字符串，弦很好，你不必为了琴弦做这些事，它按ASCII顺序对它们进行排序，基本上是按字母顺序排列的，但它是大小写敏感的。

另一个问题，是的，是的，Tshirt，要做到这一点，重载的运算符必须放入相同的文件，哎呦，他们必须住在同一个文件里吗不，他们遵循同样的规则，和其他文件一样，在其中可以包括其他文件。

然后他们会看到操作员什么的，然而，我还没有太多谈论多个文件程序，但是是的，你就会这么做，所以好像没有这种事，作为分配给这些的默认函数排序，是啊，是啊，不幸的是，它不知道该怎么办，除非你说出来。

你希望它只看几个月，再看看日子，但坦率地说，我认为这可能会导致更多的错误，而不是解决，因为你会说，啊，它的顺序错了，我不知道喜欢它，没有，它不想做出假设，它让你告诉它该怎么做，坦率地说。

用C++编写类的语法很糟糕，因为你必须做这一切，只是为了去它工作的地方买基本的东西，你得做这种蠢事，这是最早的语言之一，他们真的搞砸了，所以像Java和Python这样的人，他们学会了。

他们让它变得更好，所以这是一个警示性的故事，如何不完全掌握一门语言，对呀，是啊，是啊，对喜欢的人最好的做法是什么，我想包装就像，还有那些运算符，哦哦耶，我主要想回答你的问题，你的要求就像。

如果我要写一个新的结构，比如我怎么把它打包分发之类的，就像你有一个日期点H和一个日期点CPP，你会有很多这样的东西，我的文件包括，我很快就会教你更多关于多文件程序的知识，但是但是是的。

这只是一个快速黑客攻击的例子，只是为了以后稍微玩一下语法，是啊，是啊，为什么输出运算符，为什么它会返回屏幕，哦，为什么这返回o流，我有点不想谈这件事，基本上，这只是为了让我可以改变这些小于运算符。

每当我出去不到那个时候，表达式返回，这样我就可以用下一节课了，把它们锁在一起的教训，这是语法的一个怪癖，允许多个，天衣无缝的东西越来越少。

好啦，我想继续前进，但当与集合一起使用时，这是结构的一个小怪癖。

所以等等，在哪里，I，这里，好啦，所以我真的不会在这上面花任何时间，不过，在我们图书馆里还有一本叫词典的藏书，词典和词典基本上是一回事，但它没有定义，它只是一种词汇或语言中的一组法律词汇。

它基本上是一个词典是一组字符串，所以当你声明一个词典时，你不说词典括号字符串，你只是说词典，假定它存储字符串，你会发现它有几乎与集合完全相同的方法，添加删除包含两个字符串，一个区别是它有一些方便的方法。

像阅读文件之类的，它也有一些与单词前缀有关的方法，就像，你可以说，词典里有哪个词是以这些字母开头的吗，它会告诉你为什么这口井，它的内部有一个不同的实现，这对称为前缀树的查询很有用，我以后会教你的。

我现在才提，因为我们今天要收集，稍后我们将把这个集合用于一个名为boggle的作业，我们在黑板上搜索部分单词，这将是有用的，我们现在不需要，但它基本上是一组弦，我们稍后再讨论，是啊，是啊。

它也是按字母顺序排列的，是啊，是啊，如果你把它打印出来，它会按排序的顺序打印单词，好啦，好啦，我要继续前进，我想去拿地图，地图很重要，地图也在第五章，我猜你们大多数人都见过哈希图，或者以前的地图。

其他语文，它们有时被称为字典，就像Python，所以与我们目前看到的所有其他收藏不同，一张地图不仅仅是你，不要只是给地图增加一个值，你得在地图上加一对东西，添加的对称为键和值。

你把那些配对在一起的加到地图上，以后如果你只有钥匙，你可以让地图去找关联的值，所以地图的一个经典例子是字典或电话簿，你储存成对，比如马蒂的电话号码是这个，辛塔的电话号码是。

所以名字和电话号码是你存储的一对值吗，然后像你一样，在你构建数据结构之后，你只有名字嘿，马蒂的电话号码是多少？我要马蒂的电话号码，它去查找与马蒂相关的值，它把它还给你，所以这是一个查找结构。

用另一半找到一对的一半，这是单向查找，如果你想知道那个人的名字，你有没有接到过一个随机号码打来的电话，你不知道是谁，你很想知道那个人的名字，地图不是朝那个方向走的。

如果你把它和左边的名字和右边的数字一起存储，然后它不允许你从一个电话号码到一个名字，它只允许你从一个名字到一个电话号码，以此类推，你们可能以前见过这些，很多现实世界的例子。

我认为地图是最有用的数据结构之一，因此，以下是您可以使用地图进行的一些核心操作，您可以将键值对放入，这就像添加我们的库，还允许您使用方括号语法，这是很酷的埃里克逗号。

这个数字和括号Eric等于那个电话号码是一样的，这是一样的，等价语法，所以其实挺酷的，我想你可以想到地图的一种方法是，它有点像一个数组，但是索引不一定是从零开始的INS，索引可以是字符串。

它们可能是布尔值，他们可能是双打，他们可能是，我也不知道，有些人喜欢这样想，像这样，有些人不会，但你把它存储在Eric的索引中，你把价值存储回来，因此，稍后您可以说出存储在索引Eric中的内容。

它会告诉你他的电话，如果你试图把一个副本，它将替换以前的值，您可以得到密钥的值，你基本上是在说，请帮我找到与之关联的值，P，您也可以使用方括号语法，把亚娜的电话号码给我，这是我妻子的名字，你会注意到的。

我不知道你是否能看到这么远，但我的电话号码和我妻子安娜一样，在，有一把重复的钥匙是不行的，如果您尝试添加另一个名为马蒂的条目，它将取代以前的条目，所以你可以把，你可以得到，你可以移除，所以是的。

移除并向上看，这是你在地图上需要的三个操作，是啊，是啊，所以从地图上看，所有键必须具有相同的类型值，同类型，是啊，是啊，所有的键都是同一类型的，所有的值都是相同的类型。

但是键可以是与您可以映射的值不同的类型，从字符串到整数，或从双打到牵挂，或者你想要的任何东西，是啊，是啊，所以是的，我是说再来一次，就像我说的，你储存双对，然后你有一半的一对，你想让另一半再次出局。

我想有些人有点麻烦，你们大概明白了，但有些人有点不理解这里的想法，就像你知道如果我有整个对在这里，我为什么不把他们都叫来，我为什么要查这个东西，我只是过得很好，我怎么把它忘得很好。

通常你是从文件里读出来的，也许程序坐在那里，提示时间长，你知道你有数据，只有你，你不知道数据在哪，或者类似的东西，这是为了一个长期的过程，我也没必要这么说，但它暗示了这个结构应该以这样的方式建造。

快速完成这些操作，它应该能够快速地放置、移除和获取东西，它确实如此--猜猜我们图书馆里有什么，有一门叫做数学的课，它按排序的顺序存储事物，有一种叫做哈希图的东西，以不可预测的顺序储存东西，听起来很耳熟。

所以就像布景一样，同样的两种类型，这是因为从字面上看，集合是作为一个地图实现的，从值到真布尔值，那是的，这里是真的，所以他们基本上是一样的，从某种意义上说在里面，同样的逻辑也适用于。

如果您关心数据的排序和排序，您使用常规地图，如果你不在乎，你想要更快一点，我们会使用哈希图，那些关于存储日期或其他什么的东西也适用于，如果你想储存日期，也是地图上的钥匙，是啊，是啊。

地图中的键可以是结构类型吗，然后你有，是啊，是啊，键可以是结构，但他们必须有一个排序顺序，他们必须做一个小手术，是什么样的，如何覆盖，啊，如何编写哈希码，我以后教你，但在我们的库中。

你实际上写了一个函数，只是一个叫做哈希码的常规函数，它将您的类型作为参数，并在最后返回，为了指示放置索引，它将东西放在数组中，基本上比这更重要一点，但如果你好奇，这是最基本的想法，在库中打开哈希代码H。

斯坦福图书馆，我是个专业术语，我们对每个循环的预防，只有两个人吗，就其本身而言，这种不可预测的秩序，既是为了一套，也是为了一张地图，如果你对地图上的每个循环做一个，你不知道什么顺序，双鞋会给你的。

但你会得到所有的，为什么这样你就可以在上面循环了，你只要不关心，你先看哪一个，你第二个看到的是哪一个，等等，如果你很在意，你可以用一个普通的祝福你，以下是我已经向你们展示的方法，最重要的是，但也包含了。

也去掉了，有一些标准的东西，喜欢是空的，你所习惯的这些方法，到现在为止，这里的运行时完全类似于正则集和哈希集，我觉得你比较了两张桌子，你会发现他们几乎是一样的，为哈希映射记录一个的规则映射，稍微快一点。

嗯，如果你想在地图上循环，这就是你要问的，用里面的一些数据做一张地图，然后我们可以在上面循环，你实际上在循环的是钥匙，对的左半部分，如果你想要右半的值，你只需查找每个键的值，当你读它的时候。

所以这就是打印配对的方法，所以我想这应该是伯克利的学生，学分零分，然后就会说马蒂的平均绩点是2。7，然后会说维多利亚的平均绩点是三分，它会按那个顺序，因为它是一个普通的Mac，所以它是按字符串排序的。

键的字母顺序，对呀，所以是的，你可以用地图做的另一件事是你可以用它们来记录或计数东西，这是一个有用的例子，嗯，基本上，如果你如果你有一个选举，但你有选举，你有选票，投票机就是这样储存选票的。

就像一根大绳子，如果他们键入R，那是投共和党的票，如果他们投票类型，要么，因为他们是醒着投票的，我不禁注意到这里有三个人投了独立票，但是嗯哦好吧，呃，所以呃，如果你想数一下每个候选人得到了多少票。

我想你可以说R候选人是零，D候选人一个，但你基本上是在绘制某种地图，从字符串到整数，在一个矢量或什么你可以这样做，但我认为地图的想法是，你只要说嘿，用r键存储16，用d键存储14个。

你实际上可以随着时间的推移增加这些计数，就像你看到一艘船，你可以去找那对，把它的价值增加一个，随着时间的推移，这些计数逐渐积累，所以这个想法我想和，我们要回去数单词，就像我们有一本大书。

而不是只告诉我这本书里有多少词，我想知道一个给定的词，这个词在书中出现了多少次，所以你可以问我，就像这个词，我会说，哎呦，单词the在moby中出现了500次，迪克，不管你明白什么。

那么你是怎么做到的呢，地图如何解决这个问题，比如地图的数据类型是什么，我该怎么处理它，深蓝色衬衫，是啊，是啊，是啊，是啊，所以嗯键的类型是字符串，肚子型在，然后所有的弦只是所有的UV字。

它已经在酷中编辑过了，好啦，他说，这是一个从字符串到整数的映射，弦是字。

INT是我以前见过这个词多少次的计数，所以是的，听起来不错，我认为这是个好主意，嗯，让我们去另一个文件叫地图，CPP，我基本上已经准备好了，除了我没有地图部分，所以我在读这些话，很像那个代码。

我们一秒钟前和布景在一起，所以你让我做一张从字符串到整数的地图，我会叫它计数器什么的，这是一张柜台地图，文字什么的，所以你在这里说，我刚读了一个词，现在我得把它放在地图上，所以我认为这个想法就像，如果。

如果你以前没有想过这种问题，如果地图是空的，我看到高这个词，那么我需要做的是，我需要做地图商店，你知道高和一个权利有关，你懂的，现在如果我读了下一个单词，下一个单词是好的，然后我需要映射到存储。

你知道高的数到一好的数到一，你知道我需要储存这些对，对呀，但如果我再看到一个字，就像我看到了另一次的高，然后不是地图上的第三对，我想和两个人一起储存，你明白吗，所以积累计数器，如果有的话。

做一个新的计数器，如果没有的话，所以有一个叫做包含键的方法，哦，我没有吗，我没有导入地图，h包括地图h，那很好，所以如果我包含，如果我不包含这个单词的键，我以前从没见过这个词，所以这更像是这里的情况。

对呀，所以我应该做的是，我应该说他反击，我想给你换一双新的，就是这个数到一的词，好啦，但如果我以前见过这个词，2。我想知道这个词的词义，计数等于，然后我想做柜台，把这个数加上那个数，去找老伯爵。

再放一个进去，现在我明白你的问题了，我马上带你去，所以现在一旦我看完文件，我想问用户一句话，他们告诉我一个词，我查一下这个词出现的次数，所以要查一个词的计数，不是零，是计数器点，把那个词说对。

所以这很简单，我们连你通常做的一个例子，有点像这样，在一零六一个所以，我开得有点快，但如果我跑了，呃，哎呦，对主的未定义引用，哎呦，它是，我想我叫它主地图，因为如果你有两条主线，它搞混了，所以好吧。

主要，阅读圣经文本，所以很快就结束了，所以我花了一两秒钟在哪里搜索，我不知道那是否正确，但看起来它在四分之一的地方工作得很有趣，我写了这个程序，我以为我在读圣经，但我实际上是在看书，白鲸。

我像上帝和魔鬼一样打字，就像发生了两次，我就像，我以为上帝在里面被提到了不止几次，这很奇怪，我不知道，也许这是某种新潮人版本的圣经，在那里他们叫他大G什么的，我不知道，但是，所以这基本上是有效的。

我想指出的是，有一个小，你可能已经举手了，您可以对这段代码做一个小的更改，嗯，关于我们的地图结构的一个很酷的事情是，如果你试着去买一对，这个词没有一对，它将返回一些默认的零，一种价值。

所以你实际上可以删除所有的东西，一切都突出显示，你可以删除，你只要说去拿柜台，如果没有的话，会给你零分，用零加一把它放进去，所以我可以这么做，另一件事是，你知道的，而不是哎呀，它在哪里，而不是说点得到。

4。你可以用括号里的单词代替原词，你可以说括号词等于计数加，所以你可以，这样比较干净，对呀，所以实际上，我可以，而不是那样，我可以剪这个贴那个，所以现在我只剩下一行了，所以实际上我可以写。

所以整个循环就是这样，这实际上是有效的，如果没有柜台的话，它会增加，它会增加一个，现在呢，这是我们图书馆的一点特殊之处，所以这个更长的版本可以，但你知道简短的版本很酷，所以是的，有关此示例的问题。

你以前可能见过这样的，我只是想教你怎么用我们的图书馆，是啊，是啊，您更改值，更改默认值，我不认为你能，那是个好主意，也许有一天我们应该把它添加到我们的图书馆，但就目前而言，默认值是该类型的零等价物。

如果是绳子，它将是一个空字符串，如果是替身，会是零点零，差不多吧，我想和你再做一个例子，我想我没有足够的时间，但也许我们可以用一个零六个X来解决这个问题，嗯。

我想谈谈字谜，所以字谜，你知道的，你把一个词重新排列对了，所以让我跳到这个幻灯片上，所以说，在这里想象一下，你知道的，我有一个装满单词的文件，词汇词典，我想能输入一个词，然后打印出所有的字谜。

那么如何做好，我可以在我的档案里读到满满的文字，然后不知何故我需要找出哪些字母是相同的，对呀，嗯，我给你个提示，你可以把一个单词的字母，你可以按字母顺序排序，你注意到了什么，如果你对两个单词进行排序。

它们的排序结果相同，那两个字是字谜，对呀，好吧，让我们假装我很好，我给你写了一个排序字母的函数，并返回该字符串的排序版本，所以如果你有那个很棒的工具，我怎么能猜出一个词的字谜呢？这将涉及一张地图。

地图会是什么，故事，是啊，是啊，我想你的想法非常正确，像地图，地图是用来勾搭，我有这个，我想要那个权利，我有这个，我想要这些权利，所以地图可能应该有字符串作为键，其中一组字谜的值。

现在你给了我几个重要的调整，你说过，别让他成为关键，让这家伙的排序版本成为关键，因为所有这些人都有相同的钥匙，它们都映射到那组单词作为值。

我想这是个好主意，如果我去我的字谜文件在这里，我在阅读文字，我想用字符串做一个地图，就像这些排序的单词，让我们说，其他字符串集，是那根弦的字谜，你明白吗，所以现在在这里，如果你读到一个字。

我可以做字符串排序，等于，把那个词的字母排序，我想我需要做一个修剪词，有一个饰边可以把空白的地方去掉，不过，好吧，所以现在我得到了排序的版本，比如，你知道的，你好变成了e h l l o或类似的东西。

对吧，我想把它放进这张地图里，基本上我想去排序的字谜，那是一组弦，我想把这个词加到那一套里，在这里输入一个单词，您要求用户键入一个单词，我会得到那个词的排序形式，然后我会抬起头来，编译，哦等等。

我不知道，这不是主要的，坚持住，这就是所谓的主要黑人地图，所以我必须关掉主文件和另一个文件，我知道该走了，它有一堆斜线，R在上面，不管你有什么想法，它把那个词的所有字谜都存储在一个集合中。

这是集合映射的一个例子，我马上就得走了，但我会回答几个问题，是啊，是啊，你在哪里，为什么我使用地图而不是哈希地图，那是个好主意，我想哈希图实际上会更好，因为我不在乎命令，我可能关心字谜本身打印的顺序。

所以也许这应该是一个集合而不是哈希集，但是这个整体映射作为哈希映射更好，我同意你的观点，这也是你的问题，好啦，嗯，我没时间了，祝你周末愉快，我们节目上见。

星期一。

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P7：Lecture 07 - Recursion - 加加zero - BV1By411h75g

下午好，星期一快乐，大家都做得很好吗？我看到了很多，但那正是我要的心情，我真的想把它从你身上拿出来，我想，我想改变这种态度，我要你走进来，我要你离开这里，去你的男人，我希望你在激情中充满激情。

因为你缺乏激情，嗯反正，所以呃，是啊，是啊，本周我们将讨论一个叫做递归的新主题，那将是整个星期令人兴奋的事，是啊，是啊，呃，只是出于好奇，有谁用递归编程过，你们很多人很酷，好啦，很好，它是，我不知道。

我不指望知道，我要从头开始，所以对你们中的一些人来说，这可能是一个回顾，但我们还是要用一种Etsy的方式来做这件事，所以让我们看看还发生了什么，你的作业2已经贴出来了，这周五到期，注意那个。

这周晚些时候你要上一节课，所有我们部门领导正在做的日常工作，给你的作业打分，上周五的意见书，或者你还在努力什么的，但通常我们的目标是把作业拿回来，在你交下次作业之前，这样你就可以得到你的反馈之类的东西。

我们尽力在最后期限前完成，虽然很难，有时我们会在最后期限前溜走，我们也需要迟到的日子，但这将是我们的目标，在接下来的任务中努力恢复你的成绩，也是。

所以好吧，让我开始讨论这个新话题，幻灯片在网页上，这本书的相关章节是第七章和第八章，我们从第七章开始，我会说，即使你们是一个零，六个前学生，你有你的巨大大脑，对你们中的一些人来说。

这可能是一个很难的话题，那也没关系，我只想承认当我还是个小男孩的时候，我在大学里学习计算机科学，我以为CS不太难，然后当我们谈到递归时，我觉得递归有点棘手，所以我只想让你们知道这个话题可能很有挑战性。

我想说很多人，只是他们需要一段时间才能真正明白，一旦他们得到了，他们更快地找到了问题的解决方案，但有时需要一段时间才能到达那个地方，所以我的意思是，你知道的，买家当心，你已经被警告过了，嗯，不过没关系。

你知道我们要练习很多，我们要谈谈这个话题，很多，递归，会参与到，我们在这节课剩下的时间里所做的几乎所有的事情，所以到年底，你知道的，到圣诞节的时候，到假期，希望您会对递归感到非常棒，我们走着瞧。

但又一次，就像我说的，如果现在还不清楚发生了什么，没关系，事实上，所有这些都是一个很大的借口，如果我的演讲很烂，那就不要自责，如果你听完这堂课还不明白，好啦，所以在这里，我们去等待，为什么那张幻灯片。

我们做到了，那不应该是幻灯片一，少了一张幻灯片，那就像，什么是递归，就像，这是你的箱子，是呀，好啦，嗯，呃很好，我不知道发生了什么事，我想我可能删除了本地副本上的幻灯片什么的，所以好吧，什么是递归伟大。

我等一下，我没想到会这样，呃好吧这里，这是我在做腹腔幻灯片，那里，当然啦，我可以回到PowerPoint程序，点击新幻灯片按钮，但是当你用计算过程本身来描述一个计算过程时，没有递归。

所以你知道描述一个算法或过程本身，我这么说是什么意思有很多例子，但你知道你可以说，作为一个现实世界的例子，嗯，你怎样查字典来理解一个词的意思？好吧，你，你翻到字典里有这个词的那一页，你读了定义。

当你读到定义时，可能有一些定义中的单词你不明白它们的意思，所以你去查查那些词，但是等等，什么是查找一个词，好吧，你去字典里的那一页，定义这个词的地方，所以如果你明白我想说什么。

我刚才描述了如何在字典里查一个词，但在算法的描述中，我说你应该去查字典，所以我用它来描述这个过程，所以这是一个比计算更大的想法，但我们用它来计算，事实上，当您想谈论一个编程构造时，什么是递归编程。

我会说这将是，所以有些学生在不知道递归是什么的情况下发明了递归，他们可能会出于正确的原因，或者因为错误的原因，他们这么做，因为他们没有正确地使用循环，他们得到一个函数的底部，他们说好，我想再做一次。

所以他们调用相同的函数再次回到顶部，所以它会自己运行，你知道的，他们开始做这种事情，他们真的应该有一个时间循环什么的，你知道我的意思，所以这有点糟糕，递归只是将自调用用作循环。

但是更好的递归是识别一个本质上是这样的过程，与这种风格配合得很好的这种风格，所以我想说递归是有效的，是我所说的自我相似，好啦，所以一个自相似的问题是为了解决这个问题，如果您能解决相同问题的修改版本。

这将是有帮助的，所以我认为每个人首先给出的一个不好的例子，他们说的是n的阶乘阶乘吗，你知道我们知道这个数学定义，它是从1到n的所有整数的乘积，所以我的意思是，如果你要写一个阶乘函数。

您可能会编写一个从1、2、3到n的for循环，它乘积成一个变量，你正在积累，或者类似的东西对吧，所以你可能会说，你知道的，事实上，在N你说你知道，对于int i等于一或二，int结果等于一。

任何i小于或等于n，I加加结果时间等于I，然后你说返回结果是对的，差不多吧，是啊，是啊，好啦，所以这是阶乘函数的正常版本，您可以称之为阶乘函数的迭代版本，所以阶乘的递归思想通常是，我是说。

任何算法的递归版本都经常从等式中删除循环，递归是一种计算机制，允许重复而不循环的，挺有意思的，那么如何编写阶乘的解决方案，那里面没有循环，嗯，如果你想想阶乘的数学定义，你可能会在教科书上看到。

很多时候当他们把这些东西写出来的时候，他们说得好，等于空白，如果n等于某物，但它等于，你知道吗，还有一件事，如果n等于其他值，所以你描述了这些案例，你知道他们有侧身。

又高又卷的大括号上写着这个或这个或这个或这个，这有点像什么是阶乘的案例分析，那么阶乘的不同部分是什么，嗯，做阶乘的最简单的事情是什么，如果向量，如果是一个，那么那个的阶乘是多少，实际上如果n等于零或一。

那也是对的，零的阶乘也是1，但是不是0或1的东西的阶乘是什么，我是说，我不知道，我不想写一次，两次，点点，点时间，我不想用那种方式写出来，通常我们用自我相似的方式来描述这些事情。

如果我要求其他东西的阶乘，这怎么能帮我找到n的阶乘呢，我认为递归思考的方法是说，好啦，我不能写它等于n的阶乘，因为太圆了，向右n箭头的阶乘，n的阶乘，但那也太，太圆了，但如果我被允许说任何其他阶乘。

如果那是合法的，那么这怎么能帮助我为这个东西写出一个坚实的定义呢，在这个定义中我还可以使用什么阶乘，n减去一的阶乘，那什么时候N对，如果n大于一，所以如果你被允许这么做。

然后您可以编写具有相同结构的代码，所以这个阶乘的递归版本是，如果n等于零，我想和我们写的完全吻合，我可以说或者n等于一，然后返回一个最简单的版本，如果大于一，我们返回n减去1乘以n的阶乘。

这是阶乘函数的递归版本，它自称，它自称，所以如果我要求，五的阶乘是多少，让我们做四个，然后它就不会进入，如果因为它不是零或一，所以它的作用是说，返回三乘四右的阶乘，好吧好吧，三的阶乘是什么。

照上面说的做，返回二乘三右的阶乘，二的矢量，照上面说的做，返回了1乘以2的阶乘，1的阶乘就是返回1右，那么一个人在哪里回到它，回到这里，所以这意味着返回1乘以2，是啊，是啊，所以一乘以二回到这里。

所以一乘二就是二，所以这个是2乘以3，回到这里，二乘三，六六乘四回到这里，这是从整个函数中发出的，所以发回给呼叫者的结果是24 6乘以4，我想这是4的阶乘，这就是递归的基本思想，这段代码可以改进一点。

只是在逻辑上，如果，埃尔什么的，有一小段代码是不必要的，你知道我指的是什么吗？买一送一，如果去掉n等于1，它仍然有效，原因是如果你回到这里，实际上，让我撤销我在这里所做的简化，如果我删除这个。

然后这段代码在底部发生变化，哦对不起，试图把所有东西都放在屏幕上，所以你可以看到，所以在这里，上面写着还一个，而不是一个简单的阶乘，如果它再掉进另一个右边，所以我会说0乘以1的返回事实，事实上零是一。

所以1乘以1，它只是再打一个电话，但它返回的是同样的东西，所以你可能会说，但我更喜欢另一个，因为它没有那么多电话什么的，但我的意思是花时间来测试它，如果在一个或每次都很慢，也是。

所以我实际上认为更干净的代码版本，在这里用更少的如果和其他的和矿石是一个更好的版本，所以这是一个递归，阶乘函数的递归版本，到目前为止没有幻灯片我做得怎么样，我不知道我的视线去了哪里。

我一定有某种猫或狗可能跳到这里的删除键，但到目前为止我们做得怎么样，是啊，是啊，如果你真的结束了这节课，啊，呃，这里就像如果在少于两个返回n一个，两个阶乘，啊，少于两个，是啊，是啊，你可以这么做。

那很好，当然好的，祝福你，你可以做，从技术上讲，你可以做小于或等于两个返回n，我想是因为两次回归，哎呦，是呀，是呀，是呀，对不起，我不是故意的，你知道，做零的比例，标签计数为零，零生命很重要，啊，问号。

冒号，我可以，是啊，是啊，我可以说把这个问号返回一个冒号，是啊，是啊，是啊，是啊，当然嗯，我看过大部分是用El写的，我想当我们学习递归的时候，这是一个很好的模板，他们有无限的健康。

这是做这件事的一种方法，我想在一分钟后更多地讨论这个代码结构，我只是想举一个简单的例子，在我们继续之前，是啊，是啊，是啊，是啊，有什么问题吗，就像当所有的回报堆积起来，就像一个很大的阶乘。

就像忽视一个大数字的问题，它真的很大，在著名的空间里自称太多了，对呀，所以这是一种，零六斧头，零六斧头，算是个问题，就像这样，你会不会有太多的内存堆积在调用堆栈上，如果我有很多电话什么的。

你还提到了另一个问题，将所有这些相乘在一起，会很快溢出它可以存储的范围，我想这也是个问题，这两件事都是需要考虑的重要事情，我要说的是在某种程度上，我想把对这些概念的讨论从一些c+中分离出来。

这些概念的实施细节，例如，是呀，如果我在某个时候做了一大堆递归调用，我调用堆栈内存用完了，我的程序最终会因堆栈溢出错误而崩溃，是的，这是一个for循环解决方案不会发生的问题，所以这是个问题。

整数溢出也是一个问题，我会说还有其他编程语言内置了优化，将避免那种不会使程序崩溃的问题，如果您有很多递归调用，他们会处理得更优雅，C++不是这样的语言，但你知道如果我想教你这个，我们会有这个问题。

希望我不会给你做任何练习，会遇到这样的限制，我不会的，我是说，我不想在这种情况下使用递归，是的，还有为什么这比迭代更好，啊，这是个好问题，谢谢你，这个问题有点像，我为什么要关心这些废话。

这看起来比for循环更难，很棒，如果我拿走我的for循环，马鲁姆，我知道你这么问是有原因的，有时候会有学生问我，潜在的原因是，我不想学新东西，你知道循环是很好的，我不想用不同的方式思考事情。

我知道你们都是六个X型的人之一，所以你喜欢学习新东西，所以更多的是，为什么我要选择解决问题的最好方法，所以这似乎是解决这个问题的不太好的方法，那么我为什么要选择这个呢，我想这是更多的动机。

或者至少我希望，我希望这就是你问这个问题的原因，所以我要向你坦白，运行此问题的解决方案会更慢，比for循环更糟糕的解决方案，如果你要谈论性能，我用这个例子来说明这个想法。

我可以看到这不是一个使用递归的好例子，我想谈谈它的机制，它在这里是如何用简单的东西来工作的，比如提示，我认为递归更有趣的地方，有更多的问题祝福你，有些问题本质上是递归的，比如在目录树中搜索文件。

但是还要搜索目录树下面的目录树，在递归的目录树下面，或者你知道，逃离迷宫，如果你被困在这里，从那里逃走，如果你被困在这里，从那里逃走，从迷宫中逃脱有一种递归，找到你名字的所有字谜，“好吧。

你是怎么做得很好的？”，你找到这个词的所有字谜，然后你递归地找到这个词的所有字谜，有一些算法非常相似，我们将使用递归来解决，这不是那种算法，但是，如果我直接跳到那些算法，很容易迷失在代码的复杂性中。

这是这么简单的一段代码，在我深入研究硬件之前，我想确保我们理解它，还有什么问题吗？有人举手，我不知道他们的问题是否已经得到了回答，我想我们快到我的幻灯片恢复的地方了。

让我看看，所以我想我们现在可以去这里，通常当您编写递归代码时，您的代码有两个或更多情况，就像如果与其他情况相比，其中一种情况被称为基本情况，这意味着这是这个问题的一个简单版本，我可以直接解决。

我现在不需要使用任何递归，所以在我们的阶乘中，n是零，或者n是一，我只知道答案是什么，那就是，答案是这样的，也可能有所谓的递归情况，更复杂的案子，在我不知道答案的地方。

我要做一个递归调用来帮助我找出答案，通常递归调用是同一问题的较小版本，如果我在处理一个int，我把那个int去掉了一点，我把整型数除以1或者除以2之类的，如果我在处理某种收藏，也许我把一些元素切掉。

并使用Perum查看其余元素，等等，所以这是一个重要的想法，如果你要写一个问题的递归解决方案，您希望每个递归调用处理，解决问题的一小部分，这取决于我的意思，这取决于问题是什么样的，如果我在寻找什么。

也许每个调用搜索搜索空间的一小部分，如果我在计算一些东西，一个和阶乘或其他什么，也许每个调用计算该表达式的一项，好的，好的，所以每个电话处理一小部分工作，我还听过另一个例子，有时他们用在孩子身上。

就像他们向八年级学生展示递归什么的，他们给他们一大碗糖果，像妈妈之类的，他们说如果你能，所以他们给你一大袋巧克力，里面有一些M M，他们还给他们一个单独的袋子，就像一堆无限多的M M，好啦，这个想法是。

你怎么把碗里的m和m的数量增加一倍，但是你不能数数，你不能数数，你们可以一起工作，但是你不能数数，所以你有一个有N M M的碗，对于一些N，我希望它有两个N，我有无限的供应，我可以放进碗里的更多。

但我不知道该放多少，因为我不知道n的值是多少，它足够大，我不能只是看着它，我不能只数，或者我不能算在一些学区的情况下，我不太清楚，你知道的，伯克利地区，你知道的，哎呦，我开玩笑的，呃，哎呦，太像你了。

然后你问所有这些孩子，你是怎么做的，然后你提醒他们，你们可以一起工作，即使你不会数数，你们可以一起工作，所以你试图让他们想出一个算法，每个孩子都帮了一点忙，把碗里的巧克力翻倍，有谁知道。

八年级的学生可以解决这个问题，你能不能，你能帮我一点忙吗，把碗里的巧克力数量翻倍，你怎么这么说？我是说，你可以给一半给一个，它让那些孩子得到50万，好啦，把它分成两半，这是个有趣的想法，问题是。

我不知道一半是多少，碗里有一大堆，嗯不，但它是它是，我认为很多算法都遇到了类似的问题，你说的地方，你拿五十个，我去拿一百块，你说，嗯，我不会数到五十，你知道的，我也许可以记录下一小部分，但我不会数数。

伯爵，数到一万或十万，是呀，大人，你得到了，拿一个阿姆，从无限的供应中取一个，然后我该怎么处理它们，每个人都这样做，现在我们都拿着m和n加上供给单元，一旦碗里什么都没有了。

让每个拿着这些的人都给他放回去，现在有两倍的权利，我们一起工作，虚构的，你们可能很生气，因为我没带对，一个好老师会做这个游戏并带来证据，我才不管呢，我不会带任何证据，否，你可以想想艾米纳姆的。

你可以想想你希望你有多少阿姆，是啊，是啊，那是个好主意，那是，你就是这么做的，每个孩子都在解决这个问题上做了一点贡献，我只抓了一个艾米纳姆，我抓了一个供应，阿姆，这就是我所做的一切。

然后我把它传给别人来帮助剩下的，但是，所以另一件要记住的事是我们所有的孩子一起工作，我们都在遵循相同的算法，如果你把我带到那里，你带她到那边去，算法还是一样，我们不是每个人都遵循特别的指示，你是第四个。

所以你这样做，你是第十七个人，所以你这样做，我们都是平等的小工蜂一起工作，我们是递归函数的调用，如果碗里有阿姆的话，带上艾米纳姆，拿米内姆通碗递回通常有那两种情况对吧，那另一个案子是什么，如果没有。

如果没有妈妈，那我什么都不做，我只是把它还给你，不管我们把它送回去，它来了，最终，当它回到第一个开始整件事的人身上时，他们又把他们的两个M和M放回去了，我们停止了生产，所以如果空传回来。

否则拿拿过等等放放过，差不多吧，你知道我是这么想的，这是一个自我相似的问题，事实上，我想再次提到这一点，当我们谈论递归时，我们谈论自我相似的事情，对吧，所以我很想从自相似性的角度来讨论这些解决方案。

这是一个很好的算法，完全解决了这个问题，但是我们使用的解决方案是如何相似的呢，想一想，把一碗阿姆，就像把另一碗米米的井翻倍，如果我拿了我的一个，我就出局了，我把我的供应，我和我出去。

我知道碗里以前有多少阿姆，少了一个所以，如果以前有n个现在，有n减去1的权利，我把它递给一群人，做一堆事情，最后碗还是回来了，我指望这个碗已经从N减1变成了，在里面有2乘以n减去1，阿姆在里面，对吧。

二n减去二，所以当我把我的M MS放进去的时候，会增加到2N所以，我从n到n，所以我经过，等待它回来，这个新碗的巧克力我要双倍的价钱，少了一个所以，我把碗翻倍的算法包括让其他人取悦，把碗翻倍。

但是让他们翻倍的碗是这个碗的小版本，你明白吗，我把一个拿出来，把这个问题稍微分解了一下，然后同样我说，我不知道怎么把N和M的碗翻倍，但我绝对可以得到一些帮助，加倍一碗n减去一毫秒，然后我再做剩下的。

所以它看起来很简单，每个工人，B必须做的，函数的每次调用，如果你将不得不做，有人举手，是啊，是啊，如果你能理解n减去1，并这样做减去1，然后你就可以很好地下去了，我是说，如果你能理解n减去1。

你会数数吗，我想我的意思是，我不知道n是什么，我明白数字的存在，我只是记不住，数着数字，你知道我有某种特殊的残疾，我不知道你真的要把我的我的，我的精神状态在某种程度上让这一切奏效，但是但是是的，嘿嘿。

这是一个，这是一个非常虚构的想法，不过，好吧，所以你寻找自我相似的东西，您尝试编写具有大小写和递归大小写的代码，这通常是我们看到的模式，所以阶乘已经讨论过了，嗯，废话，废话，废话，所以这里还有一个。

这是一个神秘的堆栈痕迹，如果你通过六四八，在蒙特十号，六十四和十b，所以它以六十四的神秘呼唤，加上872，所以我们上升到72，七是除法，二号是七号模组，加二九，我们上去，现在还不到十点。

所以我认为这里的答案是九圈，所以这个东西是一个数字，求和神秘函数，一些数字，所以还有其他像这样的神秘问题，如果你想浏览它们，看看它们是如何工作的，嗯是的，所以他打了6-4-8，七十二中的n。

也就是9中的n，它返回这些答案，我有时会谈论这些调用堆栈跟踪，每次调用函数时，函数的另一个副本，我想这是一个很常见的误解，学生们有他们说的地方，哎呦，你打电话给我六四八，所以我到了这里。

所以这意味着它跳到这里，这基本上是对的，但不完全正确，因为当你说你想打电话给一个72岁的神秘人，它不只是像跳到这里，再也不回来了，它实际上产生了函数的一个新的完整副本，整个副本从这里开始，但我还在这里。

我仍然存在，我的第一本还活着，我只是在等他还东西，不管是什么好东西，好呀，一步一个脚印，当我把那家伙放在观众席上，他完全是个，不管他还什么，我也会回来的，但这仍然是一个重要的想法，我坚持他的存在就像。

当他接到电话，弹出了他的第二个版本，他在等他的第三个版本，当他最终说他要回来的时候，回到哪里的尽头并不是所有的路，它立刻回到第二个人身上，第二个人在这里等着，所以9在这里翻牌。

这又回到了第一个在这里等着的人身上，这又回到了最初打电话的人身上，这是一个微妙的区别，但这是与使用，像循环一样说，在这种情况下，效率要提高多少，哦还有多少，效率差多少，嗯，可能会很明显，因为编译器在。

优化循环和递归的C++，它不擅长优化，所以对于这些少量的问题，你会有点难过，如果你做了一个基准，你就会说，哦，我的上帝马蒂，否，我们不要这样，嗯，但就像我想的那样，如果你嗯，如果你在看几个函数调用。

像这样，那还不错，如果你要看上千个函数调用，一百万个函数调用很糟糕，所以我们要尽量避免递归，如果我们要打那么多电话，但通常不是很多，好啦，另一个，另一个问题，是啊，是啊，但是复制函数的过程。

每次使用的内存比，我确实喜欢一个循环什么的，这有道理吗，是啊，是啊，嗯，我是说，这些函数调用堆栈帧中的每一个都使用一点点内存来记住，要跳转到的内存地址，参数值之类的，这不是一吨的记忆。

只是几十个字节什么的，但它是一些，所以有一点点内存被使用，我会说不要太担心，因为我们说的不是一个巨大的网格，那是被复制的，不管我们在说什么，你知道的，六十四字节之类的，是啊，是啊，你能简短地说说。

比如尾部调用优化，或者函数式语言如何使递归更有效，是啊，是啊，我将讨论优化递归，我是说它就在我们下面，就像如果你，如果您使用正确的语言和工具，有时取决于如何构造代码。

您可以达到编译器可以运行这些东西的状态，真的真的快，事实上，这个函数在某些语言中运行得非常快，不会有任何内存开销，因为编译器会优化，因为它发生在我们下面，我基本上不会多谈这件事，但当我们讨论递归时。

我会在某些地方提到它，好的，好的，所以让我们做更多，我真的觉得最好的办法就是练习，我鼓励你使用像一步一步这样的工具，只要看看书中的问题，围棋练习递归，你做得更好，你练习得越多，让我们写一个幂函数。

将基数计算为指数，我们不允许使用任何循环，所以让我们去可爱的创造者。

我要写出幂函数，所以基于一个指数，就像它说的pow，但它应该说幂幂3逗号4返回3到4，八十一，计算如何成为一种力量，类似于计算一个幂，它本身怎么相似，所以这几乎就像我们在循环乘以基数。

一遍又一遍一遍又一遍，对很好，那么我如何在没有循环的情况下做到这一点，让我们想想，它是如何自我相似的，计算的一小部分是什么，每次通话都会影响整个任务，比如我们如何在不计算整个答案的情况下更接近答案。

是啊，是啊，就像一个数字，如果我们想要x到最后，这和乘以x减去1是一样的，好啦，是啊，是啊，是啊，是啊，是啊，是啊，所以你的意思是，三的四次方等于三，三的三次方，等于三乘以三，三的二次方，以此类推。

对呀，好啦，我什么时候才能停止这支舞，三比一等于三，我可以我可以做得更简单，右三到零是一，所以我的意思是，是啊，是啊，基本上你可以说，如果指数为零，那么任何到零的东西都是1，右边对不起。

我不能键入返回一，有时我会写基本情况什么的，只是为了记住，你们说好，如果指数为1，我可以把基地还给，这也是一个基本情况，无意双关语，嗯，你们不喜欢我今天的递归笑话，嗯，如果你想要一个递归笑话，嗯。

理解递归需要学习的第一件事，是理解递归的权利，我知道，否则如果，如果指数不是零或一，我们就在这里做这个，你们说的，所以返回基本时间，基数对x的幂减去右一，知道了知道了，我认为这个代码可以简单一点。

我可以排除其中一个病例，你知道哪一个，指数等于一格，因为如果你仔细想想，如果你说你要三到一，现在这里的帖子，所以它返回三个右，好啦，但是如果你把这个案子删掉，它要么是零，要么是递归的，如果你说3比1。

不会在基本情况下，会是这个案子，所以它会以零返回三乘以三，三到零是一，三乘一也是如此，三个人，它会返回相同的答案，实际上，它将需要一个更多的递归调用，但我不想微观管理，哎呀哎呀，有人举手，是啊，是啊。

我说，需要一个以上基本情况的真实世界任务，需要一个以上的基本情况，是啊，是啊，通常你可以减少，我是说技巧就是给你的脚制造一个问题，但我，那里有，其实呢，我是嗯，我将给你们看一些例子。

有时我们通过抛出异常来处理某些情况，也有这样的情况，如果它是偶数，如果在基地很奇怪，你做不同的事情，所以肯定有这样的例子，我要做一个计算回文，有时取决于如果你收缩一个字符串，如果它们匹配与否。

你做不同的事情，所以是的，现在肯定有不止一个基本情况，等等，为什么我的，它说它不能建立递归点，哦等等，这是怎么回事，嗯，让我想想，为什么会这样，上面写着多重主，但我这里有什么包括问题吗。

我没有一个以上的主要，我编译了这个早期的多重定义，它认为我有不止一个做，我有一些喜欢，包括你自己，是啊，是啊，我在想，如果我我，哈哈哈哈，我只是不够聪明，做不到那种事--你喜欢吗，是啊，是啊。

我想知道我是不是这样，如果我搜索主号，我只有一个，所以等等，我在这里做了什么，哼，让我想想，为什么会这样，我有吗，我有一个递归年龄，等一下，等一下孩子。

今天真是我的大日子，我所有的设备都正常工作，我的幻灯片正常，我只是有预感，让我们去递归探测，CPP，所以我现在肯定有一些递归问题，所以让我们重新加载。

我要重新编译，递归探针编译，让我们看看它是否有效，是啊，是啊，我们说到哪儿了，所以我们在做幂，幂，基数x，它在哪里，所以现在我们可以看到斯坦福图书馆自己编译，这总是一个伟大的时间，那是个故事。

我给你讲个故事，你想看小狗的照片吗，是呀，我知道如何填补死亡的时间，我不是嗯给你，这些是我的狗今天早上在外面的院子里，那是艾比，那是克莱德，那是巴尼，现在你看，有一张两张床，里面有三只狗。

所以你可能会说第三张床在哪里，嗯，我告诉你，他们把它拖到那边的拐角处，弄得脏兮兮的，不管我把这张床带回来多少次，他们总是把它拖走，我相信他们希望那里只是太糟糕了，所以有人要和某人依偎在一起。

也可能他们只是喜欢拆床，我不知道，它是两个中的一个，好啦，现在你看到了一张模糊的照片，按字母顺序，艾比巴尼和克莱德，是啊，所以实际上我一直告诉我的妻子，我们应该给女儿取个D开头的名字。

你知道像多莉什么的，然后爱德华我们的下一个故事她就像，你真的打算给我们的动物和孩子同时取名吗，我就像嗯，对不起，有人举手了吗，还是小狗的问题，它汇编了，你看到那个表情了吗，它汇编了，太棒了，小狗照片。

保存一切，好啦，所以它基本上起作用了，我想三到四个，这些看起来很不错，我这里有一些负数，它没有做正确的事情，这是正确的，嗯，零中的四是一，但我不是还有一些其他的阴性测试吗？对不起，我知道不要试着说负四。

零不是一，我的意思是，如果我真的喜欢，呃，负四分到三分，是啊，是啊，所以我想在这里谈谈这些不同的案例，所以一个系统问题，嗯，所以实际上负4到3，那个效果很好，因为它乘以自身的负4倍。

但当我试着做5到负3的时候，它其实，我鼓励你，如果你决定要和你的男朋友或女朋友分手，只是这段感情竟然有了，所以好吧，这个坠毁了，虽然，那么这次撞车是什么，我超过了五个作为基础，负3是指数。

让我们再看看我们的代码，为什么负3指数，嗯，在这里做坏事，所以它调用负4的乘幂，负四不是零，所以它通过了负5，哦不，螺旋进入一个不完全无限但基本上无限的递归，从技术上讲，如果我继续减少一个int数。

我最终会潜流到最大可能的积极，并做到这一点，那是什么，它为什么要这么做，为什么它没有那么好呢？因为内存不足，在它得到负20亿或其他什么之前，它不能做价值20亿的电话，所以这是一个堆栈溢出错误，真不幸。

那么我们应该做好什么呢？你可以说，我假设你通过一个至少为零的指数，所以如果你不这么做，那就是你的问题了，那是一种方法，但这对项目来说不是一个很好的经历，出人意料地结束，没有关于发生了什么的真实信息。

所以很多时候我们要做的是，我们会说好的，如果指数小于零，那么我们该怎么办呢，我们可以做c out，嘿嘿，愚蠢的，这是不对的，或者别的什么，嗯，在许多语言中，我们通常不是这样做的，您可以提出一个错误。

抛出异常，或者类似的东西来表明您的函数被以非法的方式调用，在C++中，你可以扔东西，投掷是指，在Java中导致错误发生，你说的好像是，抛出新的非法论点例外或其他什么，你知道你，在C++中做类似的事情。

加上约定是，如果调用者传递给您一个您不喜欢的值，惯例是把这种价值扔回给他们，这是你的指数，它说一个int异常发生在负3，这样就好一点了，它有一个堆栈跟踪，上面说93岁的谎言是罪魁祸首，所以，啊，好啦。

如果我是真的，那就差一分了，但不管是什么，它用黑客来计算行号，但这就是为什么它说近似，我写了这个代码，我真的很努力，我得到了，站在一条线上，所以这很常见，如果你有一个递归函数，有一种参数值会破坏一切。

你检查一下是否有不良反应，你在上面抛出异常，所以我想从技术上来说，这里有两个基本情况，那种非法的论点基础案例和那种法律上最小的问题版本，这里的基本情况，但我们肯定会要求你写递归函数。

我们会说你应该抛出一个int异常，如果发生这种事，我的意思是在函数中去掉一些int，如果这是非法的，好啦，它仍然会使程序崩溃，所以你可能会说，但我以为目标不是撞车，或者任何它仍然崩溃的东西。

但它以一种我们可以追踪问题的方式崩溃，总的来说，撞车也不错，这不是我代码中的错误，这是调用我的代码的人的错误，他们应该修理他们的狗屎，你知道我的意思就像，所以他们想知道他们的电话是坏的。

他们应该把电话修好，你可能会说很好，但他们只是在那里通过了一个负3，我不知道，可能是他们提示用户输入一个值，用户打错了他们应该做的事情，如果else在该值上，在他们调用我的函数之前，或者类似的东西，嗯。

反正，好啦，那就是力量，关于那个有什么问题吗，是呀，对例外否，你不需要包括任何东西，你只要，这是语言的一部分，你可以直接说，扔有一个标题叫错误点H，它有一个错误函数，为您抛出异常。

但我认为没有比这更简单的了，我觉得这样挺好的，好啦，所以让我们做更多。

让我们做更多这样的力量，啊，我想指出的一件事是，这基本上是我们写的，我们谈论的，当指数等于1时，但实际上我们做了电话叠加，是啊，是啊，是啊，是啊，是啊，是啊，所以0比1好，这是一个更好的基本情况。

我觉得我们讨论的是真正得到它并确定你需要什么案例，哪些案子你不需要，我们有时称之为递归，如果你真的得到了递归，你会说，啊，我们不需要指数，等于一个案例，我开悟了，我看在零的情况下会处理得很好，没关系的。

所以你知道这就像一个想法，你呀，通过编写更多的递归函数，我想说人们写的最常见的不必要的案例是，从贝斯手的基本情况来看，就像他们，他们看不到零，但他们写了一个案例或类似的东西，那很常见，所以是的。

我们说过有时候你会做出假设，我们有时称这些假设为，先决条件，我在努力加快速度，如果你违反了先决条件，引发异常，您可以抛出任何类型的值和字符串，东西什么的，也有尝试，C++中的catch语法。

我今天不想谈这个，但你可以有电话的另一边，捕获异常并处理它，如果他们想对此做些什么，是啊，是啊，所以扔一个负指数，你可以把这个箱子，我所做的是，我没有把所有的指数都扔了，我扔了一个屏幕。

说你实际上是个消极的指数，你也可以那样做，无论哪种方式，这都给了您更多的描述性错误消息，好啦，快速优化，你可能会注意到当你在做指数的时候，你知道如果你只说N次，n减去1的幂。

你必须对n的指数进行n次调用，如果你想减少你的电话数量，一点点，你们中一些关心效率的人，嗯，你可以注意到12的3等于6的3平方，也就是三四到三，你可以在这里切成两片，而不是每次只从上面取下一个。

所以你可以把它合并到代码中的方法是，如果你处理的指数，你可以，你能处理好的，所以它的代码看起来有点像这样，如果你计算的指数是偶数，平方基数并有指数，这是一个小的优化，但它实际上需要您从n个递归调用。

以对数为基数，n个递归调用中的两个，我们之前已经讨论过了，耳部比末端好，因此，在时间和记忆方面，这都改变了大O的类型，对于这个计算，它的整个权力实际上是在内部实现的，我认为数学学习，啊，实际幂函数。

他们永远不会使用递归，否，我开玩笑的，实际的幂函数不使用递归，因为这种语言有一个高效的递归实现，所以这仍然是一个例子，做这种事的真正的男人和女孩，不要在此示例中使用递归，但我想我们越来越近了。

我认为这是一个例子，什么的定义，我们的计算很好地自相似，所以我们越来越接近具有这种属性的问题，好啦，让我在这里再往前一点，这里有一个神秘的例子，我想跳过它，我想写作，这个叫回文。

告诉我一个流向前和向后的字符是否相同，所以就像你知道的，赛车，我们的也一样，但你可以把它转过来，它仍然拼写赛车是对的，那么这个自我是如何相似的呢，没有循环，你不允许使用任何循环，所以再一次。

我对这些问题的看法是，我试着考虑基本情况，就像什么是绳子，那很容易回答，不管是向前还是向后，所以好好想想，我想的另一件事是，我能做少量的检查吗，就像你甚至可以先想到循环版本，试想如果我有一个循环。

我该怎么办，我有我的电话，做其中的一小部分，然后递归，剩下的，这些是我思考这个问题的方式，所以一个我还没叫上蓝衬衫课的人，然而，你将如何开始，我想说每一步，我把最后一个和最后一个中的第一个字符，是啊。

是啊，如果他们相似，我将把两者之间的子字符串传递给下一个伟大的，如果我最终只得到一个角色，所以是的，很高兴看到结尾，以结尾开始的字符，如果匹配，完成剩下的工作，并继续使用递归。

最后我把这根绳子削减到基本上没有，也可能是一个角色什么的，那太好了，我喜欢它，你们中的一些人可能想得很好，为什么我不构建一个字符串的反向版本，我看看他们是否平等，那也行，但它的自我相似度较低。

很难用自我相似的方式来描述这个过程，这是个不错的算法，只是不那么递归，所以嗯好吧，检查结束字符。

我可以这么做，我这里有一个函数叫做回文，所以通常代码看起来像，如果一些基本情况是正确的，然后是递归情况，有时候，你知道这很奇怪，因为就像我认为你想从上到下写代码一样，有时候，但实际上当我学习递归的时候。

我总是发现思考递归情况更容易，他是这么说的，看第一个字母和最后一个字母，然后用中间的东西，对我来说这听起来有点递归，你知道你也说过什么时候该停下来，这是基本情况，不过没关系，嗯，你的意思是，关怀。

第一个等于S括号零，这里，最后等于s括号，S点长度减1，然后如果第一个等于最后一个，那很好，所以我得检查绳子的其余部分，就像弦一样，中间等于S点，1到s点长度减去2的子字符串，第二个参数是多少个字符。

所以说，这就是我想要的角色数量，所以说，如果第一个和最后一个相等，我把中间切开，递归魔术，对呀，看看中间是不是一个，如果两端是回文，它们之间是一个回文，整个字符串是回文，所以我应该回来，不管是回文。

中间是什么，很多学习递归的学生，他们删除了返回这个词，他们只是说把他叫错了，传给中间，那太好了，这就是你想要的，不过，那个代课老师会想出办法的，它会还给你一些东西，你得把它还给打电话给你的人，你放手。

你带回来，你必须把这些电话看作是一个廉价的，就像我把我的M和M碗，当经理回来的时候，我把我的东西放进去，我不只是把它掉在地板上，我得把它传回去，你知道我的意思，我得把它传给给我碗的人，所以是的。

这是你的递归情况，所以我想另一种提取基本情况的方法是，我什么时候才能停止这样做，你知道，我的意思是，一种方式来思考基本情况是，如果你让我计算一些非常简单的东西，我可以做的，这是一种想法。

但并不总是外面的颜色让我计算一些简单的东西，有时我已经做了一段时间了，现在我已经把这个流媒体简化为简单的东西，那么有什么地方可以让我停下来，我在里面放什么，如果在这里，如果s点的长度是多少，如果是。

我想是，可能还不清楚，我们怎么处理空字符串，但是让我们说，对于空字符串有一个回文是很平常的，或者对于一个字母字符串，因为如果你反过来，他们不会换另一根弦，因此，如果长度小于或等于1，则返回true。

那由两个字母组成的字符串呢？这样行得通吗？我们完成第一个，我们会完成最后一个，我们检查它们是否相同，中间会是空的，所以我认为这很好，我们去试试，我知道我们没时间了，这将是我们做的最后一件事。

然后我们就离开这里，所以让我们做一个回文测试，它应该这样做，啊，我以前也有过例外，对不起，好吧等等等等是的，所以实际上我有一个，我这里有一个小虫子，所以如果第一个和最后一个是一样的，检查其余的。

如果第一个和最后一个不一样，我不是回文，如果我的第一个字母和最后一个字母不一样，我甚至不需要做递归调用，我不是回文，我们再试一次，使编译器无法返回，是啊，是啊，它应该有编译器警告，待会再看。

看起来完全管用，你只要打个小写字母，然后你就很擅长了，所以我没时间了，我得让你们走了，我们要练习，周三有更多的递归。

到时见。

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P8：Lecture 08 - Recursion 2 - 加加zero - BV1By411h75g

好啦，人，让我们挖掘你好，很高兴见到你，天气不错，我们周围的世界都在燃烧，太棒了，这是真正的梅瓦什么的，我不知道所以，让我们试着不要去想不好的事情，让我们学点c+um，我们今天要继续递归，整个星期。

这是递归周，你想听一个非常糟糕的递归吗，乔，是呀，是呀，好啦，开始了，敲门，敲门，敲门，敲门，是啊，是啊，是啊，是啊，这就像我很抱歉一样好，我会说我写了一本书，Java教科书，斯坦福大学不使用它。

那是我过去在华盛顿大学工作的地方，在我们的书里，你知道的，我们讨论了递归，在书末尾的索引中，我们放了一个条目，上面写着，递归，逗号，无限，是啊，是啊，这就是为什么这本书习惯了，是呀，慢拍手，谢谢你。

那是适当的反应，我们必须喜欢，为得到笑话而战，索引器，就像他们有一个做索引的人，她就像，不明白我们为什么要把这个放进去，我们就像这是个笑话，真好笑，她就像，它不去页码，我们就像，我们知道。

我们知道这是个笑话，她就像，但当它说c时，它就会自己，我觉得这是个笑话，是啊，是啊，真的很好笑，真的很好笑，你知道她是个出版商，她不是计算机科学家，最后她说，好啦，不管她怎么说，嗯，是啊，是啊，好啦。

所以我们要做更多的递归，你看，我是说，主要是今天，我只想多练练，事实上，本周的部分也将是这样，你只需要练习大量的递归，所以讲座的主题是我们，研究一些不同的问题，看看我们是否能解决它们。

因为我认为这就是你学习递归的方式，你必须练习，当然啦，就像我说的，上次我鼓励大家去练习，可爱的创造者或一步步编码，或者任何你能擅长的方法，实际上去写递归代码，你就是这样好起来的，你就是这样得到它的。

如果你还没有感觉到你这么快就得到了，总结一下什么是递归函数，是那个自称正确的人，好啦，所以如果你试图解决一个递归问题，你想写一个递归函数，你可能需要考虑的事情是什么，有哪些概念可能对思考任何想法都有用。

任何一般提示，你说的话，基本情况问题的某种基本版本，一些你知道解决方法的问题，或者有非常简单的方法来确定是，谢谢你，他说，基本情况，所以你知道，试着想一个非常简单的问题，那很容易解决。

您甚至不需要使用任何递归来解决，你只要回一个答案，打印并回答，或者别的什么，好好想想，你可以从那个案子开始，也可以不开始，但我不知道为什么我今天一直有系统错误，但是是的，这是每个递归函数的重要部分。

它必须在某个时候停止，基本情况是什么让它停止，所以想想基本情况或情况可能是什么，是呀，你还有什么要补充的吗，是呀，这个问题是怎么解决的？自相似，是啊，是啊，谢谢你，嗯，我真的很喜欢这个框架。

如果你知道我喜欢怎么想，如果我能让其他人帮我解决大部分问题，但我得自己解决一点问题，我怎么能重新安排呢，这也是同样的想法，就是，这个问题是怎么解决的？类似于同一问题的稍微小一点的版本或稍微不同的版本。

好极了，好啦，所以我们就玩吧，我们再练习一下，我们写了一个幂函数，我们写了一个阶乘函数，一些类似的事情。

我们写了一个回文查找器，我想和你一起做这个叫做打印二进制。

所以除了以十为基数的整数参数，我想让你用，喜欢控制台看看怎么不回来，但是打印二进制基数，该数字的两个表示，你们知道，二进制，就像所有东西都是零或一一样，二进制数字每一位是2的次方。

而不是每个数字都是十的次方，你知道这种事，所以如果你想弄清楚，数字四的二进制版本，那是三二加八分之一，加2等于4 2，所以这就是你做二进制数的方法，对呀，好啦，所以我想，我想现在把它打印出来。

我不想作弊或调用一些为我做转换的库函数，我也不想用任何循环，我也希望在不将数字转换为字符串的情况下这样做，我想有些人喜欢把整数转换成字符串，这样他们就可以在数字上循环什么的，我想如果我们想在数字上循环。

我想做他们没有任何条件，参与其中，你是怎么做好这件事的，你们刚刚给了我一些很好的建议，我想我想回到那个建议，你告诉我，我应该考虑基本情况的权利，所以我不知道，如果我能想出一个一般的方法把这个变成那个。

但是有没有什么数字更容易用二进制打印出来，你说呢，摇晃是的，不到一个不到好，一位数二进制数，零或一似乎很容易对吧。

好啦，嗯，我们去试试，我这里也有一个可爱的造物主，这是一步一步来的，如果你也想的话，所以我要取消注释，这些是我的测试用例，测试用例在这里调用print二进制，所以好吧，等等呃，等等不不，那不在这里。

没关系的，所以我们可以假设这是一个非负数，我们正在打印出来，所以你告诉我如果是很小的数目，所以如果n小于等于1，然后我就可以做c out n，因为十进制是一样的，这是最难的部分，好啦，基本情况。

你知道的，递归可能真的很棘手，也挺有趣的，因为感觉就像你在作弊，好像我只需要做简单的部分，我得打印一个或零什么的，那并不难做好，好啦，但如果不是这样呢，所以这将是递归的情况，这意味着n至少是2。

那就更难了，你又给了我一个好建议，你说过，试着看看问题是如何自相似的，所以好吧，我喜欢这个提示，我想这可能是个有用的提示，所以如果我要打印4 2，我不知道那会变成什么，我是说，我知道因为我看了幻灯片。

但我一般不知道，嗯，我的电话能帮上忙吗，做，我知道四二的二进制版本是什么，还是不做，我是说，即使我不知道它到底有多少位数字，或者这些数字会是多少，我能说些什么吗，仅仅从看数字42，是呀，即使是零。

是偶数，所以二进制表示以零结束，那是个好主意，嗯哼，好啦，嗯，如果我告诉你打印二进制4 2，那将是一个零，一零，一零，所以你只是你只是告诉我你能想出正确的那部分，但这是最难的部分，这是什么？

二的幂就像二的幂一样，那么这个数字是多少，这个二进制数就是21的二进制数，所以我不知道怎么打印四二的二进制，但如果有人能帮我打印二进制的2-1，如果有比我更聪明的人能做到，我可以做这部分。

我得到了这个部分就在这里，这就像，你知道你曾经喜欢帮你的妈妈或爸爸打扫卫生，你知道，他们做了所有的工作，你喜欢捡起一些东西扔进垃圾桶，你就像在那里，今天我们都帮了忙，那是我的贡献，我把这个零印在这里。

好啦，所以让我们按照你说的去做，你说它以零结束，或者以2结束，这是偶数，这样我就可以打印一个零，所以也许我可以做的是，像int最后一个数字等于，最后一位数字是，你知道吗，你可能也在看那个。

就像N mod 10，但那不太对，我想我们真正想要的是四二的最后一个二进制数字对吧，余数是偶数还是奇数，是二的余数，然后，是n除以2右，不除以十，因为只有四个人，所以这将是零，这将是二一对。

如果我说打印其他数字的二进制呢，两个一个部分，然后在那之后，如果递归调用做了我想做的事情，如果它把这个打印出来，然后我就可以看到最后一个数字，如果最后一个数字是零，则对，我要印一个零，如果最后一位是1。

我要印一张，嗯，也许五百块没用，其余的数字都起作用了，我们基本上做到了，我们解决了，嗯，所以我们很棒，是呀，我为我们感到骄傲，所以我们没有处理负数，然而，我怎么能把它贴在这里，我们是否假设负数，是啊。

是啊，我想我想对不起，我没有很清楚地说明我想要什么，所以这里我写了n大于零，如果我把它扔掉呢，如果我做例子呢，二进制负数，四十三张印刷品，否定那里，所以怎么样，嗯，所以我的意思是。

基本上我们只需要添加另一个基本情况，如果n小于零，看到减号，打印负n右二进制，只要打印一个减号，然后做剩下的，然后在这里我想我会说别的，如果是这样，这是一个基本情况。

或者我猜这个递归案例实际上是递归案例，负数，随便啦，好啦，所以现在我认为我们应该正确处理负数，是呀，我们有我想我的意思是我没有仔细检查，但这似乎是对的，嗯看起来不错，有一件事我想指出。

就像一个微妙的小事是看你怎么说打印二进制其他数字，然后你说看到最后一个数字，说打印最后一位数字的二进制文件也是正确的，那些是等价的，因为如果我在0或1上调用打印二进制，就会变成这样，把数字打印出来。

我们以前也是这样，所以你可能会说，为什么要改，你让代码做得更好，我改变它的原因只是对我来说，自相似性是四二的二进制是二一的印刷二进制，后面是最后一位数字的打印二进制，所以对我来说这更像z。

因为它更像自我，但另一种方法效果很好，只是想指出，所以这是打印二进制，关于那个代码有什么问题吗，是呀，我们还使用日志函数，那个垫子，哦，像原木一样的原木底座2，是啊，是啊。

我是说我在这里看到的学生所做的，有时他们试图从左到右，我实际上是从右到左，从右到右，我在切掉最后一个数字，这很容易做到，使用div和mod，我想另一条路是你试着喜欢原木，用力量看看有多大的力量。

你需要一直向左走吗？你先试着打印左边的，我是说你可以这样做，但我只是觉得这是一个漂亮的递归解决方案，我想我认为认识到自我相似性，你知道两种方式，我想我宁愿用语言容易做的方式来处理它，我没必要叫数学点。

日志或电源或任何解决这个问题的东西，很多数字处理问题都有这个属性，哪里，这并不重要，无论从左到右还是从右到左，语言使从右到左更容易，所以我们就这么做吧，好啦，所以这是打印二进制。

我想和你们再做一个，我想这意味着我要跳到我的下一个幻灯片上，我再确认一下，我想那是真的，是呀，好啦，所以让我打开今天的幻灯片，我今天会试着用不同的方法，数据可以是递归的。

你可以在递归代码上做一些很酷的优化，但又一次，就像我说的，我们只是要练习很多例子，所以说，让我们处理一个文件，写一个叫做反向行的递归函数，你传入一个读数很大的输入流，如果流实际上，但是嗯。

传入一个输入文件流作为引用，如果这些就是，我想把它们按相反的顺序打印出来，我想递归地做，我想在没有收藏的情况下做，因为你可以把所有的线读成一个向量，然后在向量上循环什么的，我想找到一种使用递归的方法。

做倒车，而不是使用集合来做相反的事情，所以我看到你的手，我马上打电话。

嗯，所以如果我回到我的档案，我想写一个文件，一个叫做反向线的函数，你们在这节课开始时给了我很好的建议，我很想听你的忠告，你说过，我应该考虑基本情况，对呀，什么是一个简单的文件来反转，一条龙，是啊，是啊。

我同意你，我比你看起来更懒，虽然，有一个空文件比一行文件更容易反转，你还是对的，这两个文件都很容易向右反转，但我想指出，一个空文件会更少的工作，你让我做的微不足道的工作，垃圾怎么倒，没有这样的。

所以我不干了，我做到了，你知道对，所以空文件现在很容易做到，我要说一件有点复杂的事，没有命令让这个问它，窥视前方，看看是否有一条线，或者不看它是不是空的，你所能做的就是，你可以试着读一行，它要么成功。

要么失败，就像到了，你知道是否有一条线，你已经读过这一行了，如果有一个需要理解，所以你不好好读书就不能问，没关系，我的意思是，如果你想读一行，你说从输入中得到行，你传递一根绳子就像，你知道的，弦线。

然后你说，右行，这是从文件中读取一行的命令，我怎么知道是否有一条线，或者如果有，如果文件是空的，或者什么，我怎么知道是，把它放在一个，如果是的话，如果get行返回true，然后有一行输入要读取。

否则就没有，所以这两个案子，好吧，现在这个问题很难，所以我想也许我能帮你们一点忙，所以我所做的，你知道我是个很有同情心的人，很好的老师，所以嗯，我想也许这个太棘手了，所以我只是想。

只要给你解决这个问题的办法，所以我在上课前写了一个函数，因为我不确定你们能不能处理好这个问题，老实说，我做了一些你的家庭作业，不仅仅是，否，你们真聪明，但是我写了这个函数，如果你在输入流中通过我。

我把文件倒过来给你打印，因为我不确定我们是否能处理好这个问题，但我会说，嗯，我觉得有点内疚，调用此函数，所以也许我们可以在函数中做一点工作，然后我们可以骗剩下的什么的，所以也许在这里我可以做。

你知道我已经读过这一行了，所以我在这里有一条线，如果我有反转文件的作弊功能，我可以用那个，我可以说作弊，我可以把输入，所以这将打印成，你知道的，所以我在这里读了这一行，玫瑰是红色的。

作弊功能将读取其他行并向后打印，所以它会打印这个，然后这个，然后这个，所以这里的作弊调用要做最后三件事，所以我只需要把我的台词打印出来，所以现在呢，就在这里，我说，看到线尾了吗，酷，嗯，如果没有任何线。

嗯，我想你什么都不用做，如果没有对的线条，所以也许只是个空房子，挺有意思的，因为通常我们有一个基本情况和一个递归情况，先写出基本情况，所以我想如果你想这么想的话，你可以说像，如果我找不到一条线。

这是基本情况，没有台词，如果没有台词，我们做什么都不对，否则，如果我没有得到一条线，递归案例，倒转文件或任何权利，所以如果你想有更标准的顺序，你们可能已经习惯了，好啦，让我们试一试，啊。

我必须取消对测试用例的注释，倒车线在哪里，那里，好啦，那么我们的，我们在这里，是呀，好啦，让我们做吧，所以运行它和嘿，它打印，玫瑰是红色的，紫罗兰是蓝色的，我所有的棒球，所以它起作用了。

但我是说这有点不令人满意，对呀，因为我们又作弊了，因为我不确定你们能不能处理好这个问题，我已经写好了，让我来解释一下我是如何编写这个函数的，哦哦该死，我刚刚调用了你的函数，力量一直在我们体内。

所以我的意思是这不是欺骗法，这是逆行，对吧，比如如何反转文件，类似于反转文件，嗯，如果我有一个神奇的功能可以逆转文件的其余部分，然后我称之为，然后做完之后，我可以打印文件末尾的第一行。

然后我就完成了所有的工作，神奇的功能就是我们的功能，我们正在编写的递归函数，嗯，我的意思是，你知道你也许你看到了我的愚蠢的笑话来了，但这是一种思维过程，你说得很好。

如果我有一个神奇的功能可以为我解决这个问题就好了，但是无论是谁写了这个神奇的功能，坚持让我做一点工作，然后他们会为我做剩下的，你知道，就像我能做的一点点，然后把剩下的交给这个神奇的更聪明的功能，嗯。

通常就是这样，你想在那里调用你自己的递归函数，所以不管怎样，你现在去吧，我们在这件事上什么都不做，把一个空的，如果我用这些评论猜，它有助于提高可读性，但我想我更愿意这样说，我宁愿说，如果GET线路成功。

然后我们有一个递归的情况，然后在这里，我会去L空间案例，没有台词什么都不像，我宁愿，我宁愿这里没有空房，因为它看起来很糟糕，但我想让你明白，就像递归的基本情况可能是隐式的，此代码没有显式地包含块，是啊。

是啊，当我们写我们自己的，类似作业的类似递归函数，你想让我们根据其他情况发表评论吗，没有台词，我喜欢这样的评论，我是说标题评论，当然要描述函数的作用，但我喜欢学生向我描述，这些不同的情况是什么。

为什么我在这里，这是什么意思，你知道的，我需要反转整个文件的其余部分并打印我的行，我喜欢这种评论，我认为这是一个很好的延伸，好吧关于那个的问题，所以我想知道，啊，在文件中获取行布尔值和调用EEF值，嗯。

EEF是在你读完之后，所以我的意思是，我想我可以在屏幕上说EF那就没问题了，我是说如果不对的人，所以欧菲会是真的，输入精灵将是真的，如果你上一次尝试阅读，如果你在文件的末尾，它就失败了。

我的意思是你也可以用eef编写这个代码，但不管怎样，你最终都需要得到一条线，或者试着得到一条线，所以我认为这是最简洁的表达方式，所以不管怎样，我大多避免EEF电话。

因为我认为在文件上循环更好的方法是调用getline，直到失败，我见过很多带有微妙bug的代码，这些bug称为eem，因为问题是，如果你叫一个读，它不会说Eef，直到你做了一条线，阅读失败。

所以你可以从一个，因为那个，反正。

关于这件事，我想指出一件事，递归实际上是一种很好的方法，因为我们学过数据结构，称为堆栈，上周的收藏，堆栈，我们了解到你可以把一堆东西清空成另一个东西，它会逆转它，递归函数的调用堆栈与，当这些电话回来时。

这就像一个堆栈的展开，数据结构，他们同名不是巧合，如果您试图想象不同的函数调用，这里有一个小图，所以我知道，如果你在下面看不懂，但那是输入文件，我们在看文件的开头，我们说，好啦，第一次呼叫开始。

让我们做如果得到线，上面写着玫瑰是红线，然后它进行递归调用，所以在输入文件中，它前进到第二行，然后我们打第二个电话，所以在第二行，蓝色的暴力，它推进了文件阅读器，然后我们打第三个电话。

现在我们读了我所有的基础，这是我们前进的第三行，我们要打第四个电话，现在我们读R属于你读第四行，现在我们击中了EO，现在EF将返回真，如果我们再叫一次，我们打第五个电话，第五次调用无法成功读取一行。

所以if语句不输入，所以第五个电话马上退出，第四个调用说我完成了递归调用，所以现在我将打印我的行，所以我属于你的台词出现在控制台上，现在呢，第四个电话回来了，它回到这里，他在等那个，所以现在他把他的线。

在我的基地里，他回到这里，他带着他的线，通孔是蓝色的，我不知道为什么它在闪烁，是linux什么的，但无论如何他回到这里，他印玫瑰是红色的，所以你得想想这些，就像小长方形堆栈，当你进行这些函数调用时。

事情会堆积起来，好啦，重要的是要记住，就像每一个电话，你知道它们堆积起来，每个都有自己的局部变量副本，一件微妙的事情，但也许你们只是想当然，是你知道，通常当您进行递归调用时，传递递归调用。

传递不同的参数n减一，把n除以2，打印二进制，无论什么权利，通常您传递的参数会缩小，在本例中，我们将相同的文件作为参数传递，参数相同右，但当然它也在缩小，因为留给读取的数据量正在减少。

所以当你通过引用传递某物时，所有的调用都共享相同的值，与每个调用都有该值的副本相反，所以如果这个调用读到一行，然后其他调用也将有更少的行留给他们阅读，这就是在这种情况下对参数的修改，好啦。

所以那是相反的线，让我们再做一个倒立的脸，随便啦，让我们写一个叫爬，你给一个文件名或目录名或其他什么，你用压痕打印它的内容，所以如果它只是一个文件，我说爬，你知道的，演讲幻灯片，点PPT。

你只要把文件的名字打印出来，但如果是一个目录，它将打印目录的名称，然后它会打印目录中的所有文件，当然啦，目录中可能有目录，里面可能有目录，里面可能有目录，所以有一种类似于这个的嵌套自结构，对呀。

所以我希望它的层次像这样缩进，其中每个子目录缩进四个空格，我觉得缩进的部分有点难，所以我想做最后一个，让我们写一个没有压痕的，所以好吧，现在要做到这一点，你可能会说很好，我不知道如何用C++做目录。

但我提前想到了，所以我给你写了张幻灯片，如果使用，您可以询问某物是目录还是文件，您可以列出目录的内容，这里有一堆不同的方法，我认为会是，会有用的，对呀，好啦，所以从概念的角度来看。

你认为这个函数的基本情况是什么，抓取一个普通文件有什么容易的，你要说，是啊，是啊，好啦，所以一个普通的文件。

好啦，我们走吧，我们去玩吧，我们去试试，所以我在这里爬行，所以我已经包括了上面的文件库，所以如果它是一个普通的文件，哦不，也许我没有包括文件库，没有，我没有，好啦，所以让我们做文件，好啦，如果是个文件。

那就把它打印出来，查看和文件名，我会找到所做的一切，好吧不然，所以实际上，那是你的基本情况，普通文件，然后我猜一个递归的情况，这是一个目录，嗯，如果是目录，我应该打印目录的所有内容。

嗯，如果您想使用我们的库从目录中获取内容，这里有一个函数叫做列表目录，你把名字传过去，文件名或目录名，然后是一个矢量，我想它要么返回一个矢量，或者它可以通过引用填充现有的向量。

我是这么想的，如果我说，我想那是真的那是真的，是啊，是啊，好啦，所以现在列出目录，通常当我做递归时，我说，啊，你不能用任何循环，你不能使用任何数据结构和所有这些东西来解决这个问题。

我允许你使用循环和结构，如果你现在喜欢，你可能会说，啊，你不让我打圈，一个按因子计算大的，卑鄙什么的好吧，但我想说的是，我想让你对这个问题中自相似的部分使用递归，我想让你用循环。

这些是问题中更多迭代的部分，你怎么知道自己相似的东西，嗯，也许我们会边走边想办法，但是循环是可以的，收藏没问题，所以我的意思是，我基本上想把这些文件打印出来，所以好吧，对于文件中的每个字符串文件。

让我们看看它是否有效，哎呦，我想我有它测试反向线，坚持住，让我上去，如果有一个应用程序，我可以自动化我写的代码的测试，只需查看背景中有绿色或红色结果的结果，我不知道这种事，那么它印的是什么，它打印。

一些文件名，自由消息来源，让我给你看看我们在这里操作的目录，我有一本叫第八讲的目录，还有文件，哇塞，看起来一切正常，我是说顺序不完全一样，我不知道点菜有什么用，但谁在乎呢，嗯，它没有做的一件事，不过。

它不会进入这些不同的目录和打印，里面有什么，对呀，我如何解决这个问题建议，关于递归爬行函数，我想指出的一点是，它没有任何递归，所以也许我们需要一些建议，是呀，我觉得那是另一个学生控制，所以你爬到哪里。

在for循环中的位置，好啦，是啊，是啊，所以实际上，而不仅仅是打印出来，我们爬吧，因为如果，如果这里的文件是一个简单的文件，反正它也会打印出来，和这个一样，但如果是一个目录，它会把它递归起来。

然后进入它的内部，然后说，嘿嘿，一步一个脚印，我听说继续努力，哎呀哎呀，它坠毁了，发生了什么事，那么这里出了什么问题，上面写着错误，等一下等一下，其他分行发生了什么事？一半的，是啊，是啊，嗯。

让我想想我做错了什么，啊，所以有一件事，嗯，让我想一想，我想有一件事我总是这么做，我以前做过这个例子，我总是犯同样的错误，也就是说，我总是忘记文件名是否附有目录，或者只是文件名，只是，你知道。

是食物文本吗，还是斜线，不管是什么斜线，不管是什么斜线，食品文本，这是不同的，所以我想我想要的是，我想要，就像，我想把这两件事分开，它坠毁前打印了什么，什么都没有，是啊，是啊，我想我想要的是看这个。

所以说，如果我，如果我把这个评论出来一秒钟，我只是打印，然后我想，我在这里看到的是，子文件没有附加文件夹，你知道我的意思，所以我想它坠毁了，因为我们找不到那些文件，因为我需要附加目录名，加上欺诈的削减。

有点，你知道的，所以我想我需要做，我想我需要做，斜杠加文件，你知道我的意思吗？

进入那个子文件，所以我认为它应该起作用，所以现在看起来很好，只是我不想把这些都打印出来，就像所有东西前面的标题，但我们可以回到那个，所以有几件事不对，一个是它打印这些像完整的路径，也许我不知道。

我需要完整的路径，比如找东西，但我不一定想把完整的路径打印出来，另一件事是我还没有那个压痕，所以我认为修复印刷的快速方法，完整文件与仅文件名，有一个函数叫做得到头和尾，头部是尾部的目录如下所示。

所以我想如果我只说打印文件名的get尾，然后我想它会印在那里，所以它现在打印了更多的输出，它进入了所有这些不同的目录，但我不做压痕，所以这就是我接下来想做的，是啊，是啊，目录的名称。

所以我们还需要一个CR，目录的名称，因为根据所有的好，好的好的，所以实际上，如果你看看这个预期的输出。

如果要打印目录，你还是应该打印它的名字。

但它的内容随之而来，你是对的，在我们的代码中，我们只打印内容，而不是实际的目录名，所以我想我们一直想把这个打印出来，无论发生什么，不管是目录还是普通文件，所以我想你可以把这个移到这里。

现在基本情况是空的，但是递归的情况是这样的，也许我们马上就能解决，但我觉得那看起来更像，我们有一个lib文件夹，里面有这个，是啊，是啊，好啦，这样看起来好一点，现在我们需要压痕，因为你不知道里面是什么。

如何做好压痕，这实际上是这个问题最棘手的部分，所以我想看看，就是嗯，你知道的，你可能会说很好，好啦，在我爬行之前，子文件，我应该打印一些压痕，所以让我们到这里去看看太空基地，基地之类的。

然后我们爬剩下的，让我们试试看，嗯哼，看起来很不错，好啦，啊，但它不是，我想要，像更多的压痕，我在这里的结构越深，有点，你知道我的意思。

让我们来讨论一下这个输出，让我们转到文本编辑器。

我有这些文件，在斯坦福内部，在收藏品里，我有，你也知道，所以这里有一个巢穴，我的输出中缺少的，我认为问题就像图片，一秒钟的递归，我喜欢这里，所以我走了，好啦，打印几个空格或返回选项卡或其他什么。

但是下一个递归调用将打印一系列行，你知道我的意思，不仅仅是我想打印一个注释，我希望所有这些台词之前都有一个邀请，你的感觉，所以只要在这里打印一次压痕，然后在这里做这个递归并不能完全切断它。

所以我需要把信息传递给下一个电话，我需要告诉它，您需要打印前面有这个压痕的线条，您需要打印所有这些行，前面有这个缩进，你对此有何评论，是啊，是啊，您可以有第二个参数。

这是在任何文件必须默认为零之前要创建的空格数，但每次你喜欢一个人，是啊，是啊，我想这是个好主意，这里有时是为了解决我们的递归问题，你得改变游戏，一点点，我让你写的函数是写这个爬行，它需要一个文件名。

但是如果我们添加了另一个参数，称为字符串缩进，你能做的就是，您可以传递在每行前面打印多少缩进，作为参数，当然我告诉过你写一个只接受这个参数的函数，所以如果你想让你需要的参数和我的兼容。

我想你说的只是传递一个没有缩进的默认值，但是如果你做一个递归调用，你传递的四个空格是注释，或者你在这里传递什么，再加四个空位，你明白的，因为那样的话，所以下一个是四个，加四八八，加四十二，我想让它增加。

当我走的时候，还有一个解决办法，我需要在这里，我从来没有在输出中使用缩进，我把它们传下去，但我需要把它包括在内，当我输出东西的时候，所以这意味着在我看到我的文件名之前，我看到了凹痕，然后文件的获取尾。

你看，所以现在，哎呀哎呀，把这个处理掉，是啊，是啊，我不想那样，那么另一个未定义的引用是什么，哦，所以实际上在我的标题那里，在原型的顶端，我需要说字符串缩进等于，然后这里我需要去掉默认值，是的，是的。

好啦，所以让我们现在试试，嘿看那个，我想它在那里起作用了，我们去看压痕，图形有这些，我有那些私人的有那些等等，所以现在我打印了注释，有一件事我没有说太多，那就是当我把字符串作为参数传递时。

有时我把它们作为常量字符串引用传递，您几乎总是可以将字符串交换为字符串引用，这是最微小的优化，省去了到处复制几个字符串，所以有时候当我有标题的时候，我会说常量字符串引用，但基本上这只是意味着传递字符串。

是啊，是啊，还有其他关于爬行的问题吗，是啊，是啊，所以总的来说，如果你如果你如果你有这个，如何像，是吗，好啦，只是总是通过，我认为通常情况下，您应该始终尝试忽略字符串引用，我唯一不这么做的时候。

如果我要在这里变异，我要改变它，那么它不变的事实意味着我不能改变它，所以我得再复印一份，然后再改，然后如果我已经复制了，我还不如不要通过不断的引用来传递它，但在许多情况下，这正是正确的做事方式，是呀。

问题，通过压痕会更有效率吗，作为一个告诉你应该输出的次数，是啊，是啊，当然我可以通过压痕，就像四个空间，然后缩进加4，我可以通过八个空间，我想我喜欢这个的原因是因为，我是说他们都很好。

但是这种方法比编写for循环来打印空格更容易，我想c+没有，也许有，但我不认为这是一个简单的方式说，给我这么多这个字符的副本作为字符串，你得喜欢润滑油，我只是不想再写一个循环来打印空格。

这对我来说不是什么代码，是的，是的，使用is目录函数不是更好吗，然后就有一个如果块，是啊，是啊，所以我想我会改变这个说，if是目录，那么它是一个递归的情况，然后我会在这里说，就像其他基本情况一样。

普通文件，别的什么都不做，或者别的什么，你知道的，是啊，是啊，那是同一辆车的更好版本，我只是有点喜欢快速射击通过很多这些，因为我只想多练习，让我们看看另一个，让我们看看另一个。

我们谈到了可选参数，我们已经爬过了，好啦，我想做这个吗，如果我有时间，我想回到这个，但是等一下，我想回来，我想做斐波那契，很快的，所以斐波那契数列是一个整数序列，其中每一个都是前两个的和。

前两个被定义为一，所以第五，一号和二号有价值一，三是一加一，五四是二加一五五是二加所以，可以肯定的是，前两个中的一些，对呀，你也知道，我不打算花很多时间谈论，斐波那契数列与斐波那契数列。

但它们在数学、生物和经济学中随处可见，还有各种疯狂的东西，它们是你在自然模式和其他东西中发现的非常常见的数字，到处都是，与此有关，像黄金比例，如果你画一个斐波那契大小的矩形螺旋，你得到这个很酷的图案。

你知道它描述了你可能遇到的许多日常物品的大小和形状，呃不管怎样，别说了，所以嗯，那么如何写好斐波那契函数，递归地编写似乎真的很容易。

对呀，所以让我去做我的项目，把它写出来，所以这里是int fib返回零，所以我的意思是，就像我说的前两个是一个，所以如果是第一个还是第二个，我想如果它小于或等于第二个斐波那契数，还一个，是前两个的总和。

所以这并不难，我只是为我们写的，n减去1的返回fib加上n减去2的fib，对呀，酷，那么效果好吗，让我们一探究竟，看看你怎么撒谎知道什么七英寸，所以我们就这么做吧，便便，其实等一下，我想这不会运行。

因为我得把这个改成Main，那我得换这个，不说什么语言，C加加，现在我运行这个，什么是Fib 7。

上面说十三对吗，七是十三，好啦，所以它基本上起作用了，这个的重点不是代码，不是算法本身，我想谈谈，你们两个好像有点担心，最后一课，那是。

你知道所有这些开销，做所有这些递归调用，这是一个函数进行多次递归调用的例子。

请看，使您所做的每个调用都使另外两个递归调用，有多少电话。

如果你计算出6的fib，计算出这张丑陋照片的抱歉，但就像它的意思是计算5的fib和4的fib，所以四位数的谎言需要计算，四和三的Fib，三位数需要计算圆周率，所以他们都要计算之前的，事实上。

我甚至可能把图表搞砸了，打了这么多电话，但不管怎样，它有点像一棵一分为二的叫声树，每次，对所以好吧，就像，也许那不是世界末日，我不知道，不是很多人要求撒六个谎，如果是50的谎言什么的，可能会很多，对呀。

但特别令人担忧的是，有些电话和其他电话是一样的，对呀，就像这里，作为计算的一部分，我得先问一下，所以我做了所有这些工作，我最终知道了答案，然后我在这里之前再打一次电话，所以我重新计算了所有这些调用。

得出了4K的谎言，你们不喜欢这些额外的费用，我知道你星期一问过我，所以这是不幸的，它浪费了所有的计算现在，我要说的是即使它要打这么多电话，没那么慢，对于实际大小的整数，你可能想要一个小的。

我实际上我打电话给我的第五个，我们已经写了十万遍了，花了四秒钟，所以很喜欢经营它，测量一个缓慢的时间，不过，好吧，就花了这么多时间，嗯，那么我们怎么把这口井修好呢，我是说，当然，这里的关键观察是。

我们已经计算过了，所以我们不需要再计算了，如果我们能记得我们计算对了，所以有一个聪明的把戏，那叫记忆，我第一次听到这个词，我以为这就像一个有语言障碍的人，就像牧师和公主，新娘，就像没有记忆一样。

为什么我们今天，你知道的，但那实际上是“融化”这个词，这不是打字，呃，这基本上就是你缓存的地方，前面一个叫做速度计算的函数的结果，所以你可以重复使用它，好啦，所以这里有一个非常粗略的伪代码。

你怎么做记忆，创建某种缓存或数据结构，向量，一张地图，一些可以储存结果的东西，除非你和你写的函数，你说，我以前用弧线计算过f吗，如果我在我的现金里查了一下，并返回答案，否则实际计算它，放到缓存里以后用。

作为回报，这很简单。

好吧如果你想用，你可以使用不同的结构，我觉得，因为我们在计算斐波纳契数，你需要能够说，我以前用斐波那契数算过这个吗，有很多不同的收藏你可以使用，我喜欢用地图来展示，尽管您可以使用数组或向量。

因为我们在这里操作的是自然数和整数的定义域，但我喜欢说，让我们用地图点h，或者哈希图也可以，让我们做哈希图，哈希图，那么我会说int逗号int缓存的哈希映射，所以你就画了一张地图，现在在这里，你说得好。

前两个很容易，我不需要把它们藏起来，那些很好，然后这里，我想记住那个结果，这样我就不用再计算了，所以我会说缓存放置结果，还是我猜啊，关键是N对，我想有一天抬头，你有N的结果吗是的，就在这里，然后我说。

现在我们唯一缺少的是，我们把东西藏在储藏室里，但我们不会用缓存里的任何东西，所以你把它插在这里，在你做任何递归之前，你说，否则，返回缓存进入或现金括号n右，基本上就是这样。

我唯一不喜欢这个解决方案的地方是我有这个，这里有个全局变量，你知道我们应该讨厌全局变量，他们很坏，他们是邪恶的，不要用它们，在C++中有一个可爱的小黑客，在其中可以声明变量，对函数来说是全局的。

它被称为静态变量，所以如果你把这个移到这里，你说静态哈希映射现金，这是一个奇怪的句法，但基本上它的作用是，它不会创建新的地图，每次调用这个函数，它创造了一个，你第一次调用函数，现在它只对那个函数可见。

所以它有时被称为函数，私有数据Java没有这个，但不管怎样，如果你把地图放在这里，它将不再是全球性的，但功能完成后它会留下来，下次调用函数时，它还会在这里，地图还是一样的，挺酷的，是啊，是啊。

它对函数是全局的吗，不管是什么范围，如果你把它写进声明里，哦，你能把它，你放了一个那个，我不知道我该怎么对你说实话，我不记得你能不能把这些东西像礼物一样放进去，然后他就住在那个GIF里什么的。

我只在一个活动开始时见过它，如果你把它放在函数之外，它仍然是一个全局变量，但现在它只对该文件是全局的，和其他试图与该变量对话的文件，看不见，但它仍然是一个全局变量，所以不要这么做，但是嗯。

所以我的意思是，坦率地说，我不知道语法的所有来龙去脉，我很乐意稍后帮你谷歌一下，如果你想，但我不知道，我知道你可以把它放在这里，而且管用，作为参考，呃，我们做了十万次这种方法，花了大约四秒钟。

所以我会用同样的运行次数再运行一次，但现在我们有了我们的记忆，现在需要13毫秒，所以它做的计算要少得多，电话树不再以同样的方式分裂了，是啊，是啊，等等对不起，再说一遍，这就像你第一次运行它，就像小玩意。

就像未来的每一次，只是它移动了返回的时间，是啊，是啊，我想如果你真的想追踪这里的递归，实际上这可能会很好，我想在这之后我还可以做一件事，但如果你想追溯这个的结果，这将抓住谎言三的结果，如果你说七号谎。

这将会引起第三到第七，因为七的谎言电话也到了这里，六五四三，当你数到三，我们将把三个结果，四个结果，所有这些电话都会这样做，事实上，在我的意思是，我可以看到外面，现金和所有，如果你喜欢。

缓存3个然后4个然后5个然后6个然后7个，我想它以后会做其他五个数字，但是是的，它是以那种方式建造它们的，因为那些电话，你知道在顺序问题中彼此的堆栈，是的，最初的功能是没有捕捉。

或者它确实有指数级的运行时，是啊，是啊，因为每通电话都会多打两个电话，所以它大约是总调用数的2到n的数量级，是啊，是啊，这是不好的，指数运行时不好，看看我给你的图表，它就像已知宇宙的大小。

你必须等待大值，是啊，是啊，我想我们很多人，呃，很多问题，我想我们看到的大部分加速是对的，不是从一个叫，我们做了很多这样的计算，就像这样，我们第一次打电话就加快了速度，我们要进去一千次。

其他的九九九九只是一个罐头，我们做一个单曲，是啊，是啊，你是你是对的就像这样，问题是，如果我叫它一次，我抓不住时间，所以我能做的就是，我可以说像，你知道int等于从1到40的随机整数。

我可能会尝试不同的Fib值或类似的东西，还是挺快的不，但是这里有两种速度，我认为重要的是要注意到他们两个，他们都很有趣，一种加速是，如果我以后再单独调用n的fib，我就不用再计算了。

或者任何直到n的东西，对呀，那很酷，另一件事是在Fib n的单一计算中，我不必让那棵树的第二部分，所以它加快了这两件事的速度，这两件事都是有价值的，实际上，您可以使用缓存和记忆，即使您不在递归上下文中。

您可能有一个非常昂贵的功能来抓取您的文件，搜索结果并以某种方式捕获，这甚至不一定是递归的，但你把它存起来，以防你再次需要它，所以记忆也在递归之外，这个是什么运行时，是啊，是啊，嗯，如果你在缓存中。

我是说一般情况下，很难稍微谈论运行时，我会说，但我相信如果不是现金，你有一个电话的结束号码，对，如果你有现金，你有一个恒定的时间，所以无论如何，好啦，我想我需要停下来，不能因为我们没时间了，但是嘿。

去科练习，更多递归，我们星期五会做更多这样的事情。

我们将学习分形，真的很好玩。