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

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

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P14：【Lecture 14】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

好吧，所以我知道你们正在考虑卡在，期中练习的问题，你想问一下，你可以随意做，这是让您的问题得到解答的好方法，我们今天也有办公时间，明天等等，现在我们正在做什么，我希望本周你们会专注于期中学习。

并且大多数，这周我们的期中是星期四，因为我们恨您，您知道我的意思是人们想为此努力，但我会，通常不希望您开始考试，直到完成考试为止，预定在下周中旬进行，因此您可以完全专注于考试，现在完成考试。

那么您已经完成了所有考试，嘿，如果那不是，足以让您度过一个漫长的一天，所以我知道我认为您将有时间集中精力，您可以在网页的“考试”部分发布的每笔现金上查看，当你准备用讲座的方式看的时候，我基本上。

认为期中涵盖了直到上周五，然后开始，今天，我将不会从这些讲座中对这些东西进行明确的测试，在这里进行期中考试，所以我想这可能会导致您调音或离开或，随便什么，但您仍然需要学习，所以这是计划，这是计划。

保佑你好，所以无论如何我们今天要做的是我们一直在学习，有关链表的很多信息，我们上周一也了解到了如何实施，使用数组进行收集，我们制作了一个称为数组栈的收集，我想要，今天再次回顾所有这些东西今天的主题将是。

讨论如何将集合作为类与数组一起实现，以及链接列表，这也将成为您第五个主题。

功课分配，下周要交，好吧，走吧，到我们的幻灯片，还记得上周一，我们写了一个名为数组的类，数组事件的内部结构，但是在外部，该类是，将自身显示为堆栈，如果将元素压入堆栈，它将添加，他们到他们的方式的结尾。

所以我们在大小和，容量，即阵列的总长度，是的，我想回到，该类并在其中添加一些功能，但实际上并不是如何链接的，列表通常由客户端在其上使用，因此样式略有不同，比我们一直在做的事情，所以我要谈谈您将如何改变。

我们的代码将包含在这些内容中，所以这是目前的计划，让我们回到。

那个数组栈让我随便打开那个代码，我有一个可爱的创建者，项目的主代码可以说这样的事情，你知道做一个数组堆栈，而且您知道通过调用push添加一些元素，然后再推动薄荷糖，然后，打印堆栈的两个字符串。

所以我们编写的代码将是，小字体，您可以将东西压入堆栈，然后您会看到堆栈。

更大一点，这样就不会太令人震惊底部在左侧，顶部在，在右边，然后当您将事物从堆栈中弹出或窥视它们时，它将为您提供堆栈中的最后一个元素或顶部元素，上周我们写的内容好吧，所以让我们了解一下其他一些事情。

我可以谈谈您可能已经看到的“ Const”一词吗，偶尔在作业或入门代码或讲座代码中，还没真正谈论过它，Const只是意味着不断地，无法在Java中更改，有一个名为final的关键字具有相同的名称。

意思是JavaScript，如果您学习过Python，我认为它有一个Const关键字Python ，没有任何常量的概念，但是无论如何大多数语言都有一个，在这里您可以说这个值没有改变，所以有几个。

您可以使用不同的利弊方式来声明声明，变量或参数（如第一个示例），如果您传递某些内容，这是恒定的，意味着您现在不需要使用该呼叫就无法更改它，常量，您传递的是像int这样的简单内容，因为如果。

您更改它或类似的东西现在应该认为其中一些方法，修改向量修改网格，但是其中一些不是，如果方法，不会修改它，最好将其声明为，不断之所以这样做的好原因是因为它告诉所有人，看着像这种方法的代码不会改变这件事。

如果你，声明一些自信的功能，食物会尝试改变食物的状态，反对它不会被编译，所以如果银行帐户类有存款，更改帐户余额的方法，不允许您调用， foo函数内部的deposit方法，很酷，它有助于捕获。

您可能无意间修改对象的潜在错误，这很酷，还有另一个上下文，您可以在其中使用const这个词， ，如果您正在编写一个类，则可以声明您的方法之一是， const方法，这意味着您说的是这种方法，我保证。

你叫我这种方法，如果我是银行，我不会改变自己的状态，您拨打的帐户让我保持平衡，不会改变任何帐户，内部状态，它将保持不变，可以使用const are一词，相关，因为第一个只允许您从第二个调用方法，例如。

如果您这次有一个参数，它将仅允许您调用方法，被宣布为花费，所以当您，编写一个类来查看您的所有方法并找出哪些方法不。

更改对象状态并在其末尾写上constat一词，如果您，看一下我们写的数组栈，这里有一个名为数组栈H的文件，有一个push方法，有一个pop方法，有一个peek方法，是空的，并且。

这些方法中哪些是轮廓线应为常量，为什么峰顶正确，您不能将Const推入或弹出，原因是整个，关键是我认为其他任何人都可以修改堆栈的状态，空字符串和两串字符串也是，你知道你可以直叫两个。

一百倍它现在不会修改堆栈中的内容，您声明您的方法，这是在点H文件数组堆栈点中，如果您，声明您的方法为const，那么您还必须转到点CPP文件，而且您必须在此处使用相同的方法，并且必须将Const 。

在那里，如果您忘记了一个地方或另一个地方，那么您会变得很可爱，关于未为体系结构x86定义的符号的错误下划线六四和，那么您会对此感到困惑和困惑，所以无论如何，如果您添加。

您的方法实际上并没有做任何对客户端可见的操作，但是，做到这一点的好习惯，您也知道它可以避免像，如果我说void foo array stack reference stack，这就像是堆栈客户端。

如果我试着说堆栈推入42，那么你知道定律不是恒定不变的，那么，应该给我一个错误提示，这不是因为我需要重建，项目，我需要清理并重建它，因为如果您将方法更改为，在概念上并不总是会立即注意到哦，不，等等。

对不起，我，愚蠢的，它应该反对的原因，也就是说，如果您要在这里说“ Const”，那么它就不想让您修改，堆栈，这就是为什么它不抱怨我期望编译器的原因，这样就完成了，无论如何您都不能调用push。

因为参数是，声明为Const哦，我想我看到了，那里的错误有点儿Spalla ，触发任何仅意味着您无法在Const堆栈上调用该方法的事件，如果我要删除Const，则代码可以编译，但是现在不行，但相比之下。

我可以称呼堆栈点为窥视点，我可以称呼堆栈点为空，这样编译就可以了，所以如果我要你写一个类，可能会说我希望您使方法Const适当，这意味着，不要修改对象的状态，在方法的末尾添加“ Const”一词。

头好吧，这是Const对Const的疑问。

所以是的，D需要做些什么修改，所以当我们写一个，上课有两个方面，就像您写上课，然后还有使用该类的客户端代码，有时您同时编写，这些代码段有时是由不同的人编写的，例如，斯坦福图书馆，我们编写了向量H。

您正在使用向量H作为客户端，因此，问我需要进行哪些修改，这取决于您是客户还是，类的作者，或者两者兼有（如果您是该类的作者） ，如果您是班级的客户，您可能会选择这样做，但是。

这更多地取决于您的客户端程序以及您的程序在做什么，如果我使用的堆栈没有修改的方式，我可能想说，继续前进，好吧，我只是在进行调查，向您展示一些，相关类的其他功能，如果这还没有说Const on是空的。

那么这里也不是然后，在这里，如果我尝试调用它，即使我们可以看一下它也不应该编译，尾声，我们可以看到它为空不会修改对象的状态，该方法没有说Const，编译器不信任我们，它不会，编译代码。

以便我将其放回原处，是的，不是那么重要，您修改的内容是您是否说自己已修改，然后当然，康斯特说我们想要躺在这里的样子，我们试着做像尺寸加号或加号或。 。

一些不起作用的东西或者它不会让我们这样你就不能说Const和，然后撒谎吧，好吧，让我们覆盖其他一些东西，这是一个有趣的。

C ++功能称为运算符重载，这是最酷的或，最糟糕的功能，取决于您是哪种类型的操作员，重载是为的内置运算符重新定义或添加含义。 ，这样的语言，就像您可以定义加运算符在。

你的班级就像我不知道你以前是否注意到过，一个向量，您可以在其上使用+等于等号。

还没有谈论太多，但是像这里，如果我包含向量点H 。

向量点H，如果我做一个向量，我就走了，就像你知道字符串V和，你通常会说，像VI Pad，你知道Marty，你确实很喜欢，但是，你也可以写V加等于马蒂这很奇怪，它可以让你做到，编译运行，其行为与广告相同。

因此其工作原理类似于，我正在使用一个向量和一个像Java这样的语言的字符串来做，任何在C ++中会导致编译器错误的感觉都可以做到，操作符重载，您基本上可以告诉编译器嘿，如果您使用。

具有这些数据类型的运算符这是您应该做的，那应该变成操作员超载， ，所以您基本上是写一个描述运算符的函数，但是，该功能的名称是土地运营商加号或运营商时间或运营商，等于或什么是运算符，后跟实际。

运算符的字符，然后您有参数，然后填写正文，这样看来，您可以使用此功能执行各种奇怪的操作，我个人认为这是一个坏功能，因为它使它像其他任何人一样，任何给定运算符的给定语句都可以做一些随机的事情。

他们超载这样做，我认为这很危险，但是，他们说的语言，如果意思是仅应重载运算符，很明显，例如，如果您要带两个银行帐户，然后执行，它们之间的减号运算符并没有任何意义，知道所以不要这样做。

但是运算符的真正普遍用途是使，可打印的对象，所以有一个操作员，您可以重载以立即执行此操作，看一下我们的数组堆栈，如果您有一个，数组堆栈，您想查看其中的内容，我们将此方法称为，正确的字符串，好吧。

如果我只是将C写出来，那该怎么办，向量就是您可以对地图执行的操作，就可以说C ，把我的矢量打印出来，您知道它实际上不允许您这样做，因为， C ++不知道如何打印数组成员，您可能会说不错，但这是，很明显。

您可以通过很好地调用字符串来打印它，C ++无法理解，那就是您要打印堆栈的方法，因此必须告诉C ++ ，如何打印东西是您实际上超载了小于小于，运算符，因此看起来像这样。

您编写了一个称为operator less的运算符，少于参数，这有点令人困惑，它需要输出，流引用哦，输出流就像C out或文件out的流，都是后期流对象，它也需要您打印的值，那是两个。

所以基本上你只需要打印，东西到那条街，然后您还必须返回输出流，您必须返回输出流的原因是可以将它们链接在一起，比折线少，比折线少，这有点微妙，但看起来，这是您必须用来编写此运算符的样式，这是确切的。

设置它必须具有的属性，以便使阵列堆栈可打印。

今天很多人咳嗽和打喷嚏，我希望每个人都，感觉很好，不知道下课后会抱抱，我不会跟我抱抱，彼此了解并不意味着要让您的对象可打印，您要做的就是，下来这里，这是数组堆栈中的点H，您下来到。

班级下方的班级实际上不在班级内部，你说哦，流引用运算符越来越少了，我将调用的流引用，它需要一个称为，堆栈，所以您说的是声明我将为实现此重载，使用此运算符时，您总是在带有分号的H文件中声明内容。

然后在数组堆栈cpp中的某个地方，您编写了相同的运算符，但是，花括号，然后您实际上写了如何做的正文，所以您如何做，好吧，假装您正在打印纸叠，您将如何打印纸叠，好吧，我是说在客户那里。

我们说你知道看堆栈讨论，紧张吧，所以你就这样做，这样你就可以过来看看，堆叠点到字符串插入有一些错误，几乎就是您只包括如何打印东西的代码的想法，但是，这有两件事是错误的，你不应该，包括endl。

因为打印零食的人可能不想要， endl您应该让他们决定是否应该打印endles，所以我要，删除该部分，您应该更改的另一部分是此运算符可以是，用于打印C，它可以用于打印两个文件和任何其他类型的，输出流。

所以实际上这个叫出来的参数就是你要，打印东西到所以你只要说出来就意味着这里有这个参数，无论输出流是什么，您正在打印我以将我发送到字符串，到那个流，所以你现在编译这个。

原始的东西不支持仅在此处调用带有堆栈的打印，但是，现在我编译了，哦，等等，我遇到一个错误，说我什么也没退，所以在将输出堆栈打印为字符串后返回此处，必须说return ，输出返回。

返回与传递给您的输出流相同的输出流，这始终是您要做的，基本上每个操作员都会越来越少，大概是这样，通常对我来说只是次要的代码，回到主程序，现在它编译它允许我打印，像这样的堆栈，我打印它。

并在打印它的地方得到相同的输出，如果您不相信它，因为输出没有改变，现在就这样堆叠，我会，试图说服你，所以首先我要删除所有说，字符串，所以它应该在这里在主要客户中致电我们的运营商，但我，也要去数组栈。

我要改成Booya ，这样的事情发生了，所以我要在上面放一些愚蠢的东西，字符串的两边，然后在我运行它时将打印这些消息，因此，基本上，这是无论如何都将其打印到输出流，它调用了我们编写的运算符。

这就是制作对象的方法，我不会花很多时间在上面，但是我的意思是，诸如您如何在Java中使某些内容可打印之类的语言，您知道哪种方法，你要写吗，祝福你，好的system。out。

print留置权是您打印内容的方式，但是如果您说Print lien ，而您传递的是银行帐户类型的对象，通常只打印某种，乱码的制作方法，以便在银行帐户上打印留置权，一些有意义的事情。

您必须在银行帐户课程中写些什么？ ，是的，流结束了，你要对先生说，对不起，嗯， ，字符串方法，实际上这是我们写的字符串，如果您刚刚写过， Java将自动知道如何打印C ++类型的对象，如果您。

想要使事情变得重要，实际上你甚至不需要写这个，必须编写一个to字符串方法来字符串它不是C ++中的特殊方法，所以我们拥有它的事实仅仅是因为我认为那可能会更多，你们很熟悉，因为你们很多人都来自Java。

但是这种方法不是，特别好，所以我要请您在上面写这些运算符之一，作业5因此，这种通用语法对您来说还可以，我的意思是，看起来很奇怪，但基本上可以复制并粘贴，从而将比赛恢复为您的类型，然后做与此等价的事情。

或者其他任何事情，你都会好起来的，问题，好的，这就是使对象可打印的方法，让我们看看下一步是什么。

我要在这里跳一点好吧，我想谈一谈。

称为析构函数或析构函数与您所知道的构造函数相反，构造函数的作用是当对象正在运行时运行的代码，创建它是天生的析构函数是当对象死亡时运行的代码，该对象超出范围，如果您编写该对象，则该对象将被清除。

此特殊方法的名称是波浪号，后跟您的类的名称，然后它将在您的对象上运行该方法，因为您的对象正在被删除，就在删除之前，为什么要写这样的东西，好吧，您曾经想这样做的主要原因是，如果您上课。

使用new分配内存使用new单词分配指针内存，然后，记住在C ++中如何不会自动清除这种内存，如果您希望清理内存，则必须自己清理内存，说出删除一词，所以这是您要删除的地方，因此。

让我向您展示该示例的数组栈，如果我转到。

当我们创建阵列堆栈时，在此处擦除DAC点CPP，我们制作了一个新的， 10这是当前新程序的写入方式，擦除DAC具有存储器，如果您创建堆栈然后将其清除，则会泄漏这些租户，在内存中。

并且在程序测验之前不能再使用，因此，不好，我很难向你们证明我要做的是，运行一个循环，因为10s内存不足，所以我必须运行一个，循环产生了一百万个堆栈，您必须看到内存使用率上升，我不会花时间去做。

我希望你带我过去，天线上的文字并不是世界上最糟糕的东西，但是，如果您的程序运行了几天又几天，那将是一个问题，因此我们，需要清理此内存，以便您将其存储在H文件中，堆栈点H，您来到这里，然后编写一个与。

构造函数，但带有波浪号，所以这是一个析构函数，好的，现在在点CPP文件中，实现方式是，类名，前面的冒号和其他成员一样，现在在这里实现主体，您只需编写要运行的代码即可，堆栈被破坏了。

所以一分钟我什么都不会放，这就是我要做的，我只做C语言，D结构体就可以了， indle，但让我们看看它是否可以正常打印，所以如果我运行，程序，我们将看到它像往常一样打印所有正常输出，但随后会调用。

它说析构函数被调用了，所以我不认为这很有用，我的意思是，我想它告诉您这件事已经解决了，但我还不太清楚，不要以为这完全说明了这里发生的事情，所以让我尝试，让它更清晰一点，如果我去客户端程序栈客户端所有。

堆栈中包含的代码位于右侧，因此让我们更换教练，稍微让我抓取这段代码，然后让我制作一个称为void example的新方法，我会把这段代码放在这里好吧，只需将其从main粘贴到，这另一个功能。

我要有主要的，我要放一些印刷声明，这里C out main可以开始，然后我要说main end我也要，对于另一种方法，我要说的是示例开始，示例结束，好吧，只想看看此程序示例中发生的事情的流程，示例。

所以我想我的意思是在示例中创建了该堆栈，函数应该在示例末尾清理并销毁，功能，所以如果我现在运行程序，主要开始主要结束我没有怎么称呼它，他们应该让我参加自己的期中考试，如果我不能达到至少50岁，他们。

应该把我从这里赶走，不是吗，哦，是的，谢谢我，感谢您的帮助，我不记得要调用我的函数了，好吧，我们得到了什么，在顶部，我们得到了缅因州，然后是主要电话示例，开始了，打印有关堆栈的一堆输出。

然后说示例结束析构函数为，之所以调用，是因为我们要退出示例，而后我们要清理堆栈，因此，当我们退出示例函数时，它将对堆栈进行d-结构化，那已经超出范围了，所以看起来我们还没有完成，因为。

析构函数不仅应该打印一些东西，而且应该清理它，内存应该清理我们在这里分配的内存，以便您，基本上只需要说删除元素是唯一的记忆，我们需要清理的空间我们也有一些学生要求的尺寸和容量，但是我也不需要删除它们。

也只需要删除那些，表示新的，如果您不使用新的，编译器将自动管理，给您的记忆就是全部，这就是为什么我们直到现在才使用new ，但是我们确实使用了new的数组，如果您在，删除一个数组，你必须说删除括号残骸。

是的，它需要知道，你要删除一个数组，其他任何东西都不是一个数组，你只是说删除，抱歉，这是完整语法的微妙之处，析构函数的实现还有其他新的指针，内存，我们也肯定删除了这些，所以您认为您拥有什么。

关于析构函数的问题，它应该做什么？ ，关于这个问题，是的，抱歉，因为不规则，是的，因为数组是唯一的东西， “ new”表示这是我们唯一需要明确清理new和，删除正在尝试对，您几乎应该每个都有一个新。

删除您不是我的意思是，如果您知道如果不这样做则需要删除，它不需要删除它意味着我要管理我想要的，照顾这种记忆及其寿命，这也意味着当生活转瞬即逝后，我会自我清理，删除其他任何问题。

好吧，让我们继续前进，我想谈一谈，一个链表的类，我们一直在为一个堆栈我玩这个类，只是想在谈论关于两件事的权利，类概念，我说的是使用RIC的出色实施许可证，所以现在我想使用功能来实现一个集合，不。

它是一个指针，接下来的数据和循环电流消除了我们所做的很多事情，东西，但是我们写的方式就是我，会称为过程样式，所有这些只是一堆函数，链接列表的前指针作为参数，所以如果您不记得那些。

函数，我只是先打开我们处理过的文件，然后再将其作为来自，上周五，上周，所以我们让一个代码客户端实际上让我设置，因为我要运行这个，所以我要把它改成像主栈一样，所以我不会运行那个，我要回到这个链表文件。

这是，我们之前编写的代码，因此我们编写了所有这些方法，请记住所有这些，函数，它们都将列表的开头作为参数，然后在main中，我要把它改成main，现在你说好吧，让我们做一个，这是最前面的列表。

您可以向其中添加内容，然后可以打印它，并且可以，最后首先添加您可以知道我们从main调用了这些函数，好的，现在我不喜欢这段代码，这不是您通常的方式，做到这一点，我用这种方式做到了。

因为我们只是在学习这是，我可以向您展示此最简单的方法，以尝试清除任何不需要的概念，所以我们可以专注于指针和链接列表的内容，因为，很难，但实际上，如果您要使用链接列表，则不需要处理，所有这些指针，星号。

new和null以及所有这些东西，想和一个友好的对象交谈，这种感觉可以为您完成所有工作，看看什么是对象，实际上是数据与行为的结合，变量与函数结合在一起，其数据和行为就是，一个对象就是有用的对象。

所以当涉及到一个，收集到链表时，您可以查看我们的数据，存储在这些节点中以及我们用来处理注释的函数中，让我们，只是把巧克力和花生酱浸在一起就可以了，有更好的东西，我们必须有一个链表类，而我们没有。

必须传递front front front front front front front作为所有参数，这些功能反而在节拍的最前线如果我删除了该怎么办，所有这些函数的参数或前端，我的代码将如何知道。

链表的最前面是，链表类中的私有变量将跟踪，前面，它将具有您可以调用的所有这些功能，这些功能将开始，在那边，这就是我们要做的，而不是这种风格，我要，创建一个名为链接的int列表点CPP的文件。

我不会从头开始，因为输入很多，但我们会逐步介绍它的某些部分，所以，您将创建一个名为oops的课程，我要在哪里存档，我该怎么做，好的，我在那里有H档，所以您将，所有这些基本都相同的称为链接到列表的类。

我们在另一个文件中拥有的功能，但是它们并没有处于前台， front front作为参数，否则采用相同的参数，但没有前面，前面在哪里这里在前面，你刚才说的私人人物就是私人人物，成员变量，例如。

如果您要为列表编写构造函数， ，构造函数初始化类的私有数据的初始状态是什么，首次创建列表时，我想我想问的是，当他链接到列表时，应该把前台设置为什么，正在创建，您真的觉得我今天要联系您，我们真的点击了。

连接起来就像一个大团体的拥抱，但没有任何法律上的含义，第一次创建链接列表对象时有什么不同？ ，认为应该知道，因为没有元素，但是没有数据，所以，在这个构造函数中应该知道前面，我将初始化前端以进行了解。

但是当您添加内容时，请看一下，添加代码与我们编写的添加到代码背面的代码相同，列出如果前面通过新的否，我们编写此代码，这就是为什么我不编写它的原因，现在和您一起我们已经写过，唯一的不同是我更改了标题。

说链表添加而不是只是空添加，我删除了参数， front因为整个文件都知道front是私人成员，变量，所有这些函数的样式都相同，有趣的区别是，在我们不得不思考之前编写的代码中。

关于这种类似对指针业务的引用，您知道，如果我们，修改列表，我们必须将引用传递给有趣的指针，这种新样式的问题是，如果我们，这样做是因为您始终可以直接访问该地址，指针，如果您需要更改它，就可以了。

所以我不必担心，以这种特殊的编码方式引用指针，例如，会采取诸如add front之类的方法，而我想将其移至，进入我们已经编写的代码，我想我们称其为“首先添加” ，在这里，但是我只需要这个确切的代码。

然后我就复制并，粘贴到上面，它就可以工作了，因为这个东西叫做front and ，这与以前调用参数front的名称相同，所以我不会，基本上必须修改代码，所以我不会坐在这里复制和。

粘贴并复制粘贴粘贴并复制粘贴，需要做大量的工作就像写这个，该点H文件的标题，具有我们需要的所有功能，然后遍历，并通过粘贴上周我们编写的代码填充它们，我在这里没有的一件事哦，我想我是，嗯。

应该使用哪种方法， const，就像问列表是否为空，要求的成本列表的大小，但添加删除等那些，事情不好，所以要看整个问题的原因是，想要转换为这种样式，您可能会说这样做有什么好处，这样做似乎是一堆东西。

我不喜欢把它们放在一起，是巧克力和花生酱马蒂，但这就像西兰花和咸菜我，无论我不知道都不喜欢，请选择您喜欢的两种不良食物，例如，你为什么要结合我，我不喜欢类很奇怪的语法，我，不喜欢此指针链接列表的内容。

或者您​​为什么要使用所有这些内容，我讨厌我把所有东西都很好地组合在一起，这样的版本，其中链接列表是一个类，使用起来更容易，一个客户，所以我将所有我们不得不认真思考的链接列表捆绑在一起。

关于添加前端和指针以及对指针的引用等，循环遍历链接列表和null，所有这些我都将其捆绑在这里，这个课，然后客户不必考虑任何，客户端代码看起来像如果有的话，它看起来更像，在您说链接到列表后。

我的列表在负数3处添加42在最前面，此打印点的大小如果更清洁好得多，则删除前室，使用此功能的人不必对指针一无所知，全屏上的星星，您看到这个实施课程的人吗，必须了解指针而不是客户，所以这就是我曾经的好处。

我的导师斯图尔特·里吉斯（Stewart Regis）听到了一个比喻，他说链表节点是，就像小油漆罐，您知道您正在粉刷房屋或建筑物，或者，任何和链接列表对象，该类就像一幅画，陪伴您的承包商。

或者如果您想让自己的承包商成为什么样的人，房子涂上油漆，你不想被所有南瓜捡走，油漆罐自己，您只想与油漆公司交谈，他可以吗，让我的房子保持蓝色，他们会照顾好他们所有的粉红色，手和手指在哪里涂多少罐油漆。

需要他们处理所有细微的细节，而我们没有，作为客户，我知道你们很欣赏，因为那是，您每次使用向量或地图时都会做的事，或堆栈或多维数据集，其中许多集合都有指针和节点，并且，狗屎在里面里面，你必须完全考虑一下。

这是整个类的重点，是要屏蔽该类的客户端，从如何实现类的行为的细节开始，所以今天我们，在这之后有一个链表类，最前面是它的私有数据，我在这里没有做的事情是我没有谈论过是否要写一篇，链表的析构函数。

您应该释放所有内存，以便，您认为我需要释放什么内存，如果需要，我是否需要释放任何内存，那是什么内存，我该如何释放它，你认为。

所有的指针，所有的节点，我都有这个节点链，我有三个， ，在这里，我必须释放所有这三个节点，所以让我告诉你一些事情，那将是不够的一件事将是不够的。

说哦，我必须清空列表，好吧，前面的磨牙等于，清空列表的等价内容，但这并不能满足。

释放所有这些节点的析构函数。

另一件事是不够的，那就是说不，那不是，他想从线索中删除他是如何释放内存的地方，这个更好，但是这个相同的删除前面怎么了，是的。

转到指针指向的对象，并释放该对象的，内存有什么问题，它不会删除所有剩余的面团，没有像层叠一样，自动在这里，因为这是前面一周的时间，事情并不意味着它就在那里，您知道Domino的所有其他产品。

删除它们-我不需要写遍历列表删除的循环，每个节点都可以真正清理它，而我不会写正确的代码。

现在，因为我要您编写该代码，但这就是您需要做的事情，所以我想我想这不是假想的东西，作业5的人将集合作为类实施，其中一些有所提高，用于数据，其中一些具有用于数据的节点，因此您必须，基本上是做这种事情。

所以我想回答您可能遇到的任何问题，关于这样做是的，哦，您如何实现每个循环，是的，所以对于初学者来说，我现在不能在这里使用它，如果您想要的话，它将无法使用，为每个循环实施它，您必须了解一种称为，迭代器。

如果您好奇的话，我会为C ++ STL进行Google迭代器，有点太复杂了，我今天不想向您展示，您必须添加其他方法，如果您拥有这些方法，C ++将注意到并，它将允许您在代码上进行每个循环。

基本上您必须解释一下， C ++如何遍历集合的内容，而不是，非常辛苦，但是要花比我今天更多的时间谈论是的，你能，在结构中有一个析构函数，是的，你可以，如果结构体内部有指针字段，但通常我们不这样做。

通常结构通常很小，即使是像列表节点这样的结构，不喜欢你能想象一个列表节点的析构函数自动，转到下一个并删除它们也是我们不这样做的原因是，有时您拔出一个节点，然后想要摆脱它们，然后，糟糕。

他们在boo-boo-boo-boo-boo的路上杀死了许多其他节点，而你不是，你不想把它们全部炸掉，所以我们主要在，该级别在类中而不是在列表节点结构中，因为其他任何级别，关于这个的问题。

我只是把整堆随机的东西都弄碎了，今天在你身上，我只是想填补你需要的所有零散的东西，知道要实现这些收集类有关此问题的任何其他问题，是，哦，朋友关键字yeah II并没有提到，但嗯，有一个关键字，叫朋友。

如果你声明这个过载，我曾经很简短地提到过，如果您声明该操作符，则该操作符将打印出您知道的列表，操作员使用“朋友”一词表示允许该操作员查看，列表的私有变量，所以如果我去执行那个运算符。

您会看到它指的是列表的最前面，它是允许的，之所以这样做，是因为它是班上的朋友，即使我们不是，也不会，现在可以看到它了，您可能会说稍等一下Marty ，在进行数组堆栈操作时您没有谈论朋友，这是因为。

在数组堆栈中，操作员无需查看任何私有内容，如果我有单独的方法，请调用public to string方法来获取输出，想看一下元素数组，我想把它变成一个，朋友，以及我要给你的任务，我将宣告所有，标题给你。

我会把朋友放在里面，让你看看，我们谈论的私人事物有点像“受益者之友” ，正确的关键字，看看对方的私密事物，是的，就像是FM ，其他版本的友谊，你可能会说我不知道​​你在做什么，不是吗，不是那种化妆会议。

一次我下班回家，不小心走了，当我想勉强避免， FM otq的引力，我就像哦，那将是一个，丑闻，尽管我不小心走了，嘿，每个人都在做什么，我还有更多的东西想在完成之前告诉你我想谈。

关于现在的事情我如何谈论一种称为，优先队列，您可能会说到底，怎么可能，在10分钟内向我介绍这个问题，我认为我不会尝试，可以在10分钟内帮助您掌握这一点，是的，我希望您能想到，关于这项工作。

所以我要介绍一下，这个概念给你，你需要从那里接受它，因此，这是简短的，这是故意的，您可能需要执行某些任务，在想要优先排序的地方工作，您有一台打印机，通常，打印作业按进来的顺序打印，但某些人除外。

更重要的是，如果一位教授打印一份工作，排在所有人前面，学生或类似的东西可能有一个急诊室，排队，需要治疗非常非常痛苦的病人，他们生病了，正在受伤，他们需要帮助，但您知道，因此通常您会先处理人员，首先服役。

但如果更重要的人出现，他们正在流血，他们迫在眉睫情况危急，要在人们面前排成一列，谁有嗅探声或其他什么，如果您是，要在代码中建模这些东西，您需要一些概念，优先级基本上是具有紧急优先级的提示，因此操作。

神奇的提示会很好，那就是能够添加新的人到，线和从线中拔出最紧急人员的能力，因此，可以处理他们，您总是会处理最紧急的人，在该行的列表中，如果要执行此操作，则有一个ADT，有一个数据。

type作为适合您的集合类型，称为优先级队列优先级，队列具有以下操作，您可以在队列中想到它开始像，普通队列，您可以在队列中，您可以DQ，您可以达到峰值，但您讨厌什么，您传递的优先级有点不直观。

可能会更低，优先级更高的是直觉领域，例如，对我的课程工作人员来说非常重要，因此您可以添加基本，优先，然后以某种方式将可爱的故事写成一个故事，找出优先级最低的最紧急事件，因此在此示例中。

2作为最低的定居点退出这个词，如果你还好，那是，该集合中存在的事物存在于我们的库中，你甚至可以使用它叫做pqh你的问题是什么，是的，这是优先级队列类，数字，因为它的优先级会出现。

所以埃里克会在马蒂之前出现，如果我，添加了另一个优先级为3的优先级，该优先级将排在第二， Eric等了解结构并不复杂，我不认为您是否已经使用过其他ATP（例如队列和地图）以及，这些事情。

所以我不期望这会非常困难，让你理解，我希望我已经解释了一些背景，你会，想要这样的事情，真正的问题是是否必须实施，如果你必须做一个经典的东西，这个东西已经不存在了，你有，从头开始编写它。

您将如何在内部实现它，存储这件事的数据，这实际上就是您的作业，分配是我希望您实现两种类似的方法，因此，让我们快速讨论一下可以实现此功能的一些方法，可以将其存储在数组或向量中，就像我们对堆栈所做的那样。

无论何时排序，如果它们未排序，您能做的就是，只是添加到末尾，而不考虑优先级，最后可以，通过遍历事物的DQ寻找优先级最低的事物，数字30现在我们要移动并返回该数字，如果这是您的结构，如果存储排序。

添加速度很快而删除速度很慢，当有新病人进来时，您会优先考虑将您留在狭窄的地方，病人出来时的排序顺序谁出来哪个元素，如果PQ排在最低位置-谢谢，斯巴达好射线就是那个，会出来的总是他们-我需要开始看到。

所以这是两种方式，你可以实现这是一个未排序或排序的数组/胜利者，你也可以，使用未排序或已排序的链表（如果未排序），只需将其添加到，框架或和（或）在任何地方（如果已排序），您必须遍历并找到合适的。

并在正确的位置插入它们以保持排序顺序正确，这些更好，我的意思是，这取决于您要优化的内容，但我希望您能看到所有未排序的排序数组链接列表全部，这些组合中的四个都有特定的操作，这些操作确实很慢。

它们都有一些操作，您必须遍历整个列表，寻找跨元素的东西循环以使它们正确地移动，我们谈论，作为n的大O，因为您只需要查看n的所有内容，向量正确，所以这些结构都有其缺点，看起来，比任何一个都更好的答案。

这是一个特殊的结构，所谓的堆，堆只是您以特定方式使用的数组，如果，您正在使用堆，您会想到每个元素都有父母和孩子，父母在Packer索引中，孩子在索引中倍增，在， index plus y这只是一个概念。

只是一个想法，为什么您会想到这个，之所以这样，是因为如果您将数组排序为quote-unquote，这样父母会更多，比他们的孩子更紧急的这个结构对于，建立一个优先队列，当您向PQ添加一些东西时该怎么做。

你把它放在最后但现在已经坏了，因为它有优先级，所以它应该更接近起点，因此，您要如何使用swap进行交换？ ，为了送给父母三岁，比三岁有更紧急的优先权，所以你交换它释放了这一对，紧急优先级比一个优先级高。

因此您交换它就可以交换索引剩余的点，结束索引，结束索引，直到到达正确的位置，如果您要删除自己，则对那些父母的排序顺序也一样，取出第一个元素，然后将最后一个元素换掉，所以你让孩子和孩子在一起两次。

直到顺序正确，这听起来像是一堆复杂的事情， mumbo-jumbo，但是如果您执行此行为，您将发现，从此结构添加和删除所有日志和运行时间都很大。

因为如果您跳跃的次数是两倍两倍如果您跳跃的次数是/二/- ，这些是输入大小的对数二，所以这是一个很好的平衡运行，该东西的核心操作时间，它也具有不错的属性，最紧迫的要素需要首先出现的要素。

您想偷看或删除的地方是它在哪里看，在开始的时候，最低的索引就是索引1，所以这是一个，真正聪明的小技巧来实现这一点，这不是和DC的107末日分配（称为Heep分配器）不同，那不是你的另一回事。

我们能够使你实现，你要做的功课是我要你实现一个，优先级队列使用2004 griefer，同时使用未排序的数组，因此，这第一件事是未排序的数组，第二种样式是排序的链表，底部是第一个。

第三个是使用这个奇怪的父子垂直命令，堆结构，我知道我很快就闪过了，因为这就是全部，在规范中有很多详细信息，我希望您考虑一下并阅读它。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P15：【Lecture 15】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

我想你们可能知道我们的期中考试是明天，那是我们今天在哪里，中期是明天晚上，请在这里取消我们通常的部分，尽管某些部分，领导者正在与自己的学生一起进行评论，是的，是的，是的，他。

问了一个很多人可能会想到的问题，他说你告诉我，如果我来上课，你会给我一些正确的东西，我记得我，记住这一点，但我告诉你每天都有什么人站在后面，大约30秒钟后，因为他们正在等待，所以我要。

大约15到20分钟就可以给你，所以如果你在这里，坚持下去，如果它已经过了一半，我还没有给你，那就像在向我摇晃，向我招手，就像嘿记得你在做什么，说我会给你，我会很感激你在这里所以不是。

我上课时只是动物图片，我保证，明天再看考试，晚上，我知道你们专注于您的压力， ，广场上有很多很好的问题，询问期中和实践，问题，如果您有问题，我们会尽快开放，关于事情，所以我今天要谈一点考试。

尽管我的意思是，我认为，一般来说，你们有一段时间的学习主题列表， ，在实践考试中查看，所以本次讲座不是期中考试，但我会讲一些关于中期的东西，我也会讲一些，今天有一些新资料，但我知道您根本不在乎，因为。

这不是您现在关注的重点，所以今天我的封面，我今天涵盖了所有新事物这一事实是基于以下几点： ，我的意思是说，如果您使用的是四分之一系统， ，没有太多的讲座，所以你不能只是丢掉它们，我必须，总是保持前进。

我必须继续覆盖新事物，以完成所有任务，我需要在星期一教你一些东西，所以我们得到的讲座不如本单元那么多，涵盖所有内容的材料，我也知道你们那里的人有钱，他们星期五要抛弃我，因为你星期四晚上参加了考试。

他不会在星期五出现，所以我觉得我会想念你们很多，虽然如此，无论如何我今天还是要覆盖一些东西，我们今天要去的地方是，我们仍然会在，星期五，如果明天晚上考试后您还剩下什么，那我该怎么办。

首先要做我今天想做的第一件事，问题和办公时间，而美国国家航空航天局（NASA）就是关于这个话题，叫做Big O ，重新整理一下有关该主题的内容，因为我认为可能是，有用的，还是一个小技巧，无论如何。

看到我明白了，这不是最后一个技巧，我会在另一个技巧中，谈论它的大O主题我没有涉及很多，我没有很多，讲课时间来详细介绍它，所以有意义的是。

令人困惑，所以我将一直讲到幻灯片5 ，来自第2周，所以我想谈谈Big O的一般想法，是您可以假装它们各自采用的单个代码声明，一个单位的时间来执行，因此如果执行的for循环为十，重复。

也许我们会说循环执行十个语句，或者如果for ，循环主体中有五个命令，它会重复十次，也许是for循环，执行十乘五等于50的语句，所以我们假装有，语句需要的这种基本原子的一种执行时间单位。

为了现在写那是不正确的，这不是真的，不同的陈述需要，不同的时间量，但是如果您愿意的话，这是一个很好的起点，要将现实生活的所有复杂性归结为它，它变得非常复杂，快速。

所以让我们假装每条语句要花一个时间来运行，假设如果您调用一个函数并且该函数中包含n条语句，则，函数调用需要花费一些时间，因此即使，如果函数调用中包含for循环，则函数调用为一条语句。

则调用该函数的代价不是一个，而是所有重复，函数内部的代码，这就是，在我们的小世界中调用一个函数，我们生活在重复中，乘以那里的事物数，例如，如果有一个函数，其中有五个语句，我编写了一个for循环。

该循环十次调用该函数，大约需要50个电台才能理解，所以像这样的模型，如果您有一个if-else语句，则住进去，如果它进入， if和if语句数量是否在else中， else中的语句只执行它实际执行的语句。

所以这是，有点像草率的代码执行模型，所以看一下测试，可能会给您一个问题，您可能需要在哪里做类似的事情，正确的，这是什么运行时间，所以我会问很多这些问题，有一个名为N的变量，我不告诉你它的值是多少。

这是一个整数，这个想法基本上是相对而言，结束它是一个正确的变量，所以你知道夫人。循环将是n次，那是身体的n倍n倍，所以身体有一个陈述是n倍， n乘以1，身体得到四个陈述，是其外国咒骂的n乘以n， 。

所以这是显示这些类型的事物的一般方式，现在这些都是非常人为的代码，但我实际上是在尝试做，是让您能够查看您的代码并说哦，我正在遍历我的3 ，我正在做，我正在做，哦，那要花这么多，要执行的语句。

我希望您对此有大致的了解，现在好了，我们从中学到的东西，谈论Big O是很多情况下，运行时仅在，处理大量数据时，您的算法可能有点草率或，如果您仅处理10个学生或数据库的10条记录或，这样的事情。

但是如果您要处理一百万个，无论您是在浪费每条记录的时间，十亿美元都变得越来越重要，学生们每双滑雪板都好，所以我们谈到了如何将数字变成喜，玫瑰正是我们更加关注的事情，您知道您可以衡量。

任何您可以运行一段代码并启动秒表，然后停止，秒表，您可以说花了5秒钟或类似的时间，但是，这是非常有缺陷的，因为我的计算机可能与为您的计算机供电时有所不同，可能会给我更多的处理能力，所以这与绝对值无关。

给定人员的一段代码量，在今天的游戏中，相对而言，如果我，使输入大小更大需要多长时间？ ， Alber的运行时间和作为输入单位增长的增长比例是多少，在这两件事之间，什么是计算机科学家认为的。

关于代码运行时最有趣的话题，所以我们来谈谈，关于它的增长率或算法的复杂性，好吧，计算机科学家决定的是，您不需要获取，过于挑剔，几乎没有什么价值和细节，您应该专注于，输入大小与运行时间成正比，因此您知道。

如果您的算法的零点是四点加，它将使您找到的结果运行，是因为n真的变得比那个表达式的第三部分大，是最重要的部分，因为如果n为一千，则n ，第三是十亿左右，所以这十亿完全使任何，在该表达式中。

n的次幂数百万或数千，因此，就像我们作为计算机科学家团队所决定的那样，我们将，简化这些日子，使其更容易讨论，但扔掉，所有较低的幂并且丢掉任何小常数，它几乎没有倍数，倍数或倍数，因此最终状态全丢了。

大约进入第三个，确保零点进入到30s不同于进入，第三点是不同的，如果你指出了另外四个节奏和一个，一种算法，与第三种算法成比例，我们俩花费的时间不同，但是兄弟的增长是什么。

我们很在乎这就是我们所说的运行时间，花费了很多陈述的顺序大约是第三，语句运行，我们说n的阶次为第n个阶，所以我们称之为，喙哦，对了，所以这才是真正的重点，就你们而言，我想向您介绍的原因是因为您。

知道我们关心效率我们关心好的算法，正在做很多使用集合的代码，并且该集合，如果您以错误的方式使用集合或选择了错误的代码，集合来解决给定的问题，这实际上会使程序变慢，你们在写一些家庭作业时已经看到了一些。

作业也是如此，所以我真的只想让你拥有那就是，最终目标是很好地了解如何制作算法，所以，就像这些不同集合的某些方法和功能一样，他们需要执行才能运行的大运行时，您知道我们在说什么，需要花费固定时间的事情。

例如在最后添加一些东西，向量的时间是恒定的，因为您不必移动，您周围的任何事物都只是放在最后，它是在快速寻求价值，获取值或在给定索引处设置值也很快，所以我们，说花费固定的时间，我们说基本上需要一个单位。

一次，但是任何可能需要循环很多次的操作，我们说很多价值观都需要花费时间，因为它是成比例的，到向量的大小a花费所有时间将所有元素转移到，的n个元素，所以现在在这种情况下，您知道我认为。

幻灯片中我有一个名为M的变量，之类的东西，现在我的向量大小是n，因此，像您正在处理的东西之类的东西，或者现在很多的东西，的学生也会感到困惑，好吧，您插入了前置向量，需要n倍的转换才能最终得到它。

但是如果您像这样插入，向量的中间，我们还要说一半，事情按n的顺序排列是因为如果您将n加倍， ，做了什么小静脉，所以如果我改变输入大小，只要n是n的一部分，更改将是n的百分之一的运行时间。

该表达式由于其增长与n成正比，所以不要，在中间考虑太多，到底是不是在最后，例外情况是，如果您恰好在最后插入它或喜欢，一个或两个元素远离最末端或类似的东西，然后，只需要一两件事，而不必真正改变任何东西。

因此您，知道我在你的中期学习表上给你的表上有，这些大方法可以解决所有这些问题，但是有一个明显的例外，如果您碰巧正在处理列表的最后一个实际上是Big O ，其中之一是因为它并不需要真的运送任何人。

这样您就可以观看，反正一点点，这实际上归结为，您必须在我向您显示代码的地方回答问题，然后说什么是大O ，这段代码，所以您必须首先了解集合方法，而且您必须先了解这些规则，例如是否有循环。

如果您有一个函数调用，该怎么做，并且如果将所有内容组合在一起，应该能够了解不同事物的运行时，所以我将跳过此幻灯片，但是我的意思是这张幻灯片的要点是，大O算法更糟，花费的时间真的非常长，您不希望这样做。

因此这里有一些示例，涉及Big O的代码，这是我的工作，我要你明天中期做，所以像这个第一名，看起来像那些在大厅里的时代吗，是的，他们上来的只有一个，单曲时间[音乐] ，因此，如果他们走了。

那么第一个for循环，第二个for循环，我在，我要移走的时候，我可以做一个妓女吗，另外一个是整体，他们执行了整个代码，所以有人被绊倒了，您会看到两个for循环，很多人都说哦，两个for循环都可以。

我们不相乘的土匪，其次是另一个加号，如果我只是这样做，您就喜欢合并此文件，然后，实际上是两英寸，所以先将小片切碎，脖子基本上是一个人，所以他需要我进去，所以我们有，首先带我去了，除了时代，那仍然是男人。

我们还有一个问题，所以有时我会用，不会直接说结束的表达，但您应该能够说出，这就是要做的事情，所以你说如果我相信外面的这种需要，而不是一次，但是如果我的第一个或循环甚至有一个特定的，您曾说过。

如果它的第一部分从0到n次扇动， ，这意味着要重复任何时间的平方， ，集合是N平方的，这意味着第一个for循环将是，上升，所以我认为如果我们在“是”中找到，它将翻两番，代理机构30说不递归怎么办。

如果我有递归功能， ， 1190很大，而参议院的召唤总是很难为之思考，您很痛苦，我保证我不会再问您有关Big O递归的任何问题，足够棘手，您必须用完全不同的理论来学习，类调用递归关系。

您将了解递归的原因，运行时之战我不会问你，但是如果你需要我的话，打电话给每个人都可以工作，这将是很好的平方，所以这，正确，如果我将2x-1-x-3移开，只要Tracking的手指已经，什么都不做。

那么元素的数量应该是常数，元素，所以我的意思是我知道我可以让你最后知道它的背面，与其他任何地方，并缓慢，所以我不会去镍约你37 ，几小时后，您知道我是否可以再问一遍第二个代码，在水平线下面。

我做了一个向量n次，先生，嗨， ，然后我清除了这个插入所需的时间， ， N平方大二人组的大O更多这是一个组合，你会很好地说这是怎么回事，我不记得的一套很好，我的意思是你可能不得不看一下你的大。

o抬起手，我将回到幻灯片上一秒钟，我必须跳一下。

第二个um我们了解集合和映射集合的大部分日志都是大的，关键操作“添加/删除”包含一个哈希集，其中大多数，如果您在记忆中有困难，可以将其常见的包含操作删除，不用担心，它在备忘单上，在语法讲义上，在，好吧。

如果我知道那是真的，我是说我有一些学生问我喜欢，那么为什么N的对数和简短的答案是我们要学习，详细介绍如何实现这两个集合，然后您将知道，直接说明为什么它是log n的大O，这与重复切片数据有关。

分成越来越小的块，直到找到要搜索的内容，我将向您展示如何尽快执行此操作，但现在我们只需要知道。

如果知道的话，就是这些操作的运行时间，然后返回到，我们正在谈论的大O问题，如果我有一个问题，我们会在这里， [音乐] ，还是有点正确，这无关紧要。

所以我做了一个叫做awesome的变量并接受了2000的awesome ，从零到棒极了，是的，但不是没有看到运行，那么，如果这些循环在N或某个希望的地方，而所有这些顺序都在。

我们可以将代码设为n个平方律的眼睛，恒定的最大值邻近贝克的相似的最大值，可以很好地结束我的意思是n是可以确定的数字， n真的很小，因此代码不会花很长时间，但是整个过程。

大O就像如果n真的变得非常大会发生什么，那将是，整个直觉，我们试图与这最后一个他妈的，然后我们将移动，如果我们有一个哈希图和一个向量，有时我在，哈希图，然后在向量中插入一些内容，然后循环播放直到向量。

是空的，元素不在矢量中， [音乐] ，开始远离这些东西，为什么不+并在底部，循环，唯一的消失，所以实际上我一开始就在做任何插入操作，这意味着总体上，丢失视频和正方形，然后我循环播放，直到它变空为止。

我们从，开始，好吧，所以它是N平方，然后是N平方的整体兴趣和平方见，如果这是过去的话，你们现在会准备好了我知道一个问题。

问题是这是否只是一个常规映射，那些方法的运行时间很长，所以，如果我现在确实放在这里，这就像log plus和log n plus n，所以现在，你怎么做的日志仍然比常规日志小，而且小得多，实际上。

所以我们只是忽略它，如果它是乘法的对数是否是加性的， n乘以n，则为n log n，但如果它是像这样的顺序相加的，然后最大的一个吞下较小的一个，哦，是的，我的意思是说如果Elsa是我们的我不。

我也不会试图欺骗您，还有很多其他原因，因为就像Elsa只是将，它进入哪个分支，所以您知道我是否执行了类似的操作， 2是零，然后做地图1否则做向量或类似的东西，所以现在一半时间在做地图，一半时间在做地图。

向量的东西，就像半个N平方的东西和半个n对数对齐，这是，它会以相同的基础出现我不知道，所以只需要运行时间，不管它进入哪一个， papito每次都放弃这里的决定，因为为了插入，在那里。

我只是将所有其他元素滑过，这样我就可以适应，取代连接我们自己的东西，它将其他人移交给妈妈免费，如果我说上帝要更好地对我说零告诉你，只需修改该位置，使每一列的常量都可以。

就像如果这次测试的电话要花很长时间，那么每次通过，通过循环，必须再次进行测试，再次进行测试，因此，您必须在运行时计算中考虑这一点，我可能不是，会让你这么做的，因为那比我给你看的要棘手或棘手。

关于示例问题，但是是的，我的意思是，您知道测试的时间了，进行循环测试所需的时间大部分是循环运行时间的一部分，我们运行的测试通常是快速对象，例如，我小于n是否是此向量，空是一堆空的东西。

我觉得你们想要另一个，只给房间里人的秘密小提示好吧，这就是我认识我妻子的方式。

可以，然后呢，好吧，我知道这是有史以来最严重的转折，但我想谈一谈，在几分钟内谈论一些新东西，我知道那不是你的头在哪里，现在就可以了，但这是我要做的，如果不是。

你要做什么，然后我不知道我不能强迫你，但是等一下我，不想在哪里我不，我不想要这个文件我，想要一个不同的东西，所以我想告诉你下一步我们要去哪里。

下一个高级材料将是关于一个叫做，二叉树与我们刚才讨论的其他内容并不完全无关，这是因为我们与您如何有效实施，设置我们谈论的是那些方法来自其中的一些或如何，我们可以高效地实施这些事情，我们学到了很多。

链表和数组，如何实现向量，如何实现，实现一个堆栈并排队这种东西，所以这是我要诀窍，教您继续使用它来实现集合，因此树是一种结构，用鼻子做成的，最常见的是我们谈论每个节点的二叉树，有两个下一个指针。

我们不真正地将它们称为下一个，我们没有或全部，我要去的企鹅下一个左指针和右指针，指针看起来有点像他要画的树， ，树必须计算的属性，例如有向叶的对称性，这个-链表，以及您从自己转到下一个列表。

去网络也是一个根节点，你可以用递归来描述根节点，定义一棵树为空或它是具有一棵树和一棵树的节点，在它下面，您可以形容这并非巧合，递归结构，因为基本上从您的人的角度来看，树是，指针的混合听起来并不很棒。

就像两件事一样，您在本课程中最享受的是我选择相信的，这就是我选择认为您对此有想法的方式，这就是一棵树，再来一棵树将是我们将用来实现粗糙集的东西，想法是，您将在左侧存储较小的内容，在左侧存储较大的内容。

对，当您搜索事物时，您将向左，向左，向右，向右走，根据您需要变大还是变小找到它们，这将，使您可以快速找到一组目标元素值，我们将立足于人们做很多事情的想法，计算机科学中的树，您可以存储家族树。

您可以存储目录，您可以存储字母树来存储您在手机上键入的单词的树， ，自动完成基本上就是一棵树，以这些字母开头的单词，并暗示可能的单词，如果您正在编写编译器或编程语言，则为输入内容，编写树来处理表达式。

这一次再加上一次，就像一棵运算符和操作数的树各种各样的东西，像那样，在人工智能决策树中大量使用，您的算法需要做或考虑一下，所以到处都是树，他们是超级骗子，而且实际考虑的是。

面试工作面试有关实习和他们喜欢的东西的问题，二叉树编码问题，因为如果您可以这样做，您只需向他们证明，你可以做指针，可以做递归，所以他们应该，基本上雇用您，所以这可能是您想要的主题。

为了从这门课程变得很棒，我在这里有一个像巫师的问题，这些是有效的，哪些是无效的？ ，这些无效的树，只是有人举起你的手，这些不是合法的二叉树，是的，你说五号是什么，错了，不是周期性的，它可以追溯到开始。

它可以回到顶部，是的，是的，其他任何非法树木都可以。 ，你知道我想我昨晚说过，你可以使用二叉树，好像，代表家庭，尽管如果我们的例子不能很好地工作，这样做是因为您可以让两个父母一定要指向一个孩子，但是。

好的，不，是的，有点主意，好的，这里有一些，术语向您抛出了很多术语，树的每个小元素都是，一个节点，但这是我们谈论叶子列表时使用的相同术语，链表中的某种起始节点，您称其为起始节点，并带有一个。

我们称之为二叉树的根源，我们有很多类似条约的条款，它们被称为子树，您分别是左子树和右子树，这些站点上您下方的节点以及读者第二层的孩子，树中反叛者的总数称为树的高度，有趣。

因为我刚刚谈到了如何使用集合来实现树，只需在树上往下走，直到找到你要的东西，搜索，因此树的高度与运行时间有很大关系，处理树的各种算法，但您知道我们稍后再讲，我想无论如何，如果您愿意的话。

我会开始使用这些术语，用一个你不记得的词，只是对我大吼，我会提醒你，这意味着什么，所以您可以使用C ++对象和结构来实现树，我们将编写一个称为树节点的小结构，用于存储一块，数据。

指向左侧的指针和指向右侧的指针，就像我们有一个，小列表节点，存储了一条数据和一个指向下一个节点思想的指针，您可以存储所需的任何类型的数据，但对于初学者来说，我一直很喜欢，从intz开始。

因为我认为蚂蚁是这种最简单的类型，可以存储，这是一个树状结构，我已经在这张幻灯片上花了很多时间，它只是一个包含数据的三个节点，我在右边的指针上可以，构造一个，然后您可以问一问是否是一片叶子？ 。

在两个null的右边，所以它就像带有某些方法的结构，大部分是在我向您展示方法时，它们已经在类中，但是，结构也可以有方法，所以所有的数据就此左右，事情就是这样，如果您想使用它来构建一棵树，这就是。

看起来糟糕，我在做什么，这为什么我，所有这些旧文件都打开等待我不想让这不安全等待，哦，这是讲座二叉树，好吧，我不知道那里发生了什么，所以这是，如果您想构建我在ASCII艺术中粗略绘制的那棵树。

你会说根存储左9个根，子存储右6个根，子存储14，然后左左为负三，左为右，你知道吗，你能看到这些线条基本上是如何建立那幅画的，我在这里没有null，因为树节点的构造函数设置了，子项自动为空。

直到您更改它们为止，以便使后四个，知道在十九号中有三个他们的叶子全都是空子，好吧，所以你知道我是否说过root root right right right等于new ， 88的树节点。

因此根右上左右将是88，因此向下，在这里，你知道我的意思，所以我会买一些昂贵的好东西，这是我的妻子远程向我发送情人请求消息这是什么，给我买些昂贵的东西，亲爱的，我想那会在这里，就像， 88就在右边，哦。

您能否拥有三个分支的左能量和中能量，所以我确定，您几乎可以做任何您想做的事情我们将要学习的大部分内容，向前是有两个子树的树，如果您有三个子树，则称为二叉树，我们称之为三元树，您可以拥有四棵三元树。 。

有多少个孩子，但是我认为很多概念可以概括为，可以用两个做，可以用三个做，可以用四个做，你会看到，就像大多数整洁的东西，我不知道我是不是向你展示了。

人们为什么在这里和这里使用树木或其他东西的原因类似的幻灯片，以及，我还说过我们将用它来实现集合和东西，我猜，我要说的是，如果您有能力一分为二，这是非常强大的功能，然后从那里添加拆分为三个功能。

并没有增加太多的功能，所以我认为我想获得的好处是。

有两个孩子还可以，尽管这是合法的，但如果您有可能做更多的事情，无论如何还是需要一棵树，所以我做了一棵树，看起来很多，就像我们上周制作列表节点链接列表的代码一样， 。

好吧，我在哪里，所以想象一下我有那些放在最后一个节点上的节点，幻灯片，我想编写一个打印整个树图的函数，树上每行只有一个元素，所以它打印我不在乎我的顺序，不在乎订单，而是想要的订单， 17：

14这就是如果我们必须写我在这里说的代码的事情，除了，树指针作为参数，所以您知道我们使用链接列表来完成此操作，链接列表的最前面作为参数，因此应该看起来很漂亮，类似于该权利，好吧。

让我们看看这里我想编写一个函数。

叫做print，它是您过去的根，好吧，让我们进入那里，我的意思是，空的，我们还没有写，所以再次提醒我，当我们，打印一个链接列表，您如何喜欢在元素中走动以及，看看他他在做什么，是的。

就像临时指针或当前指针一样， ，说虽然不为null转到下一个转到下一个转到下一个所以看起来，这样可能是正确的选择，所以也许您说树节点，当前等于节点，然后当当前不为空指针，然后。

而不是当前等于当前点下一步您会离开，你突然做的对不起，我希望你能看到这有点，棘手，因为您需要左走，然后右走，链表很简单，因为它是线性的，只有一个下一个节点，到但现在我们必须去其他两个地方。

所以我该如何循环，我现在做一个电流，Curt将它分成两个电流吗，指针，然后那些必须指向儿童的指针，我必须分成四个，当前，您是否看到这比仅打印出一个链表更加棘手，好吧，我早些时候告诉过你一些事情。

你可能现在还记得我说过，树是关于将指针与递归混合在一起的，所以这就是，可怕的更好的方法是不修剪树，而while递归循环，如何。

递归是否可以帮助我们很好地解决这个问题，让我们回到所有，学会了死刑并复发他说，是的，我会给你一个，第二个简单的turbo我们将得到两个基本案例，但是如何打印出漂亮的，就像在其他树上弄怪一样。

如果我在那棵树下找到那个点，很自然很容易阅读其他东西，他会带我们扎根树木是一些条约是非常自我的基因，这就是波斯人所拥有的类似权利，所以我喜欢任何其他方式，想想递归，如果我有一个神奇的功能可以。

打印除我以外的所有其他节点，如果我愿意，则打印与我自己有关的所有内容，不，你不知道，如果我有这样的功能，这个问题会真的。

很容易，因为我会做的就是说好吧，让我们看看我有一个，神奇的功能，所以我会查看节点数据Endel，然后将其称为，魔术功能，我会通过我的左边，我会调用魔术功能，我会通过，我的权利。

所以神奇的功能将打印所有其他人，我会，打印自己，如果我们拥有神奇的功能，那将会很棒，但是，当然你们已经足够多的时间看到了这个技巧魔术功能是我，我是神奇的功能，力量就是您的力量，如果我只是让您大吃一惊。

那您应该先在人下学习一些，但我教给你的东西至少对，这是什么基本案例什么是易于打印的树是的叶子，听起来很好，所以叶子是没有任何子节点的节点，所以我想基本上你不想我走到左边如果左边没有，正确，例如。

如果node left不为null，则打印左侧，因为我不想，如果我走得太远，则会在空节点上调用该行，这会导致我的崩溃，程序确定，然后如果权利不为空，那么打印权利，让我们，看看它现在是否正常工作。

仅供参考，这是我们拥有的树，哦，天哪，我上课之前没有编译它。哦，不，我要输五分钟，哦，我从来没有想过我会看到我的学生会说为什么来的那一天，我的C ++比我的Java慢得多，这是颠倒的。

当人们说我从来没有这样的事情时，树，好吧，它崩溃了，但是稍等片刻， 9 6 negative 3 7 14 11 a它打印了所有节点，对，我们做到了，这么聪明，你会摇滚这个测试，我知道。

我想我们可以做一点，更好，因为我真的认为我确实希望您学习该课程，关于递归的问题是您应该尽可能地懒惰，它与称为“臂长递归”或“ ，递归Zen就像找到最真实的基础，不，不，你做什么，只是不。

正确打印任何内容，让我让我为您修改此代码，我会尽力指出这个代码是可以的，确实有效，我猜它有一个小错误，如果树的整体根是， null会崩溃，因为它尝试打印，空路由的数据，但是没关系，那没关系。

但我真正希望您理解的是，这段代码是一臂之力，递归，这不是最好的方法，这将会出现，一遍又一遍又一遍，当我们谈论二叉树时，你应该总是，首先考虑空情况，如果，传入的节点为空指针，那么您就知道为空null 。

节点无所事事，如果树为空，则不应该打印任何内容，但是，否则我应该打印它的数据，就这样，可以，但是我不再需要这些测试，因为如果左边为空，如果右边为null，它只会调用并执行此操作，所以我可以，这样说。

实际上，如果您不介意，我宁愿我不喜欢空树枝， if-else的原因，为什么我不说节点不为null打印它就打印它，左边是对的，代码是更好的，我比其他人更喜欢，一个是因为另一个有两个if。

而这个仅需要一个if ，我认为递归代码的一个好特性是，您只专注于自己的事情，而不关注下一个家伙的事情，不用担心，下一个家伙是否为null或左侧是否为null或是否担心，关于您是否现在不专注于自己。

如果您不太清楚这是，仍然要首先工作我会运行它，所以您不要认为我疯了，它确实打印了里面所有不同元素的树，因此可以正常工作，首先，但又像您知道笔记不为空一样，打印您的数据，然后继续递归打印您的左侧，这可能。

为null的情况下，它将立即退出，或者可能不为null ，它会打印一堆东西，然后为正确地做同样的事情，我们编写的大多数二叉树函数都有一个优雅的Zen ，这样的解决方案，他们将有大量的ifs。

否则为if和，武装递归的其他解决方案，所以我为您的目标，伙计们是为了使您更趋向于优雅的解决方案，我认为，对于二叉树尤其重要，我只剩一两分钟了，让我们再做一件事，我将如何，计算树中节点数的大小。

让我提醒您，您对树所做的一切都是递归的，所以如果那是我的树而我，想知道其中有多少个节点，我该如何计算，自我相似性是一种神奇的功能，它可以帮助我完成大部分，工作，只是将打印功能做得很好，我会告诉你什么。

您知道我不想一定喜欢复制该代码，但我认为我们可以，考虑一下你知道的不同种类的树木，我想仍然有这种，像你然后你的孩子的自我相似性，以及他们的大小如何，就像我告诉你我已经知道这东西的大小一样。

子树是3我以某种方式神奇地知道，我以为我们知道，这个子树的大小是4，所以我知道3和4，我问你大小是多少，您的尺码3和4是多少，您在它们的上方，所以总共3加4 ，加上1对您来说。

实际上返回的是树的大小1加上大小，左边的节点加上右边的节点的大小我们忘记了基本情况是什么，最简单的树，知道节点是否为null的大小。null的大小是多少，树0 0没有错，如果它是空的，那将是一片叶子。

否则为1加上孩子的大小（如果孩子全部是，它们的零，它们对总数没有贡献，所以这就是这些函数的作用，通常看起来我停下来了，祝您学习顺利。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P16：【Lecture 16】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

所以大家好，我知道您希望今天看到Marty ，注意到他昨天不在期中，但他要我告诉你，他在检查室里的所有事情，因为他的妻子在工作，所以在那里，将很快在世界上迈出第一步，我敢肯定，他一定会分享，图片。

我认为有一个女孩，我知道他是否正在考虑将她命名为，期中加薪，但我想他们会和夏娃一起去，他的妻子赢了那个，战斗是的，所以对你们所有人来说意味着您可能会看到，我中有很多人对此感到遗憾，马蒂希望他也能在这里。

但在我们之前。

开始，我只想先发布几条公告， ，昨天有几个人在备忘录中留下了一些东西，所以如果你已经，丢失了一个水壶，汽车钥匙或您的课本，下课后来看我，然后也是总统日周末，这意味着星期一没有演讲，很棒。

这也意味着周日没有任何活动，因为部门负责人，也像三天的周末，所以如果您有任何疑问，请随时，只要实际上，只要在广场或眩光和克莱尔上的帖子都会在周一开放，有更多的人手，这很好，所以让我们开始谈论。

二进制搜索树，所以今天我们将结束对二进制的讨论，我们从周三开始谈论的树木，然后，我们将学习一种称为二进制搜索的特殊类型的二进制树，具有很好的排序特性的树，可以进行很多操作，快得多。

所以我们将那些常见的操作编码为破坏者，警报二进制搜索树是如何实现斯坦福地图和集合的，因此，如果您想知道为什么他们这么快，为什么要对它们进行排序，讲座完全适合您，然后我们也将基本上。

在今天和下一个星期三之间实现一个二叉搜索树，我们进入二叉搜索树，我想谈谈遍历，所以遍历，就像解决任何树问题的最佳方法，所以基本上如果有任何树，问题，您将需要做一些您需要去做的事情，看一下节点。

看一下它的子节点，所以共有三个，遍历遍历在查看之前您在节点处正在做的事情，在任何孩子的顺序中，我们都会看到这就是为什么它被称为，一旦我们进入二叉搜索树，那么基本上就是你去了，左，然后是您自己。

然后是右和后置订单，您可能会猜到您是先做孩子然后自己做孩子，思考它的另一种方式是您可以考虑它，就像您一样，可以追踪您的树和您传递节点顺序的方式，表示要遍历的订单，因此在进行预购时，如果。

第一次在左侧传递内容时，您将其打印出来，以便，这种情况下，它会像是17，然后是41，然后是29，然后您将在此处，我们已经发现41，然后下降6并转到此处对不起，有点滞后，这是完成后的样子，但是，基本上。

您会四处走动，然后依次执行17、41、29、29 ，六个，然后传递981和40，您可以按顺序执行相同的操作，并进行后期订购，以便订购，这是您第二次通过该号码，因此，你知道这是我们第一次通过他们。

现在我们通过了29 ，我们已经通过41现在我们通过6现在我们通过17现在81现在9现在是40然后，然后在您通过右侧时发布订单，以便基本车轮见示例，使用所有这三种方法，但是要牢记它们，因为几乎。

任何树木问题都可以通过遍历的某种变体来解决，所以无论何时您，需要对树木做一些尝试首先考虑一下，嘿，这是一个，遍历问题我应该使用哪个遍历，是的，所以如果你想谈谈，与邻居一起尝试找出前后顺序遍历的内容。

这棵树的沙皇，好的，有人要分享他们发现的预订遍历吗，是的，我说的是42岁，所以我们有42 15 986 339好的，那顺序是什么，在后面，对不起，这应该是42岁，好吧，然后发布订单好吧。

我认为那几乎是对的，所以让我们看看吧，通过右边的15，让我右边的86，然后我想你说，三个，但我们还没有通过右边的三个，所以我们下去并通过39 ，是的，首先是的，所以39但是你说的其他所有内容，点9。

然后点42，所以如果你是的话，那么86在9之前是因为你，在处理音符本身之前先处理左孩子，这种情况就像当您通过它时，它像底部一样向下走，所以我们，在底层法院9我通过了86 ，知道这个ol似乎毫无意义。

我正在让你学习，对此感到抱歉，但是就像一旦您开始做树的问题，如果您还记得的话，遍历就像基本上所有的树问题都可以写成，弄清楚遍历，然后弄清楚该怎么做，节点，希望那些匹配，所以我们在星期三写了一个打印函数。

，看起来像这样，如果我们移动电话，您认为会发生什么。

打印便签本身的任何想法是的，是的，如果我们把它。

在这里，然后您将看到您也尝试将其扩大，上，你们所有人都能看到更好的结果吗，所以让我们开始吧，如果我们尝试运行此命令，您将看到。

一些丑陋的文字基本上说，我们崩溃了，是的，所以它说在，程序执行基本上意味着您打空而您没有，检查null，然后您尝试取消引用痣，好吧，您怎么看。

如果我们把这行放在b ，它会是遍历的一种类型吗，是的，所以它将被预购。

遍历的意思是我们先看一下音符本身，然后再看，它的子CA的情况很好。

我真的不能切换屏幕，但是55是这棵树的根。 。

在这里先打印59然后再打印29然后他们得到3等。

它是一种遍历，是的，然后你会，大家是的，然后我们也将遇到相同的无指针问题，我们之前所见，所以这基本上只是重新排列，打印出的节点似乎没什么用，但这就像，实际上，有时有时会在树的打印方式上产生巨大差异。

好吧，这就像好吧，所以我们有这些树，我们可以将它们打印出来，很棒，我们可以遍历它们，这也很棒，但更多的是，有用的是能够判断您的树是否包含元素对，因为那是我们看到的大集合操作之一，因此。

让我们谈谈如何为二叉树编写包含项，但想法是，如果该值在树中任何我们想返回true的位置，否则返回true ，我们返回假，所以任何人对任何技术都有任何想法，也许我们刚刚了解到，可以帮助我们，是的，是的。

所以我们的想法是我们仍然要继续研究，树中的值，所以我们仍然想使用遍历，而不是，实际打印该值，我们想查看该节点上的值是否等于，我们正在寻找的价值非常正确，就像我说的，所有树问题基本上都是遍历问题， 。

伪装好吧，所以我们知道我们要做什么，好吧，我们知道我们要。

在做类似不包含左值的事情，不包含右值，所以，现在的问题是，这是哪种遍历？ ，在检查节点的任何子节点之前先检查节点，邮购后，我们将首先检查所有子代是否具有该值，然后再返回。

这个节点或命令有多少人认为预购这些，你的手好吗，很多人认为有多少人认为后订单有多少人，认为遍历是完全错误的，多少人认为他们真的不应该，今天就来上课，就像在期中停下来一样运送，是的， ，显然是正确的答案。

喜问观众，所以可以预购是一个很好的选择，选择，因为我们拥有所需的所有信息，如果我们正在寻找，一个节点，我们有足够的信息可以告诉我们，这就是，我们正在寻找正确的方法，是的，如果没有日期，那么返回值很大。

怎么办，您想处理包含我们使两个孩子的电话，是的，你就像我领先一步，所以问题就像我们，需要将所有这些包装在if否不等于null指针和yes中，因为我们正在进行递归，而我们目前缺少我知道的基本情况。

你们都知道这是问题的答案，所以看，所以我们让它的节点不等于空指针，好吧，所以我们，避免我们的基础或我们有一个基本案例，我们要对这两个调用执行什么操作，是的，所以可以，这个或这个返回值是真的。

所以基本上我会在这里做的是，通常对于树是一个很好的基本案例，它会检查节点是否为null以及，然后经历并检查该值，这就是，我们先在此节点上进行，然后遍历订单，以便我们可以尝试。

是的，运行它，好吧，我们看到树中有87个树，而树中有50个55 ，像6不在我们的树中，所以我们的contains函数似乎正在工作，关于遍历都有哪些问题，并且包含是的，所以。

问题就像为什么我们必须在这里进行预遍历，为什么我们不能，做一个帖子，让我们尝试一下。

所以我们得到相同的结果包含继续工作，这是一个好兆头，在这里没关系，就像你仍然会得到一样，回答问题就像让我说我去了这个节点，然后看到像或，就像我有能力知道这个节点是我要寻找的节点， 。

而不是做那么简单的检查，我喜欢一直走到我的叶子，节点需要做很多额外的工作，所以这里更多的是优化，并非绝对必要的东西，例如有些功能，他们喜欢您做事的顺序确实很重要，是个好问题，好吧。

在我们继续研究二叉搜索树之前，还有其他问题吗。

包含函数的功能非常不错，每个人都能很好地工作。

知道此函数的运行时是什么，所以我听到了一些登录信息， ，一些目的，所以基本上我想一个好问题是我是否需要，搜索树中的每个节点，是的，我看到了很多点头，因此，哦，一个，所以我想我们可以做得更好。

因为布景又回来了，所有人都记得昨天的创伤经历，所以还好，如此二进制。

搜索树实际上让我们进入了这个哦，有关博客，所以目前我们的推文是，就像所有节点都是随机顺序一样，但是如果我们强制执行顺序，树的构造方式的特性，我们可以获得更好的结果，所以我们要订购的是我们要说的好。

我左边的一切都比我小，一切都比我小，权利比我大，这是递归属性，这意味着您，知道我去左边的孩子还是右边的孩子，他们也在做，以二进制搜索为例，您了解所有信息，在这棵树上，小于55的树在这边。

但就像您在所有事物上一样，大于29但小于55的子树将在此子树中，所以让我们看看是否，可能就像更改我们的contains函数以获取旧日志n ，而不是n次正确的O，为什么不与伴侣交谈并尝试。

找出一种优化我们的包含功能的方法，此订购属性。

好的，所以我要把这个放回去，因为有人要进行遍历，关于如何更改此设置的任何想法，因此我们无需查看所有，树中的节点，我们只能看一些，是的，因此我们可以在此处进行的优化是，我们不需要。

这样做，我们不需要查看子树的两侧，例如，如果我们，寻找35，很抱歉让我们做34，我们知道如果我们看到18 ，没有机会在这里的任何地方，所以我们正在寻找30或我们，可以像整个臂架一样划掉整个子树，好的。

然后我们达到35，我们知道这比我们的数字大，寻找不可能在这里的任何子树中，所以我们，像每个路径上的大量节点一样越界越好，之所以要这样做，是因为现在它正在n的o o中登录n，所以是。

所以问题是为什么这不算是公平的递归，基本上，这不是独立交易，因为我们所做的一切都是，我们当前所处的节点就像所有这些if语句都与，我们当前位于的节点，而不是我们想要的节点，如果我们尝试做某些事情。

例如节点是否剩余数据或，这样的问题是一个很大的问题，无论如何，我们，需要对此功能进行操作，让我们尝试运行它，这样所有这些都将返回。

假那里发生了什么，除了55是我们的根，我们缺少了什么。

这里，是的，我听说基本案例已经关闭，好吧，所以如果我们再次尝试运行，是的，我们现在看到了，这与我们看到的匹配。

好吧，嗯，所以我们早先的一个问题是等待，为什么我们不能做，像邮购订单一样，是否有一种简单的方法可以做到这一点，功能，所以任何人都可以看到一种方法，是的，所以基本上，您必须先查看当前节点，然后才能进行。

决定要向左还是向右走，因此遍历确实很重要，对此包含哪些问题，功能或类似的原因，为什么它工作或为什么更快，是的，这里的回叫，问题就像假设我们当前正在查看87和节点，我们正在寻找的是10。

该代码不会返回false，所以在这种情况下，那么87是，大于值rikes大于10的87 ， 87的左孩子小于87，可能会或可能不会，是10，所以我们会说子树是否包含10，这样它就不会。

必然返回false，因为如果我们曾经到达该左子树中的节点，等于值，然后返回true，然后返回true，是，然后像这样一个大的人会回到那可能。

好吧，关于bsts的另一个很酷的事情是，获得最低要求非常容易， BST的最大价值，这是我们原始树的好孩子，必须像对待数组或数组一样正确地查看每个值，向量或链接列表，您必须查看所有内容。

以便任何人有任何想法，三重奏的最小值是一直到，左，所以它是没有左子孩子的第一个节点，感觉为什么好吧，好吧，嗯，这个想法好吧，我们只需要看一下。

在左侧而不是在右侧尺寸的CJ上，将左侧的还好，所以我们可以继续下去，这段代码缺少基本情况是什么，所以，什么是好的基本案例，是的，所以如果我们要做类似的事情，在这里，如果不等于空点指针。

我们可以做这样的事情，这是我们之前见过的，但是问题出在最后，就像这里，如果它是空指针，那么做一些事情就像一个空，树没有最小值，所以我们实际上需要做些微的改变，基本情况下。

我们说“好”是我的左孩子null，然后描述了，我们之前讨论的条件，我们想要第一个音符，没有左继子就好，否则，让我们写更多的柯诺值，为什么bsts很棒的另一个例子，因为这只是log n而不是o ， n次。

到目前为止，我们一直在作弊，因为我一直在你知道我们只是，通过链接这些节点神奇地创建了这个BST，就像，这对于这个BST来说很棒，但是我们如何才能让其他bst赞一下，这样就可以添加功能了。

那么我们如何添加到BST中，您可以想象在那里，您可能会添加很多不同的方式，例如我的意思是如果您给我，一组值，例如，您可以从中得出许多不同的vsts ，一组值，但是我们希望找到权重，就像添加一个好的方法。

尽可能少地完成工作的树的价值，因为我们，真正懒惰的计算机科学家，所以我们希望对更改进行最少的更改，越树越好，那么他们如何与伴侣交谈并设法弄清楚，像是将值14添加到此树中的好地方，好的。

有人有任何想法要分享吗？对不起，好的，所以我们的想法是让它成为树中现有节点的子节点，还没有孩子，让我们下降到19岁，然后，使其成为19的左孩子，那么您如何选择像19而不是，是其他节点，是的。

这样的想法就可以了，就像这个想法还可以，所以14个更大，大于8，所以我们知道它必须在树的右侧并且更大，比11小，因此它必须位于11子树的右侧且小于， 19，因此它必须位于不存在的xix子树的左侧，因此。

让我们让子树等于节点14听起来像，我们今天所做的一切，是的，我听到人们说的声音就像包含其中的声音，正确的想法是让我们像在树中搜索要放入的节点，因为无论如何集都不能有重复，我可以找到它很好，如果。

我们找不到想要的地方到我们一直在寻找的地方，而您，知道发现null必须是我们的节点应该去的地方，那。

好吧，让我们复制包含的代码，我们可以弄清楚我们想要什么。

改变这里，好吧，嗯，我们大概不会有任何类似的东西，返回值或错误值应全部添加，但我们想在，我们当前所在的节点具有我们想要的值，我们是否想要更改，我们的树好吧，所以我们可以返回好吧，然后是什么，然后好吧。

我们，让我们知道你走对了最后一件事，在这里，我们还有另一个返回值，所以如果节点为空指针，我们该怎么办，是的，抱歉哦，是的，我得到了，所以我们可以说节点等于您知道新的树节点，值还行。

所以让我们尝试运行此代码，这样我就可以摆脱我的帮助了， Insta BST好吧，让我们尝试运行它。

我们的树不存在，所以您认为这是怎么回事，为什么我们的树。

添加功能无法正常工作，您喜欢与伴侣交谈几分钟，并尝试找出为什么我不工作，好吧，如果有人对这里出了什么问题有任何想法，是的，是的，所以我们在这里有一个问题，这个节点超过五个值，这意味着，在这里。

当我们尝试将其设置为等于未反映变化的事物时，回到缅因州，因为它是另一个范围，因为我们复制了，树节点变量好吧，我们已经看到了这一点，带有链接列表，那么通过引用传递的解决方案是什么？ 。

就像这是一个非常微妙的观点，所以你们都对什么问题，是的，所以问题是我们是否需要检查是否没有数据不相等，有价值，所以让我们尝试将其注释掉，以便您知道只有一部分，那实际上是先尝试运行它，我要先运行。

然后我本来要运行它，就是这样，我们知道这可行，所以我们得到了相同或相同的树，但是在这里。

让我们尝试不要让我们试着没有这部分，我正在运行它，以便进行汇编或。

树只有一个值，是的，所以那是当我们因为。

我们只检查节点是否为空指针，执行此代码，所以我们将失去其余的树，是的，就像我以为指针已经基本上通过引用传递了，就像为什么不反映此更改，而问题是因为嗯，所以凯，新的树节点返回一些值，例如0 X ABC。

并且该节点最初具有，其他一些值，例如0 X 1 2 3而不是大约0 X 1 2 3是从main或，从调用函数到这个函数，所以这就像一个完全，将变量与前一个变量与主要变量分开，所以我说好。

而不是0 X 1 2 3我们想要0 X ABC，它对应于指向，像这个具有这个值的节点，就是这样，问题实际上不是在指向正确的东西，这些变化。

并不反省吗，那我觉得我有一个幻灯片，这很清楚，所以是的，问题是你知道这里我们喜欢有这个可变的音符，应该指向45，但是就像完全分开一样，在42中应该指向45，这样做更有意义，非常微妙的一点好吧。

再看看我们通常想要做的另一件事，看到带有链接列表的内容是您要清理您的内存吗，只是想让树上的垃圾随处可见，以便程序处理，直到它最终耗尽了内存，所以um可能要与合作伙伴讨论。

就像您可以用来释放我们需要的树的一般算法一样，释放组成树的所有节点的所有内存，好吧，任何人对我们可以用来解决此问题的任何想法都有，问题是的，是的，所以建议是我们可以进行后期处理，遍历。

所以为什么不喜欢预订或有序遍历工作，在这里，是的，所以我们首先需要确保没有任何问题，如果需要，需要在我喜欢删除自己之前清理的孩子，离开自己，我无法接触那些孩子，所以那不是。

实际上就像在释放树上做得很棒一样，就像释放根和，别无其他，因此这是事后遍历使，大多数情况下，我们实际上不会在这里涂上它，因为您将在，您的下一个作业，但主要的提示是去上课，所以我们聊了。

关于某些示例或预购，最好包含，我们讨论了一些，如果您认为自己会使用，有序遍历或为什么您将其称为有序遍历，像发生了什么事，是的，在YouTube之前是个好主意， ，支持者是的，这个主意还可以。

因为有序遍历被称为顺序，就像当您使用有序遍历打印二进制搜索树时得到的树，是的，是的，是的，我不知道他们从哪里来的，但是，因此，如果您尝试检查您的树是否是二叉搜索树，也许，您需要使用某种顺序遍历才能像。

我们正在查看的元素实际上是有序的，所以这是正确的， ，您会在汉考克区看到类似的问题，所以我们，还剩五分钟，我可以研究如何从BST中删除，但我知道您有，昨天中期，这是一个三天的周末，所以我要放树。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P17：【Lecture 17】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

所以今天我们将通过讨论来结束对树木的讨论，一些高级树并完成一些我们没有得到的操作，到星期五，所以我们将使用remove然后完成二进制搜索树方法，然后。

我们将查看并查看如何使用二进制集或对不起二进制搜索树，实施设置和映射，然后我们将讨论树木平衡的概念，这真的很重要，因为这是我们获取登录时运行时间的方式，讨论，然后我们将讨论一些称为try的非二叉树。

是我最喜欢的数据结构之一，然后以一些有关，功课六今天就出来了，所以就像我们谈论的进修一样，周五的二进制搜索树，这就是其中所有内容，左边小于根，右边的一切都大于，该小组。

所以我们讨论了如何添加和包含但从BST迁移，有点棘手，所以就像其他人一样，您会发现如何删除，您知道这里的这个节点而没有违反BST属性的任何想法，这是一个更容易的情况，是的，在这种情况下，这真的很容易。

因为我们可以像摆脱这个笔记一样，否则我们仍然有一个BST ，如果我们想摆脱7怎么办，我们该怎么做呢？ ，删除7之类的东西比较困难，因为您仍然需要处理7 ，右边的子树是8，但是因为只有一个子树。

所以您可以，就像您说的那样用8替换7，好吧，如果我们要尝试做，像删除五个，是的，但是你要做什么，约翰想和一个伴侣聊几分钟是个好主意，看看我是否认为可以，让我们用节点替换这五个，真的很好。

所以也许尝试找出用哪个节点替换它，好的，Seimei想分享任何想法，所以在这里作为刷新或当我们有一片叶子时，我们说一个真的很容易，因为当我们只有一个孩子的时候，我们就可以摆脱它，我们用什么替换了它。

就像我们试图删除55我们替换了什么， 55你说的完全正确，所以当你只有一个左孩子时，你可以，只需更换它，然后如果您只有一个合适的孩子，就可以更换，具有正确子节点的节点，那么在这种情况下。

您知道我们有这个概念，如果我们要替换一个孩子，但您不能只喜欢选择或选择8 ，用权利代替，因为您仍然必须像对待所有， 8的子树是否有人有任何想法，例如可能是一个很好的音符，替换为，是的。

所以您可以尝试执行类似的操作，将五个替换为八个，所以在那一点上，我们仍然需要处理六个和九个问题，所以我，认为您处在正确的轨道上，就像我们希望将其替换为，有些东西，但是一个合适的孩子并不一定能解决。

我们仍然有这个，这个最难的孩子该怎么办是什么意思，九点六，那么六点有什么特别之处，好吧，这是六种蓝色，非常好，非常正确，您肯定在正确的轨道上，是的，太棒了，所以观察结果是六个是蓝色，六个也是最小的。

子树中的元素，因此它是此子树中的最小元素，您现在可以用六个替换这五个，我们知道六个必须更大，比这里的一切都多，因为我们知道六个大于五个，我们知道，那6较小，这里的所有内容都是因为6我们刚刚说了。

子树中的最小元素确实有意义，所以这是一个，好东西是因为我们注意到6做6时，左右审判，是的，所以子树的最小元素只会有一个正确的，之所以聊天，是因为孩子的年龄比左孩子少，像这样的最坏元素是不好的。

所以问题是为什么，我们不会为您使用可以用于，所以您可以使用最大的元素，从左侧子树中选择，或者从右侧子树中选择最小的元素，是的，但是任何一种实现都是完全，有效。

所以使用六个数字的好处是这是我们刚才谈到的简单情况，大约在上一张幻灯片中，我们可以直接执行此操作，可以替代，人们对此二进制搜索树删除的感觉还不错吗，到目前为止，最困难的二进制搜索树操作还可以。

所以我们需要，找到子零食的最小元素，我们有办法做到这一点吗，无论如何，我记得从星期五开始，我们写的一种方法，不，就像一个星期前一样，星期五没有人在这里，好吧，我不知道为什么我的。

可爱的火山口很有趣，好吧，所以我们写了印刷尺寸包含高度加得到，男人得到最大的数量，并努力消除像我们这样的方法中的任何声音，可以用yes让男人们好吧，所以好吧，为了这样，我们说有四个，案例是正确的。

但是为了达到这四个案例，我们首先必须找到，我们想要删除我记得的任何人的元素，我们正在使用二分搜索树的公式，例如如何获取该元素，我们要删除的，因此，如果数据小于该值，那么我们要做什么是好的，所以如果。

我们正在寻找的价值大于我们目前所处的价值，如果您认为自己处在正确的轨道上，我们想向左或向右走哪条路，是的，您说对了，因为路线右边的所有东西都比，我们要寻找的路线和价值比桥梁还大，说正确的删除节点。

让我们看看如果节点数据大于呼叫您返回，好，所以我们有四个案例了，子树右子树，好吧，如果那是一片叶子，我们要怎么办，但是，是的，所以我们可以说好吧，我们将此节点设置为null指针，嗯。

关于这件事的一件事就是那个节点发生了什么，内存中存在的结构仍然存在吗，所以我们要做什么，做那个是的好吧，所以你可以调用删除节点，然后不，它等于空，指针好，所以我在这种情况下，我们只有左边的子树。

所以问题是当我们删除该节点时，在这种情况下，我们是否必须创建一个临时值，因为我们不是，对那个节点做任何事情，就像我们不需要从中获取任何信息，该笔记或类似的东西，但我们会在需要的地方看到其他示例。

做一些临时的工作，是的，你能看到吗，就在那里，好酷，是的，所以问题是为什么我们要删除此注释并将其设置为等于，空指针，就像我以为大家都说过，您不需要这样做就可以了，所以，发生的事情是当我们删除便笺时。

我们肯定需要删除它，因为，我们不希望该知识存在，但您还需要将其父对象设置为，指向该节点的父指针等于null，因为您不希望这样，父指针继续向下指向不像那样的内存，不是垃圾，所以在这种情况下。

您必须同时做这两种事情，是的，有点像ADD，我们必须如何将节点设置为等于，新节点基本上是相反的，那当您，关于这种情况还有什么其他疑问？ ，在这种情况下做的正确，所以问题是当您删除笔记时实际上是什么。

如此发生，好吧，对不起视频中的人上课，好的，就像人们看到这部分感觉如何，竖起大拇指，很大的问题是问题是因为通知按价值传递给他，通过引用，当您说等于null不会改变任何内容，好的观察。

所以我们应该怎么做才能通过引用，所以总的来说，随时进行修改，就像任何形式的链接数据结构一样，列表或通过引用传递给它的树是最好的选择，加上星期五的精彩观察， [音乐] ，对，好的，这些都是很好的问题。

好的，所以当我们有正确的注释时，将其作为空点作为空指针，所以我们只有一个左子树，我们想要做什么，这暗示着。

在这种情况下，我们想用左杆代替它，但是我们该怎么做。

我们将拥有类似node等于right左右的东西，但这就是全部，我们需要做的还有其他吗，是的，是的，所以我们需要举行，我们需要创建一个，临时变量，因此这可以回溯到您关于我们是否需要一个，垃圾变量。

在这种情况下我们这样做是因为我们需要从，我们要删除的那个节点，然后我们删除垃圾，然后我们，在正确的情况下做相反的事情，那么您对此有什么疑问，两种情况，是的，所以问题是我们是否需要将垃圾桶声明为旧的。

指针，因此在这种情况下，如果您只是删除叶节点， 。

希望父母将其拉为零，这样，正确的情况下，我们不希望29继续指向任何东西，所以我们，会在左侧产生或，因此他会将29指向左侧的null，但在，在这种情况下。

我们实际上希望公平地将29替换为在其中删除29的位置，如果我们要使55指向null，则想用42代替29 ，那么您最终将不会失去整个42个子树，从这里树，这就是为什么我们在这种情况下不做空指针的原因。

将其设置为等于我们现在而不是说它-不，我们等于说，聪明的孩子那里有一台笔记本电脑，这很合理，其他人也有，问回去是的，所以问题是为什么我们有这个垃圾指针所以。

假设我们没有此权限，因此在这种情况下，我们可以选择删除，像这里这样的节点-在这里删除节点您无法使用剩下的节点做任何事情，因为，左边的节点不再存在，只是叛逆而已，或者，想在这里删除节点。

就像在删除节点一样，重新分配给新值，因此在这种情况下相当于删除。

42，而不是删除29个大问题，您准备好应对非常困难的情况。

好吧，在这种情况下，我们必须再次使用哪个功能，所以得到最小的，不好，所以我们说我们要替换节点附近的值，用最小值正确删除，所以我们不需要喜欢重新排列树，我们只想替换该节点。

所以如果您可以通过说节点数据来做到这一点，等于最小值oops，然后对，这很有意义，所以这就是我们有五个，我们想用六个代替它，所以我们可以。

只需将6的数据复制到节点5中，那么我们现在这里有6 ，五对是的，所以您要在这里而不是获取最小的节点对是。

节点权的最小值，这样您就可以得到最小值，子树而不是整个树的最小值，好吧，那太好了，我们现在有一个六层，我们还需要做什么呢还有另外六个在这里，所以，我们需要怎么处理那个节点六。

一些基本案例实际上就像是另一种基本案例。

可能是完全使用此删除功能，是的，是的，所以我们想在左侧或右侧的节点或节点本身上调用remove，所以，我们想正确处理节点，因为如果要在节点本身上调用remove ，我们将最终删除刚才更改正确的那个节点。

这样就不会，很好，好的，所以我们在右边的节点上调用remove，然后寻找一个最小值，基本上，这段代码正在做的是，好吧，让我们找到最小，像这样的六个值，让我们用六个替换五个节点，而不是，五个。

然后我们从树中删除六个，但这实际上正在接近，基本案例，因为我们知道该案例将在此处出现，这是更容易的情况，是的，最小值是，所以问题是，例如如果树中不存在最小值，get min必须返回一个。

就像假设我们的代码在星期五是正确的一样，我们将返回一个值，该值在您的树中是一个很好的问题，是的，所以，保证是树坐着，我们会尽一切努力是的，是的，好吧，问题就像这些第一个调整语句是什么。

就像您的规范BST代码一样，我们只是往左走，正确地找到您想要做某事的节点，是的，这仅仅是，就像寻找要删除的节点，然后我们终于在这里找到它， ，然后我们讨论了这四个案例，所以案例一是叶子。

您只是想将父级设置为等于空指针，然后第二种情况是，我们可以用它的孩子代替它，然后第四种情况是，第四种情况是整棵树，我们需要找到最小的树，值，然后将节点替换为最小值，然后删除，树的最小值，所以好消息是。

这与vsts一样困难，真的很喜欢，如果得到的话，你会像钉钉子一样，还有其他，有关于这个的问题。

所以我们花了很多时间谈论BS T，您可能想知道我们为什么，这样做，这就是斯坦福基本上是如何设置邮票的方式，斯坦福地图已实现，这就是为什么当您遍历自己的，设置您会得到正确的订单，这与我刚刚拥有的哈希不同。

随机值，因为BS密钥是有序的，这也是为什么，登录时搜索添加和删除元素的原因是因为二进制搜索树，有一个准时的博客，所以我们只写了add contains并删除了，基本上需要一个类似的东西。

您知道我们可能喜欢这个树集，将具有这些添加包含和删除方法，但它们不会占据屋顶，因为您的二进制文件集应该只包含正确的单词，例如，当您使用斯坦福集时，您不必像哦，这是，我正在传递的树节点根，您不必跟踪。

那个球可以让球保持正确的位置，所以一个很普通的事情是，您将拥有这样的服务，这就是您作为客户的目的，回忆起使用集合或地图的人，然后此功能将，就像一些助手一样打电话，这是我们星期五在课堂上编写的代码。

而今天，它只是作为该节点的根节点传递，感觉是的，所以好消息是，是的，问题是我们假设我们，根据这些参数构造一条路线，只是班上的一员，所以在发生什么事之前。

方法和下面这是我保留的一项根本权利，跟踪主要方法，我在这个根上调用广告，您可以想象，您将需要这棵树集，然后您才知道它跟踪根，本身，这样客户就不需要做我在这里所做的事情了，是的， 。

问题就像我们为什么要保留为什么不能为什么客户不能只是保留，跟踪根，所以您可以想象一下，在第一周我们就好了，所以，我们正在学习设置和映射它，所以有一个像树一样的东西，节点星。

您需要首先将此值设置为null指针，然后像，您需要像这样传递但不要担心，因为这是此数据结构，对继续前进真的很好，就像是的，我一直在使用向量，所以，这就是为什么您想要在计算机科学中很喜欢很多次。

您想向用户隐藏一些实施细节，以便，在这种情况下，您想要隐藏起来，就像实际上是二进制搜索一样，用户并不真正在乎的树，它只需要代码，就需要数据，工作的结构和时间的反弹，我们保证是正确的，题。

好吧，好吧，嗯，这对性别而言效果很好，但是地图上有键和值，因此您可以，有点想像你不会有那样的单一拉伸，就像一个正确的值，您现在将存储密钥，并且膝盖可以存储一个值，无论您想要什么类型。

然后重要的是您有一棵树，这是二进制的，它是由键排序的，而不是由键的值排序的，为什么对您来说真的很快，就像我按到键一样，您只能，像一个键但唯一的键，但是您可以拥有相同值的倍数。

之类的事情是因为您在密钥上有这个二进制搜索树，所以，您基本上就像一组键，每个键都有一个关联的值，与它有关的集和地图的另一个棘手的事情是你，必须实现这个左侧，我不知道你们是否尝试过。

创建像您自己的结构一样令人困惑，但如果您没有遇到怪异的事情，问题可能是因为，太好了，您对斯坦福的资产和地图有什么疑问？ ，实施yeah键锁，嗯，好吧，问题是不应该锁定与Jack的连接，就像。

这些是按字符串排序的，所以它是JKL，所以J小于K但L更大，比K高，这就是为什么L在此子树中，而J在此子树中，以及，您可以看到这些值基本上只是随机的，我认为，没有对值的排序，这就是为什么很难像这样写。

包含值函数，但是写包含键真的很容易，所以基本上，我们刚才编写的所有方法在map中都有一个类似的方法，因此您，已放置要添加的包含键，包含和删除或删除另一个，您必须像get方法一样编写的大更改才能获取值。

与键相关联，但是与包含非常相似，只是，而不是返回true或false，您将返回实际值，与之相关的信息，所以我知道我只是说斯坦福图书馆基本上使用，一个二叉搜索树，它实际上对其做了一些修改，原因是。

它不是一个像普通的二进制搜索树，它被修改为具有，所谓平衡的东西，所以这个重要的原因是因为当你，不平衡的二进制搜索树让您失去日志和运行时，就像，例如，如果您插入，元素按此顺序排列。

例如5然后1然后2然后4然后3然后是，是的， ，最终像这样结束了，基本上是元素，所以与其让您知道一棵漂亮的树，每L个级别基本上就像一侧的另一半元素，另一半你会得到很多，所以如果你有这条线。

在这棵树上做类似包含的东西的时间是多少，您只需要自己像一个非常精美的链表，那不好，为了防止这种情况发生，这是极端的情况，的情况下，虽然您可以想象您是否像一千个节点那样关闭了，在这里的活动中。

您可能想知道一个子树990中有十个，另一个子树中有，那仍然是非常糟糕的，所以并不一定需要像，直线仍然让您仍然有很糟糕的朋友时光，所以基本上，平衡树是您只需要确保子树本质上就是其中之一。

相同大小或非常接近相同大小，因此我们的斯坦福图书馆，实际上有保证内置，并且有一些类似的修改，您可以做的是确保获得平衡树，因此一个示例，您可以做的是称为红黑树的事情，您将了解更多，这些。

如果您想继续进入计算机科学，没有人编码红黑树，​​您不需要知道如何编码红黑树，像这样的课程的树，但基本上的想法是你做一个叫做，树木旋转来维持平衡，就像你一样，节点着色，以确保只有这么多的节点和一个子树。

与另一个子树相比，如果您有兴趣的话，那会很复杂，看起来更多，但斯坦福图书馆将实现类似，这个不错的公告考试分数简短超时时间是，在成绩范围内发布，因此如果您之前没有做过很好的跳过帐户。

您可以通过对课程入门代码进行分级来实现此目的，如果您的屁股，字张贴在广场上，您也可以访问我们的网站获取统计信息， ，升级信息，有些人可能做得还不够好，但是，本季度仍有很多机会获得积分。

像这个期中考试丝毫不表示您喜欢计算机，科学，这是我们必须做的一门考试，而且还有很多，本季度剩下的机会，无论您想要什么成绩，都能获得出色的成绩，并且，那么另一件事是因为马蒂（Marty）不会去校园。

艾米和我都增加了办公时间，您可以看看您是否去，转到网站上的员工页面，很好，所以我答应我在这里谈论尝试，这是我最喜欢的数据，结构，所以尝试工作的方式我们一直在讨论二进制树，有一个左孩子和一个右孩子。

有人说些什么，嗯，所以，你有一个左孩子和一个右孩子，但是逻辑上的问题就像为什么，我们不能这样做，我们想要多少个孩子，而尝试是，像是的，是的，我们可以这样，所以尝试的方式是每个节点基本上都在存储。

像您一样，它用于存储字符串，这就是斯坦福词典的方式，实现，因此每个节点有26个子指针，每个字母对应一个，字母（如果您正在为其他语言编写词典） ，取决于该字母的大小的指针很少，所以基本上您。

想如果您跟随您知道一个指针，然后是T指针，然后， e指针会拼写出单词8，所以想法是当您，就像跟随那些指针往下走一样，尝试最终会导致失败，节点，如果该节点的单词是true，则表示您没有单词， ，如果没有。

那么您就不会工作，但是就像不错的事情是，如果没有，他的话是对的，但是就像您仍然在尝试添加一个节点那样，表示您对单词的前缀是正确的，所以您可以想像哦，你什么都不是，但是哦，你仍然可以呆在节点上的唯一原因。

因为你是因为你最终会建立，或者如果您遵循正确的指针，那么我就像一个更清晰的例子，我承认，所有空指针，因为否则将有20个大小为26的数组，这很难理解，但是您可以想象他们实际上就像。

您在该数组中也是23个空指针，所以如果您尝试欺骗，你试图看到好吧，这个词是我们部落中的一个词，我们，将从这里开始，好吧，第一个字母是一个，所以我要去，放下指针，下一个字母是T，所以我要放下T指针。

下一个字母是e，所以我要下e指针，看它说单词是，是的，因此，如果我们尝试将其视为，曾经在我们的词典中是一个词，我们会走的很好，然后是N，然后是C ，为空，所以我们会说好吧，一旦尝试中一言不发。

您有什么疑问，关于尝试，是的，所以问题是我们是否像一个人一样，以及我们如何，知道on是一个有效的单词，因为那不能仅仅作为前缀，因为一个，所以这就是为什么我们有这样的词字段是因为当您，继续说下去。

我会说是对还是错，因为你会说英语，和其他语言确实有作为其他单词前缀的单词，因此您只是，就像一个布尔标志，如果您是一个单词或不是一个很好的问题，是的，问题是按照定义，尝试中的所有叶子都是单词，是的， 。

是真的，您还有什么其他问题好吗，是的，所以我们没有时间，写包含前缀，因为我确实想谈论霍夫曼，但本质上，这个想法是可以的，如果您碰到一个空节点，则您不是前缀，因为您已经，放弃尝试。

然后如果单词中的字母用完了，您会喜欢，跟着下来，你仍然在尝试中的一个节点，那么你是一个词，然后要获得下一个字符，则减去，请先输入ASCII字母或ASCII值，以找出哪个，要去的指针。

然后您知道递归沿着那个孩子走，所以大，区别在于您拥有左右数组，而不是左右，指针作为提示，您可以对霍夫曼使用类似的方法，作业6，您需要在字符和数字之间转换，对，所以您可能要减去而不是减去a的值。

零的值您对尝试有什么最后疑问？ ，您想去哪里霍夫曼，所以今天要写作业六，基本上你在做什么，编写一种压缩方案以使文件更小，以便ASCII有一个，每个字符正确的字节数，无论怎样，都具有相同数量的喜欢。

就像没有人使用过的怪异标点一样占据了相同的质量空间，因此，相反，我们要做的是像可变长度，会像空格一样，而A小于一个字节，好吧，这些只是四位而不是八位，但是您得到了一些东西，像Z可能更长，但这没关系。

因为我们使用的Z更少，如果您有一个很大的文件，我们总体上会这样做，您的文件仍然会，较小，所以我们的想法是我们将在您拥有的地方创建一棵树，有一个左指针和一个右指针，您有一个零和一个指针，所以您。

知道左需求接近于零，右意味着趋向于一，然后这个想法是，例如，如果您在树中较高，那么您将在较短的二进制文件中下降，值是很好的，因为那样的话看起来就像是压缩的方式，工作正常，因此要执行此操作。

基本上是一堆步骤， ，在讲义上有概述，但您需要计算每个出现的次数，文件中的字符，就像逐字符读取文件，然后，将字符和计数放入优先级队列，以便您，刚写完的作业又回来了，那么您想使用。

优先级队列以创建霍夫曼树，然后遍历该树以查找，字符到二进制映射，因此我们遍历此树的方式有点类似，我们如何遍历尝试，您将如何建立这个，根据您要指向的指针，然后针对其中的每个字符的字符串。

然后将其转换为压缩二进制版本的文件，基本上，当您进行此设置时，您想知道当您离开时，你想喜欢一个事实，那就是你只走了零，你走对了，你想保持追踪，所以只要走一个就行，你就会，用这种方式建立你的弦。

那么当您解压缩时，您需要喜欢从某个地方开始，然后喜欢，选择是向左走还是向右走，具体取决于您阅读的是1还是0 ，关于霍夫曼的一件好事是，您永远不会有前缀，就像是对字符的有效编码一样，所以您不喜欢。

在你的树的中间并以一个类似的结局结束，在这里输出这个字符，或者我像所有有效字符一样继续前进，是叶节点，有一些输入，并通过此分配输出内容，因此您将使用位流，输入和输出单个位而不是完整字符，因为再次。

该设计的重点是喜欢压缩文件，因此您需要在，位级别而不是角色级别关于霍夫曼的任何问题都让您兴奋不已，好的，我星期五见。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P18：【Lecture 18】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

好吧，我假设您的掌声是感谢您的高品质，您上周参加的期中考试的权利，哦，不，也许还有其他事情，呃，不，但我确定你知道我已经参加了，有一阵子我有重要的事情要照顾，这很适合，我，我想这是父母周末，有几个。

一对父母在房子里很高兴见到您，欢迎光临CS 106 BI ，想向房间里的任何父母道歉我是你的孩子不在的原因，回应您的来电和短信，因为它们正在残酷地处理我，辛苦的家庭作业是我的错，对此我深表歉意。

但是是的，这是父母周末，因为你知道我刚刚成为一个，父母，这是我的小宝贝。

我的意思是我告诉自己，我不会花整整堂课，谈论婴儿真的很棒，她很棒，很健康，她做得很好，我今天没有带她进来。他好像5天大了，我不是，被允许带她进入大学校园，那将是我的疏忽，真的是过山车。

就像我的妻子从字面上去工作一样，期中的一天，我们就像在制作女子组合的副本和东西，上个星期左右要去照顾所有的事情，在本季度的剩余时间里，我仍然会按照一定的审核时间表，他们在家中要做一些重要的工作。

主要涉及粪便，而且我每周都会去做一些演讲，我可能会每天都在这里，星期五我可能会在每个星期的另一天，但实际上任何一天都会继续，帮助我在完成课程时弄清楚事情，但是我认为我们。

我知道通常我会给你看我的照片来奖励你上课，小狗和我的动物我想也许这次我可以给你看几个，婴儿图片很酷耶，嗯，让我们看看，等等，她在哪儿，这是夏娃的照片，我在看。

她出生时打篮球我的妻子真的很生我的气，看着她推到这里时的三分全明星大战，是在她的小卷饼包裹的东西，实际上并不难，因为所有，你做的就是把它们包裹起来，把它们包裹起来，他们喜欢，移动他们的手臂和腿。

然后很容易跟踪，之后，他们只是无法真正移动到任何地方，只需将它们变成，小墨西哥玉米煎饼，然后您就可以走开了，很容易，所以她在这里，这是她还在医院里，我无法告诉的最好的情况是她看起来更像我还是像我的妻子。

得到了我的schnoz对不起亲爱的我不知道这是我已经告诉你了这个，我认为这是我最喜欢的一张，当你，你把你的小手伸出来，他们用他们的小手抓住你的手，手指和东西只会融化你，我不是感性的类型，我什至都不是。

变成婴儿，但是以某种方式当您的婴儿这样做时，就像您整个，之后世界就不同了，我想这是我跟她开玩笑或双关语或我最喜欢的时刻之后，我想的就是，当我们要带她回家时，我必须向她介绍，我们的动物有三只狗和两只猫。

我有点害怕，这些狗会向她吠叫，是要咬还是会发生什么事，他们会跳过她的划痕吗，他们超酷，我不知道动物只有本能，他们只是看到这个小婴儿，就像我得到了这些奔放的狗一样，并跳起来。

他们基本上在天花板上进行循环去循环，它们是如此充满活力，但，不知何故，当我抱着这个婴儿在他们面前时，他们就得到了，知道他们有点像不寒而栗，他们仔细地嗅着她，他们，很安静，很温柔，这真是太好了。

这是夏娃和我的法国人，斗牛犬艾比（Abby Bullet Abby）融化了我的心，知道这是她和我的另一只狗巴尼，我的妻子谨慎地花园，但是他，前夕和我们的猫咪两只小猫真的很棒。

真的很好奇她另一只猫的照片在哪，一只猫的照片有另一只猫，小猫真的不是，知道怎么做她我想我认为狗就像想要保护她，猫就像是在说这意味着我受到的关注减少了，现在您知道，狗和猫之间的差异这里还有她妈妈。

小睡一会儿我告诉你，你知道你和某人有一个婴儿，它真的向您展示了有关您伴侣的一些东西，例如我不认识你们中的一些人，伙计们现在可能在恋爱关系中约会，我觉得，真的很幸运。

就像我找到了一个值得与我共度一生的伴侣，你真的看到，当你有孩子的时候，你知道就像你在他们的身边看到他们一样，最好的，最坏的情况是当他们处于极度痛苦中时会看到它们， 。

当他们过去两天的睡眠时间总计为45分钟时， ，真的，这是一个真正的考验，它确实向您显示了您是什么样的人，选择与您共度时光，而我妻子太神奇了，这真的，让我们在一起，你知道这真的很特别， [掌声] 。

她赚的钱比我不喜欢做的多，然后有人寄给我这张照片，我一直在谈论我的孩子，就像墨西哥卷饼，有人寄给我这不是夏娃的照片，而是，我想走了两次，我要走了，然后谈论其他，的东西，但你知道谢谢你和我在一起。

我知道这个季度，过去几周会有点怪异，我很难达到，仍然在电子邮件中我仍然在广场上我至少会在每个星期五在这里尝试，更清楚地告诉您如何联系到我，你知道艾米和阿什莉会帮助我们完成事情的，在本季度结束时。

我想简要谈谈中期和，班上的情况如何我知道我认为阿什利也许，在星期三谈了一点，但是我们给你的期中成绩打分，应该有你的成绩，现在应该可以查询，而且我还发布了一些有关您在课堂上的表现的信息。

而且你知道有些人不喜欢他们的表现，或者他们不喜欢他们，屏幕上的数字，我想我会说的是，您仍然有很多机会可以改变这一点，在家庭作业中表现出色5 6 7在期末考试中表现出色，参加本节，您还有很多积分可以赚。

如果您有不同的目标，我会看到您的成绩百分比有所提高，会说不要放弃，仍然有很多波特，或者留下了，我们的很多要点都被推到了本季度末，所以，知道我通常会说你知道继续做自己在做的事，并且请记住，您知道是否在。

有关您的情况的网页请记住，我将您的分数拟合为一条曲线， ，大约一半的人会得到A，而大约30％的人会得到B ，你知道很多人会获得比你可能更高的分数，担心会这样，所以你知道不要放弃，只是继续前进。

做你正在做的事情哦，最后一件事，我开始喜欢教你，新的东西今天我要教你一些东西，一种of样，一种结合睡眠剥夺激素的肾上腺素，所以今天心情很好，所以我很高兴能给大家，一个额外的湖，所以是的，你走了。

我想我必须花一些时间，天，所以我也应该让您过得很晚，所以无论如何都可以，我想教你一些东西，所以让我跳到现在，我们就在这里，现在在课堂上，我们刚刚学习完二进制，树，所以希望您能看到自己知道上下文。

这里的二叉树是，指针和递归的混合体，这有助于我们进一步了解您，可以实现集合Set Maps和lexicon之类的集合，您知道我们很友善，在这次旅程中，我们将了解我们所有不同的系列。

数据结构库以及它们如何工作，如何实现它们，以便我们，继续说，今天我们要学习的是，我们将开始学习一种新型的，一个叫做图的集合，图非常强大，非常有趣，所以您知道这将从今天开始，我们将在整个，下周也是好吧。

这是我在第18章图表上的幻灯片。

教科书，如果您听到单词图，您可能会想像笛卡尔平面，用x和y画一条线或类似的东西，这样V和吃掉边缘，是两个顶点之间的连接，有时它们称顶点为节点，因此它更像是链表，其中包含节点，有时它们之间的边缘。

它们被称为圆弧，所以您可能会听到其他术语，但是我，要说顶点和边缘，我认为这很常见，是的，边缘，将一对顶点相互连接，所以这是一张图形的图片， ABCD，并且在某些顶点之间有边缘，那里有一整束。

今天我要告诉您的关于图的术语一个术语是，顶点的度数是触碰到它的三个边的数量，在右上角的图片上好，所以图表非常有趣，可以用来解决一大堆有趣的计算机的数据结构，科学问题，我们将在这里快速介绍一些问题。

例如社交网络Facebook Twitter或其他哦，如果您，想看很多婴儿照我完全把它们都丢在Facebook上了，和instagram如果您想加我，我将很乐意向您展示我的所有宝贝。

图片网络通常基本上是相互连接的人物图，当他们彼此成为朋友或彼此关注时的边缘，诸如地图，航空公司地图，道路地图，Google Maps之类的东西，东西之间的联系，你知道边缘是，道路，航班和顶点。

而城市则是地点，您想通过正确的选择，所以有很多这样的例子，这就是一个图形，mm-hmm这是我所用的其他图形示例，不会经历其中的每一个，但是你知道你可以，可以将很多东西视为图，即使它看起来不像是。

首先向您显示图表，例如您可以考虑课程和，在大学的先决条件，就像你知道我的意思是什么，如果你有这样的图，那将是一个顶点，什么将是一个边缘，是，是的，当然是节点或顶点，而边缘就像某物是否是。

先做一些其他事情，是的，你可以用化学方法做到这一点，通过解决迷宫来做，有各种各样的例子链接，在网页之间，页面本身就是顶点，如果页面是链接，到另一个代表边缘的页面，这样您就可以这样思考。

我可以在其他页面上找到类似的内容，这些是一些您将使用图表的示例，它们遍布我，没有列出大量使用图形的示例，就像当您在构建处理器时布置电路时， ，各种各样的东西，所以如果你要代表一个迷宫。

您知道我们稍微想过迷宫记得我们写了一个递归，从迷宫中逃脱的算法，您能否将迷宫视为图形？ ，将是顶点，边缘将是什么，如果您的答案是肯定的，父母可以随时自愿，是的，这是一种很好的思考方式。

例如您可以叠加一个，网格上，然后您可以访问的每个小方块就像一个生日，如果可以从一个到另一个相邻的正方形之间有一条边，其他的，还有一堵墙，所以是的，这是一个很好的答案，像那些是顶点，粗线是。

他们之间的边缘那种自然的权利，你可能会成为一个图表，我知道你不认为这是为什么，认为它是一个网格图，我在这里有这些选择题，基本上，您知道很多图算法都涉及到查看邻居，你们已经写了一些像人生游戏这样的算法。

，涉及看给定事物的邻居，所以很多这些邻居，算法基本上是图算法，因此很多事情都可以，如果您愿意，可以将其建模为图形，您可能会说好，等等，为什么我在乎，关于这一点，我不是，我不需要晃晃成为一个图表。

我已经盐晃晃晃了，我，用来网格化，您知道我不需要迷宫即可成为图形，我可以用，递归，所以我想这引发了一个很好的问题，例如为什么我要，认为这些问题是图形问题，如果我能给我带来什么呢？ 。

已经有其他方法可以很好地解决这些问题，答案是，许多聪明的人研究了图并提出了用于，搜索图以对图进行排序图处理Brasch在，陷阱，如果您可以解决他们的问题并将其转变为图形问题，则。

可能存在一些众所周知的现有算法来解决该问题，然后找到问题的答案，这是一个非常普遍的窍门，计算机科学将一个问题简化为另一个问题，其中第二个是，有一个已知的解决方案，这是我们做的一件很普通的事情。

这就是为什么我们，可能想将这些其他事情视为图形问题，好很多次，当我们谈论图形时，我们想考虑，路径是一种从一个地方到另一个顶点再到另一个地方的方法，将顶点表示为要访问的路径，也可以将其记为一组。

沿任何一种方式走，您都可以得到相同的信息，唯一的例外是如果有多个连接的边，一对相同的顶点，但是我通常不会像，在我们今天的示例中，例如，如果您想从，在该图中顶点V到Z可以使顶点与相同路径相同，基本上正确。

当您有一条路时，您有时会担心多久，路径是您必须走过多少条边才能知道该路径，许多这样的示例，例如，如果该图的路径是航空公司的话，飞行，那么路径长度是什么样子，如果你说我有一个所有的图，今天的航空公司航班。

这条路径的长度为三，这是否意味着在现实世界中您可以从纽约飞往三家商店，芝加哥芝加哥丹佛丹佛西雅图，对，所以您可能会说您有任何路径，长度较短的话，您是否有一些打击较少的打击垫，例如，是的，无论如何。

这是我们谈论路径长度的一个术语， ，成为邻居或与另一个顶点相邻的概念仅表示，那里有一个直接的边缘好的术语，所以您知道一条路，不一定要最短或最好，或者如果我想找到一个，从u到VI的路径可能只沿第8条边线。

但这也完全有效，从u到W-x-y从W到V或其他任何可以弹跳的地方，周围可能出于某些原因，您想要更长的路径，或者某些原因，您在锻炼自己，在跑步时在跑步，您并不总是想要，最短的路径。

因为您可能要回到他的起点，所以，最短的路径就是您所知道的，因此您可能想运行一个，无论如何，您都可以走不同的路来获得相同的结果，目的地，所以这里有更多术语可以从另一个顶点到达一个顶点。

如果从第一个开始的路径上存在，在一起，如果有一条从， A到B，所以在图中显示的是每个顶点都在一个，彼此可达，只要跟随边缘，就能无处不在，在右下角有一些这样的图，如果需要，顶点是D和E再次与其他顶点分离。

现实世界中的示例，例如您的灯没有进入某些国家或，你在做管道或电插头或诸如此类的东西，网络无法到达其他网络的其他部分，有各种各样的方法，你可以想象这个朋友圈子你知道你的朋友没有，和他们的朋友成为伙伴。

所以你知道这些小朋友，右图的区域，我们称其为连通，这意味着每个，顶点可以到达其他所有顶点，因此右上角的图与，左下角是连接的右下角不是完整的图是，从字面上看，每个顶点的边都指向其他每个顶点。

这种情况很少见，但有一些例子，您知道，数据集，因此了解能力和联系非常重要，我知道，举例说过航班，我的意思是连通性很好，因为那时你，说嘿，无论您在哪个城市，都有某种飞行计划可以，卖给你。

这将带你到你想去的地方或你要塞的东西，在城市的电源线中，您说我需要确保所有设备都已连接，因为我希望每个房子都可以正常供电，这样才能达到那里的能力，某些路径称为循环循环是您最终到达的位置。

刚开始的地方并不是一件坏事或一件好事，有时您想找出没有周期的节奏或解决方案，所以您知道该图中的示例通常是vx WV ，如果您不能在同一条路径上两次遍历同一条边，请遵循，琐地猜测。

您可以只跟随母狗两次就对您说，我们通常不将其视为周期，因为您必须走同样的优势，没有任何周期的图两次被称为非循环图，废话是周期性的，我可以通过显示周期来证明这一点，对，所以您能告诉我一些可以做的更改吗。

图变成了循环，就像我必须修改以使其成为，一个循环图是的，每次等待都去掉边缘，让我不知道这些东西在这里，所以您。

说好删除边缘H我想如果我删除H，图形就不再，已连接，但II仍然可以正确循环，因为我仍然可以像这样去，如果存在任何以相同顶点开始和结束的循环，则，图仍然是循环的，所以什么也不会给我带来其他变化，是的。

删除所有边缘，我喜欢您认为先生的方式，这是正确的，回答有人可以对图形进行较小的侵入性吗？是的，您可以，去除多个边缘是的，去除C D和FCDF，因此很难，读了一下。

但是像这样一个人还在那这个人还在那这个人还在，在那里，这个人还在那里，那个人还在那里，就是你想要的，是的，对我来说正确，我猜一个启发法似乎是连接他们的正确数字，这里没有任何循环是的。

所以我的意思是您的答案还可以，我应该问一些更具体的问题，也许我应该说你能，这是周期性的，但仍然正确，所以他的答案将是正确的，嗯，无论如何，有些图具有自环，而图具有边，像这样像边缘一样走向自己。

最被称为循环，我们将在示例中使用的图表中没有某些数据，设置它真的没有任何意义，我的意思是，如果您正在做，您是否可以想象航空公司航班是否像您一样购买了从SFO到SFO的航班，只是向上飞来飞去， 。

或某种没有意义的东西，没人愿意买，那个航班和他们剩​​下的食物一样好，你不想买那个，飞行，以至于数据表明这没有意义，但有时您可以做到这一点，就像某些社交网络可以让您与自己成为朋友并了解一些东西。

有时候我可以通过聊天程序向自己发送消息，有时不知道这是有道理的，但大多数情况下我们不会在数据中包含，好，那是周期，就像我要使用这些术语一样。

可能会说嘿，让我们寻找一种算法，该算法在，在图中，您可以假设该图是循环的，并且您有时会知道，这就是我在前进过程中将如何使用这些术语的方式，所以让我们来谈谈，关于图的一些变化，您将看到一个变化是。

所谓的加权图，所以您再次知道它取决于数据集，但是，例如，如果您正在乘飞机或驾车，这是一种非常简单的减肥方法，边缘会很好，重量是飞机飞行的英里数，因此。

如果我想寻找一条从您认识SFO到迈阿密或其他任何地方的道路，那么也许，我想要重量更轻的那个，因为，我必须飞翔，还有其他方法可以加重那些无法，一定是距离，你知道像图并不总是关于。

物理空间并在地图上走动之类的东西，因为我，认为如果它们超过边缘的重量会像多长时间会很诱人，优势是，但是我想您想测试一下，您可以选择给工作人员加重的另一种方法，可以等待边缘。

这些城市之间突然之间机票的价格是多少，现在您正在尝试以最便宜的价格进行优化，我知道我们没有父母，周末，你们有时会乘飞机回家探望他们，但有时，您正在排序，您想要最便宜的一个，即使那个最便宜的一个。

额外的中途停留，在丹佛，无论您仍然购买那个权利， ，所以那样将是您可以对同一张图加权的另一种方式，好吧，我告诉你，我们将学习搜索路径的算法，我们可以搜索优化某些属性的路径。

优化长度边缘数量您还可以优化总重量，路径，这就是这里的一个例子，大多数权重被假定为非负数，这不一定很困难，规则，但是就像在许多数据集中一样，负数是没有意义的，就像他们不付钱让您搭乘飞机。

或者如果是里程数， ，没有负面的飞行，这里没有虫洞，所以重量，如果您想考虑的话，通常都被认为是积极的，图的等价性，您可能会认为未加权图是，所有边缘的权重等于1或类似的东西。

图的另一种称为有向图的有向图是，边缘只有一种方式，就像我之前向您展示的示例一样，假设您可以沿边缘的任一方向行驶，但，图上有这些小箭头，基本上我们说的是不，不，那边，只有从A到B而不是从B到A。

那么那口井的一些例子是什么，您在告诉我一些先决条件，这可能是您想要的一个示例，方向，因为106a是106 B的先决条件106 B不是106a的先决条件，命令关系的方向很重要，对吧，你不想接受那些。

如果你们中的任何一个已经报名参加下一个106次课程，则顺序错误，四分之一，你弄乱了，你就弄错了右边的箭头，嗯，嗯，所以，另一个例子是Twitter，就像我可以关注Jennifer 。

劳伦斯箭从我到她的最后一个我检查了她没有跟着我回来，尽管收到了我的无数讯息，但今天我们会再次检查两次，但您知道方向性很重要，因为我要看她的推文，有时不对我的方向性表示怀疑，有时在道路上很重要。

或者不离开单向街道而您却有两向，正确的街道，所以如果我们成为，彼此的朋友，我们都是朋友，指示如果没有您成为我的朋友，我就不能成为您的朋友，这种方式不同，因此取决于数据集的含义取决于。

图形建模权我也想提到所有这些不同的组合，图的所有这些不同属性可以组合在一起使用，加权有向图或非加权循环无向，这些不同品质的所有这些不同组合，取决于你在做什么，好吗，到目前为止我们怎么样。

到目前为止的任何图形问题，告诉你我真的很想进来我要得到我要得到我的妻子，为了帮助我，我要录制一段视频，让我和狮子王抱着我的孩子，你知道背景音乐，我真的很想喜欢，今天要给你们吃。

但是下周五我要带那是我要的，下周五告诉你，以弥补我的其他演讲，质量，但无论如何都请继续关注，所以这些是一些一般的东西，关于图，我认为这主要只是概念性的东西，我将向您展示一些。

在一分钟内用图进行编码我想指出的一件事是图，实际上与其他类型的数据结构紧密相关，我们了解了链表的相关知识我们了解了二叉树的相关知识，基本上是具有很多额外约束的图，链表是每个顶点都有的一个有向图。

最多有一个出站边是定向边，并且有一条路线，没有入站边缘的前部和[音乐] ，没有出站边的最终节点，所以它有点像，对它的约束二叉树最多可以有两个出站，边缘还有一些关于如何不能拥有两个的限制。

通向相同目的地的路径，依此类推，但这些是，图的子集，所以这很有趣，让我们来看一下，就像您实际如何用图形编码一样，这看起来像我们有一个，用于图编程的库，它称为基本图类。

我们提供给你们的斯坦福收藏图书馆和作业，启动我们给您的zip文件，称为基本图形，它代表一个，加权有向图，这样您就可以使边缘具有一种方向，如果您想，您可以对它们施加压力，所以开始它并不那么复杂。

您只需将库包含在程序中即可构建图，然后您可以向其中添加顶点和边，您知道其中一些方法，例如，如果您尝试两次添加相同的顶点，则尝试添加时会出现错误，顶点之间的边缘是不存在的，您会得到这样的错误，事情。

它的方向就像你说，从C到D 9，如果您想同时使用两种方式，则不能同时直接，我在这里用C和B完成了操作，您可以将边从B添加到C，然后从C添加到B ，基本上，这就像具有一个方向性的边缘。

这就是基本图形的入门方法，这里是一些，基本图形库具有的方法和成员可以添加边和，您可以清除的顶点可以将所有顶点或边作为一个集合进行索取，您可以遍历它们，您可以请求顶点的所有邻居， 。

它会告诉您所有您可以行跳跃到该顶点或从该顶点到达的顶点，只是去除东西边缘，您可以要求提供可以打印出图形的尺寸，这是一个非常标准的东西，您在顶点及其顶点之间知道，邻居，所以这就是我想要做的一点编程问题。

你们只是这样，我们可以喜欢玩这个库一秒钟，并得到，熟悉它好吧，所以我认为我不需要给你看这张幻灯片，但让我，来吧，让我快速回到幻灯片，我会回到那，所以我想，写一个叫做“最酷”的东西。

我将在其中读取一个完整的Twitter文件，追随者，然后我将找出谁的追随者最多， ，因此，此文件的各行上都有两个令牌，每个令牌有两个单词，或者，命名或其他名称，如果显示2则表示1号人是，跟着第二个人。

好吧，我想输出，跟进他们的追随者的大多数追随者确实是有道理的，所以这里。

我在队列创建器中，我想编写此最酷的功能， ，文件作为参数，所以在这里我想和大家一起写这个，好的，也许我可以帮助您入门，因为您知道其中一些，只是要读取文件，所以如果您想查看文件，它看起来像。

这个Twitter点txt只是一堆名字，这意味着斯图尔特跟随马蒂，海伦跟随埃尔默，以此类推，如果我想读那些话，我想我可以做这样的事情，字符串行，而从输入到该行获取行。

变量实际上您知道每行只有两个令牌的原因，我想我也可以只用一个名字来命名字符串，也可以输入，箭头名称一个，然后也是箭头名称-只需读取两个单词两个标记，如果无法做到这一点，它将给我一个错误。

因此我正在读取两个名称，我想用这些名字做什么？有人帮助我，我想，想要崩溃，好的，所以您说如果图形不包含名称，我应该添加节点，名称，所以我认为您的评论中隐含的是应该有一个，正确的图。

让我们做一个基本的图调用图，然后我可以做，图点添加顶点名称一和名称-我忘了让我们仔细检查一下，如果调用给定名称为add vertex且该顶点已存在，则执行该操作，已经存在没有任何好处。

所以mm-hmm如果可以的话，我们可以添加它们，他们已经在那里，那会没事的，然后还可以，在这两个人之间放置一条边，好图从名字1添加边到，像这样命名两个，如果您想查看是否有正确的图形，您可以说。

看看图和所有，只是看看它是否有效，看起来还不错我这里有一张满是名字的图表，有点难以阅读，但基本上先打印所有顶点，然后再打印每个边缘，小箭头，所以我认为与文件匹配，所以我们得到了一个图形，在其中有数据。

该图可以，我如何确定谁是大多数关注者，如果只是追随者怎么办？我如何看待最追随者？ ，知道，是的，就像您拥有的邻居数量一样，程度是，追随者的数量很多，我想指出的一件事就是，想知道一个人有多少追随者。

所以我们说这是詹妮弗，劳伦斯就在那里，这是我马蒂，就在这里，我就像是，我遵循这样的权利，这就是我们的图形将要存储的内容，因此，如果您愿意，知道有多少个邻居j-law你知道有一种方法，叫获取邻居。

但获取邻居会告诉你有多少出站，边缘，有多少人在跟着你，你知道我的意思，所以我，认为我们遇到的问题是我不想知道有多少，顶点在这个系统中的邻居，因为那是，人关注我想知道有多少人关注他们，你知道吗，我是说。

我们该怎么做，我们如何调和，这使我产生了想法，是的，嗯，这是解决这个问题的好方法，基本上，让我们，边缘存储了另一种方式，我凭直觉就知道了，就像我跟随你一样，所以边缘应该走那条路，但看图只是。

对于解决我们要解决的问题和问题非常有用，我们要解决的是谁跟随我，以便我知道我想要，为了能够吸引我的关注者，您知道我的意思，所以我有点想要，从我到我的追随者的优势，这就是我强调你的顺序，建议在这里。

所以现在确实是， Jayla对我有优势，因为我关注她，柏拉图式的好吧，所以如果我想知道多少，我们就说几，追随者该人是否有我认为您回答过的您说过的话，如果，您想在图形中的顶点上循环，可以说图形点得到。

顶点有几种方法，其中一种叫做获取顶点名称，将返回一组所有顶点的所有字符串，另一个称为get vertex set的对象，它返回一堆指向更多对象的指针，有关顶点的信息是我将使用此获取名称的时间，因此。

如果您想遍历它们，则在该字符串中输入顶点，如果我想知道如何，他们拥有许多追随者，这些追随者只会是图点，而得到V点大小的邻居，那就像他们有多少追随者，但我不想知道，他们有多少追随者我想知道有多少追随者。

他们有权利，那么我该怎么做，图如何存储该关注者和关注者，是的，基本上，对于每个邻居，让我们问一下他们有多少个邻居，对，所以让我们对图中的每个邻居进行类似操作， V的名称。

所以我们现在要遍历所有直接关注者，关于邻居的追随者，所以我可以说图得到这个的邻居，邻居，我可以做一件事的点大小，这可能是我，可能有重复，我可能在这里重叠，所以我可以通过解决。

把东西扔进一个集合或类似的东西对我来说很好，所以基本上我只想要像int followers等于零的东西，然后在这里，我将使追随者拥有自己的追随者，再加上等于就可以了，所以对于。

每个跟随我的人我都会问谁跟随他们我会数，这些全部，我将所有这些计数器加起来，追随者知道了，我想要的是谁拥有最多的，追随者的追随者，所以基本上这只是您的最大计算量，一旦完成给定的计算。

就知道跟随者的最大跟随者为零，这个人的追随者，我只是在做像你这样的事情，该人的关注者和关注者大于我所看到的最大值，那么， max等于此权利，但该功能的最终目标是，应该返回最酷的人的名字。

谁拥有最多的关注者，所以我认为除了存储，最大我应该存储他们的名字，以便像字符串最酷的人等于我不那样，知道是谁，然后如果这个人是我见过的最大，最酷的应该成为V这个我现在正在看的人，当我，完成。

我将返回最酷的人，这个图中最酷的人是Mara，就像我所有的数据集一样，就像不是那么微妙地亲吻我的老板，希望他们能给我奖金或，父母Mehran sahami是这里讲师的老板， ，计算机科学系。

因此无论如何您以后都可以浏览数据，如果您在查看内容时遇到一些麻烦，请验证这是正确的答案，我正在说要下载代码并放一些，打印语句以观察不同的循环，但是，该练习的重点是我说过我只是想使用该库，一点。

看看它如何工作，你知道这是一个不错的小图书馆，您知道如果没有这个，我们将有可能解决这个问题，您知道的图书馆使用我们在写之前学到的收藏，所以我，不说看这会打开一个解决问题的全新世界，或者。

我只是向您展示这样的内容就是使用此示例，图书馆，会有一些问题，我们将学习解决，这将非常适合解决问题，因此这是这里的目标，对，是的，我们在此处编写的有关此代码的任何问题。

好吧，让我们在这里多看看一些东西，我将开始教你，关于在图形中查找路径的信息，在这里，我将向您展示两个，如果我们很简单的学习算法，我们将学习更复杂的算法， ，我想您会发现每种算法都有好处，因此。

当您搜索路径时，有时您只想知道一个地方是否，从我驾驶的其他地方可以到达我可以达到的目标，到达今天有时您想最大化或最小化我想要的东西，我想要的跳数最短的路径最短我想直飞。

航班有时您希望最低的等待时间我想要最便宜的航班，所以我，想要最少的距离这种事情，所以您知道不同的算法看起来，对于不同的事情，此示例是从迈阿密到SFO I的最短路径，认为需要飞往檀香山。

但这不是最低花费的途径，因为中的里程数和定价等等，所以您要淘汰，不同的东西取决于对您重要的东西，好吧，让我们学习，一些路径搜索算法之一被称为深度优先搜索， DFS，这意味着您从给定的顶点开始寻找路径。

目标顶点和执行此操作的方法是尝试一条路径，具有不同的边缘，不同的邻居，不同的方式，去选择其中一个，然后尽可能地跟随它，看看它是否导致，您到达目的地，如果这样您就停止了，否则请返回并尝试，与众不同的是。

您对算法的一般风格听起来都很熟悉，你尝试一些东西，看看它是否有效，是否不起作用，然后尝试一些东西，不同，我爱你们，我想念我，我想念你们中的所有17个人，父母你的孩子大多数时候都不来上我的课，为您展示。

但现在还是有一些新面孔，我只是在开玩笑，但是，这就像我们几个星期前学到的递归和回溯选择，尝试探索它，然后如果它不起作用，这是递归的，回溯通常完成的算法，因此如果您要搜索，此图中从8h到8的路径。

您尝试去B，然后从B尝试，从每个我要去F到e回来尝试去看，所以你尝试，去我那里你仍然找不到H，所以你有点备份，没有其他方法可以沿着那棵选择树走，所以您支持所有，最多尝试八种方法DD导致GG导致H此算法。

不会考虑不会尝试找到最佳路径和最短路径，最小重量路径，它只是尝试查看是否可以找到路径，是否可以找到，它为您提供了路径深度优先搜索，所以这里是，有关如何编写已访问v1的此类markdown的伪代码， 。

知道如何标记东西，标记标记方块，并且知道如何标记东西，您不会两次访问同一广场，因此您以某种方式对其进行了标记，然后您递归地先从每个邻居进行深度搜索，看看是否，邻居将导致v2，如果是，则停止。

否则请取消选择并尝试，下一个邻居好吧，这个伪代码有点高级，不是，详细说明您要做的每个细节，因为我要，您编写此代码，但这是它的主意，请选择资源管理器，取消选择每个，邻居。

直到您通常在执行此操作时找到目标为止，最终目标是您想找到一条路径，然后让该路径给出，给我一个顶点矢量，因为我应该拜访你，知道给我，回答它是某种数据结构，所以如果您想这样做，并存储路径。

然后你们知道该怎么做，回溯算法，您可以沿着矢量或您通过的对象，您所做的所有正确选择就在这里，您只需通过，沿着路径参数，然后在访问每个顶点时将其添加到路径，您正在建立，然后如果您已经找到目的地时间。

那么我，知道如果您没有找到自己的技能，就可以编写类似的代码，回答，然后取消选择从路径中删除该顶点并尝试尝试，否则，该算法讨论的是将事物标记为正在访问，而我，真的不说该怎么做。

如果你不得不去的话你会怎么做，编写这样的内容，如何标记之前访问过的顶点，您有我们的基本图形库，您知道这些想法，您认为，他就像让我们写一个更好的图形，你在说什么，我给我写了一个图。

你想在上面写一个更好的图，不，不，所以要保持某种布尔状态，我该在哪里，把所有这些布尔值放在这里，尽管我认为您主要是在给我我所得到的，想要更像我在哪里，我该如何记住这些信息？ 。

被访问过的人都被标记为常数，你可以用你说的选择的载体，我会说有一种包装，我们选择的向量，以便您可以使用集合并存储信息，在其中我会说而不是向量，可能更像是集合或地图，还是像这个顶点我访问过它是或不是。

所以一个顶点图是两个，布尔值或可能只是一组顶点，您之前曾访问过，当您访问顶点时，将其放置在集合中，完成后就可以将其删除，从集合中避免，因为他们不想不小心弄乱，图，但是是的，您也可以像在某些人中那样。

就像您参观了Boggle Square一样，您喜欢将字母更改为，另一封信-自己有一个面包屑，让您知道自己，是在做之前做的，好吧，那样的东西就是您将如何标记一个，所访问的顶点。

所以这是深度优先搜索我会告诉你深度优先搜索，这是一个很好的算法，因为谈论简单描述它很简单，实施起来并不难，你们以后会实施它，很明显，它无法通过任何特定方法找到最佳的路径。

它找不到最短的路径不一定找不到最短的路径，体重路径必然会偶然发现，但并非如此，保证这样做，所以这是一个缺点，所以可以保证，如果有，它会找到一个路径，并且很容易找到将路径作为矢量。

并忽略了想要看看它的人的道路，这些都是好事，但是，它不是最佳的，不会返回最短或最重的重量路径，另外一种算法，我正在快速地执行这些算法，我并没有花费很多时间，他们。

因为我有点想在下周晚些时候为你们节省一些，下一个我们要剩下几分钟，这就是所谓的广度优先搜索，告诉您他们做了什么深度优先搜索，深深地让我尝试尽可能走那条路，看看我是否必须到达那里或，不，如果那会回来。

广度优先搜索是相反的，让我们移动一个，每个方向的一点点，让我们搬到我的邻居那里看看，如果我在附近所有地方都找到金子，看看我是否，找到他们所有邻居都能看到的球，如果我找到一个目标，您会发现这是一个迭代。

深化搜索关于广度优先搜索的最好的事情是，保证找到最短的路径，最短的边缘，您将找到最短的路径，一个很棒的地方，我们在哪里完成了要搜索的算法，两件事情之间的路径，我们想要阶梯中最短的一件，作业分配技巧。

您以为自己在蜡上蜡，您正在编写广度优先搜索，学习一些空手道，而不是一两个，这是广度优先搜索的一个示例，你们正在寻找一条途径，将一个单词变成另一个单词，一次换一个字母，你们用了一堆纸堆和队列， 。

数据结构来实现您正在实现的算法，广度优先搜索将单词取出，然后按一个单词找到单词的所有邻居，搬来换一个字母邻居，你们这样做了，所有的邻居，并把它们放在一堆，并与你在一起，在作业2中实现了这个想法。

只是不知道它叫做，也许因此，如果您对广告资源进行广度优先搜索，就会发现以下内容，第一次看bdd的直接邻居时，我都不是，所以你看看他们的直系邻居B最后的邻居，寻找邻居的邻居，并最终将您引向我，这就是。

从领带到领带的最短路径，再说一次，我只想给你看一个很短的伪代码，但这不是，实际上，它与您的单词阶梯代码不同，您可以使提示提示记住，因为顶点字母Q最初访问时只存储起点，顶点。

然后有一个循环将顶点拉出队列并添加，它的所有邻居都怪异字母单词单词单词单词单词字母拉前面的东西，离开队列将所有邻居添加回队列中，这不是堆栈，只是个别的顶点，最终如果您标记了目的地，顶点为，就是这样。

我没时间了，所以我必须停在那里，但谢谢你，父母和学生在这里度过了一个很棒的父母周末，我会看到大家，在星期一谢谢。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P19：【Lecture 19】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

所以今天我们要结束了，但是您在星期五开始谈论，这是广度优先搜索或BFS专门讨论如何，最终找到要搜索的节点后，重新构建路径，首先，我们将讨论Dijkstra的算法，这实际上是一个，图表非常重要的问题。

可以，所以我们可以找到一条路径，这是深度优先搜索，我们可以根据数字找到最短路径，边的宽度优先搜索，但是我们能找到成本最低的路径吗，在边缘权重方面，所以我们将讨论Dijkstra的。

我们今天将开始讨论的另一种算法称为，这颗星基本上像Dijkstra的新版本和改进版，因此可以运行，快一点好吧，所以希望从周五开始看起来有点熟悉，广度优先搜索并没有在整个周末消失，但是这个主意。

在存储要查找的所有节点时进行广度优先搜索，在队列中，然后每次看到您标记的新节点时， ，你看它所有的邻居我想聊聊的主要区别，今天大约是如果我们有这样的顶点队列，您将永远无法，好吧。

所以我仍然碰巧看到了这个顶点，但这不是一个好方法，重建这条路径，以便能够做到这一点，对于每个节点，所以您知道A的邻居是BE和D，因此我们可以说，如果您尝试从中搜索，则以前是a，然后从那里去。

到F之类的东西，那是最大的不同，您将在家庭作业中执行此操作，所以我不想放弃，有关如何跟踪此问题的太多细节，只是想一想，你知道也许我应该如何跟踪以前的每个节点，什么做这个算法关于广度优先搜索一些好的观察。

总是会找到最短的数字或最短的路径，就边缘数量而言，如果不加重裂纹，那将是最佳选择，成本，但正如Dijkstra对于加权图所看到的那样，这可能不是，成本最低的途径之一是难以重建。

您在路径中遍历的边的实际顺序，因此使用DFS确实很容易，因为我们只是知道从矢量跟踪，顶点，但是在BFS中，您必须多加一些思考，每次搜索重建该路径深度会占用较少的内存，因为，没有整个队列，因此重建，路径。

但是BFS找到最短的路径，因此您需要权衡一些，可能会想，如果有人告诉您，您只需要找到一条路，在两个顶点之间，您对BFS有什么疑问？ ，在我们继续讨论Dijkstra的问题之前。

如果有人好奇我还有最后一件事，我会，谈论运行时，基本上是您一次遍历每个边缘，顶点一次，所以它是V加T的o，我们将谈论一件事要注意，这是au v + e吗，我们会看到Dijkstra的面积更大一点。

运行时，这就是为什么我们不总是使用Dijkstra的而是运行时相同的原因， DFS很好吗，所以我一直在暗示这个想法，有这个加权图，我们如何找到最短的成本路径，在现实世界中，这是一个很好的例子。

有时您知道而不是飞翔，从这里直飞纽约，在芝加哥停留可能会更便宜，等等，如果您更在乎金钱而不是像您这样的时间长短，可能想在芝加哥停留并节省几百美元的机票，所以，任何人都有其他类似的例子，例如哦。

现实世界中的图形，每个边缘都有一定的重量，您可能会在意最小化，边缘的长度与我们参观的地方数量的关系是的是的，因此，例如，如果您有一张城市地图，则可能需要等待，通过遍历所需时间的长度来确定边缘。

因为前进的方向非常不同，在旧金山的大街上走一英里我知道你是否，看过它的照片，但看起来像这样，因为它是如此陡峭，就像您知道的一样，一垂直英里，与正常街道右侧的一英里非常不同，因此，如果您要尽量减少该街道。

则可能不想走这条街，时间长的好例子别人有其他想法，另一个例子可能是，如果您喜欢服务器有时如何处理请求，像是根据那台服务器的延迟，您可能想要更多，很少相关的服务器在所有事情上的延迟都较短，那是另一个例子。

所以作为一个例子，为什么BFS不够好，解决方案好吧，任何人看到从A到F的BFS都会找到我会选择的路径，找到对X的正确路径，所以BFS会找到正确的路径，以便，成本是九，有人能找到更好的道路，是的。

实际上在那边，你曾经是这样的，所以总督，而不是九个，每个成本只有六个，所以有时会停更多次，总的来说便宜些取决于你的背部，所以如果这张图很简单，因为我们只能看一下，但是您知道可以想象成百上千个。

成千上万的顶点和边缘可能会变得困难得多，所以这， Guy Dykstra提出了一种基本上可以解决此问题的算法，因此， Dykstra在计算机科学领域非常重要，他获得了图灵奖， 。

有点像诺贝尔计算机科学奖，所以如果您看一下，赢得图灵奖的人的名单令人印象深刻，我最喜欢的故事可能不是真的，但就像我最喜欢的轶事有关， Dijkstra是你可以看到他的名字叫ijk，这就是为什么。

传说这就是为什么CS中的循环计数器以ijk开始的原因，因为，这个家伙说他在计算机科学方面很有影响力，所以他看到了这个问题，并开发了一种算法来找到最小的重量路径或最小的成本。

加权有向图中一对顶点之间的路径，因此可以解决，好的想法，我们需要从给定的路径中找到最短或成本最低的路径，顶点，所以不太理想，因此该算法不一定会找到，像两个好的路径之间的最小成本路径是的。

它很好地找到了F到a ，到e，但是想要找到B到F，则必须再次运行此算法，事情的基本前提是我们，每次看到一个新顶点时，我们都会用，我们已经看到的先前顶点中的一个，而不是Q，我们只是，盲目地和Q邻居。

我们将跟踪边缘成本，以达到那些，邻居，然后随着我们通过此算法将更新这些成本和，最终，我们将拥有成本最低的路径，因此伪代码会有点，涉及更多的想法基本上是从B 1开始，您在我们的示例中知道a ，成本为0。

因为我们已经在这里了，我们什么都不知道，关于任何其他音符的​​信息，我们只是说它们具有无限大的，成本，那么我们要走了，所以我们已经看到您在使用队列之前开始，使用优先级队列。

因为我们要基于边缘成本进行排序，我们将使用按成本排序的顶点优先队列，然后， PQ不是空的，我们要去DQ成本最低的节点，而市场是，拜访之后，我们将查看到达所有其他邻居的费用，然后说，好的。

所以到达所有这些邻居的成本最多是花费的成本，让我到达我正确的节点，加上到达我的邻居正确的边缘成本，所以如果我在节点B和，到达B花了七点时间，然后到达C距离， C的总成本最多为9，那么它的成本可能会更低。

比该节点的当前成本要大，因此，如果它小于该当前成本，则，我们会便宜一点，以Q结束，以较低的成本使那个邻居静音，如果它大于我们只是忽略的部分，因为也许我们可以通过，成本是8而不是9。

所以我们只用8来让cui ，那么我们需要记住必须经过哪些顶点才能使，同样，您对此有什么疑问，我们也会做一个例子，但是，好吧好吧，我们选择了我们想要从A到F或最喜欢的例子的方法，因此，为了做到这一点。

我们将使用某种着色方案，黄色表示它的末端很可爱，所以您知道我们仅在固化我们的算法时才开始，起始节点的成本为零，然后Y为节点，我们对此一无所知，我们所知道的，也许甚至没有办法在这种情况下到达那些节点。

图从a开始，然后绿色，这是我们访问过的节点， ，处理，然后从我们的优先级队列中进行DQ，所以我们的第一步是，获取a的所有邻居，我们希望将他们排入队列，是的，有人知道我们保留什么，队列应该是什么样子。

在我们成为优先队列之后，您应该知道流程后的样子，到，是的，所以你有D 1和B 2 ，正是这样，我们知道，以最高的成本成为可能-从，因为我们可以走这条边缘，我们知道我们可以做到这一点。

只需沿这个边缘右转即可花费一个，这样您就可以更新了，所有这两个成本，然后说好，我的先前工作已恢复到现在的状态，下一个节点是什么，我们将提出任何想法，是的，我们要看D，因为D的成本比B低，而那是两个。

队列中的所有内容都正常，所以它将查看D，那么D的邻居是什么，赫兹（Hertz）认为还可以，所以C的成本是，会结束Q好吧，听到有人说任何其他想法，我看到了一些，人们说三个。

所以从D到C的成本是2是完全正确的，但是花了我们一个人才能到达D正确的位置，因此，因为我们试图找到，从A到FX的距离，我们想找到以某点为代价的距离，从A到C变成三点，人们对此有何看法，好吧。

D会一直保持你的座位对不起，看到三个F ，的E并与9个对等排队，因此1 + 8，然后裘德被提示与5和E ，会加上3所以1加上这些边缘成本，因为到达D的成本，没关系，那么接下来要进行DQ的音符是什么。

有多少人认为B有多少人认为还好有多少人认为，许多人认为e我们认为人们认为GF我呢，好吧，我是，所以我想你们都明白了，对，B是下一个，因为它的当前建议成本为2，所以，我们看一下B。

那么BD和E的邻居是什么，我们需要做的是，带有D的任何东西否，所以我们忽略D，因为我们访问了D怎么回事，我们应该为你做些什么，我们要更改优先级还是将其保持不变，多少人认为改变多少人认为保持不变是的。

所以我们，希望保持不变，因为2加10是12，比3大很多，所以，到达e的最快方法显然不是通过V ok，所以我们该怎么办，再看下一个，或者说实际上是C和E之间的联系，所以我们只选择C 。

因为这就是幻灯片的写法，C指向H，FH也可以，数字16的优先级3加13关于X 2多少人认为，我们想要更改F的优先级，有多少人认为我们希望保持F的优先级，相同，好的不参与也可以，是的。

就像选举没有更好的投票率，你们所有人都可以做得更好，所以让我们尝试，再次有多少人认为我们应该改变，所以我们在看，有多少人认为我们应该改变F的优先级？ ，许多人认为它应该保持同样出色的出色性能，是的。

因为，我们的新优先事项我们知道，如果我们经历C，我们可以付出代价， 8之3加5和8之和小于9，这就是为什么我们要更新ok的原因，现在我们在看E这些邻居是Dean我们E的邻居是G ，我们要更新G吗？

有多少人认为是？有多少人认为现在可以，完全可以，我们忽略更新G接下来要做的是DQ ，嗯，抱歉，要成为D多维数据集的下一个名字是G狗屎，所以G的邻居是F。 。

人们认为我们应该更新F有多少人认为我们应该保持现状，五加一，所以fnaught变成六，那么我们的下一个DQ是f， ，因此我们发现优先级为6个苛性碱，即f-G /对不起a 。

-D-G-f如果我们追溯以前的指针，是的，你如何储存好，所以问题是我们如何知道，先前的指针是您知道F先前是G且G先前是D等等，嗯，所以这是一个问题，您必须考虑在做作业时，存储它们。

因为否则将无法执行此步骤，并且有很多，不同的方式来做到这一点，只是要有创造力， [音乐] ，是的，问题就像没关系，如果Indy不是真的，我们将使用无穷大，存在于计算机程序之类的计算机程序中。

而不喜欢无穷大，如何，我们会在每种编程语言中用C ++表示那个um吗，有这样的概念，例如最大int和最小in一些最小int ，就像最小的负整数值和最大的最大值一样，整数值。

所以有一些常量基本上代表了我的意思，这不是，正无穷大约为20亿，但这通常是，计算机科学家代表Vindi是的，是的，这个问题还可以，所以在PQ为，不为空，因此此内部代码找到或喜欢这样。

为什么我们在找到一个，继续进行下去，以便此伪代码可以找到，从a到图形中每个顶点的最短路径，但是在此，现在我们找到F，我们知道不会有更短的路径，因为，就像如果我们经历了一条较短的道路， 。

您的边缘权重是非负的，就像您必须经历额外的，边缘，因此这些边缘只会增加正确的成本，因此我们知道，不可能有更快的F路径，所以这是我们可以做的优化，因为我们知道我们是专门从A到F，而不是像find那样。

从A到另一个顶点的最短路径或最低成本路径，很好地捕捉图表，大家还有什么其他问题，迪克斯特拉的，因此，对Dijkstra的算法进行了一些评论，这就是所谓的贪婪算法，它是使局部最优的算法，选择。

希望可以导致全局最优，所以我们，采取似乎最好的方法，就像我们在查看每个顶点并说，成本最小的那个是我们接下来应该看的那个，然后，我们希望总体上能够像找到，所有路径上的最短路径，因此这是一个贪婪算法的示例。

如果，您对贪婪算法感兴趣，因此应选择CS161，因为他们会说话，关于这些很多，这的REIT似乎还可以，我们只是这样做了，它确实找到了一条最短的路径，也许那只是运气，也许我创造了这个。

以这种方式起作用的示例，但它之所以有效，是因为它总是，维护关于优先级队列的两个属性，因此对于每个顶点，我们访问了当前信息，或者您知道我们在PQ中将当前信息标记为。

记录的成本是该顶点与源顶点之间的最低成本，因此，一旦我们访问了优先级队列中的一个节点并对其进行DQ，就不可能再快了，到达该节点的方法，因为任何更快的事物都会像其他所有事物一样涉及。

优先队列中的费用不大于所访问的费用，节点，因此就像遍历任何其他节点一样，您将获得更大的成本权， ，然后对于所有未访问的顶点，那些仍然处于优先级的顶点，将这些优先级排队在优先级队列中，例如我们的费用。

如果只看一下，就知道暂时分配的是当前最短路径，在我们实际访问过的顶点处，因此可以保持这两个顶点，属性，这就是为什么它起作用的原因，这就是为什么dexter是一个非常酷的人，他想通了所有这些，所以好吧。

你为什么不尝试与合作伙伴一起做Dijkstra的，废话，看看进展如何，好吧，让我们来看一下Dijkstra的算法如何处理这些图，当我们启动将其顶点化的算法时，PQ中最初包含的是什么，从我们的关键键开始。

是的，所以容易，以优先级为零的起始节点关闭，好吧，那么我们要DQ ，我们要说的很好，这个人已经去过了，所以D治愈了，邻居B和G是的，所以B以优先权180进入，所以这里的边缘和，然后她以30的优先级进入。

所以要成为DQ G，因为G ，成本较低，所以我们将进行DQ，所以我们该怎么办，在看完GD后，会结束您的发言，那么一个人的体重是多少， D抱歉，我能听到，所以D得不到Priority One的帮助是的。

所以D进入150的多维数据集，因为花了30才到达G，然后G同步它，从G到D再花120欧元，所以总费用是150欧元，所以，我会说这个一零这三十个好吧，那我们接下来做什么q 。

人们认为我们dqb接下来有多少人，对不起，完全没有看到是的，好吧，怎么办，很抱歉，我们仍在查看G，所以对，nqa是什么， 50 30加20好的，接下来我们要做什么，好吧，所以我们访问DQ好吧。

我们要多少成本，我们要什么节点，结束q是的，所以费用高50，所以您可以更新b2b费用70，因为70是，少于80，所以改变这个，说70，我们想看的其他音符，从院长那里，花费130 。

所以我们已经有了QD 130好的，所以我们接下来要看的是哪种钞票， 70好吧，那么从B出发，我们将在Y处注视什么，以便使F具有成本， 80好吧，那么你们都可以看到绿色的吧，好吧，这怎么样呢？ 。

这是D当前的130f，在我的屏幕上看起来好多了80好的，这些费用分别为0 30 50和70，所以知道这样做的人- ，不，我们现在不去拜访您，是的，所以感谢D花费了130，您可以写下来，所以f花费了80。

我们已经做好了，所以D花费了120，因为80 240 ，我们需要添加到优先级队列中的其他注释，看到角色扮演Diaz花费120，所以CS花费是130可以，所以我们现在在这里做什么是的。

所以开始备份一个我不知道是否，我显然可以抹掉，我不能抹掉，所以从F开始我们是80岁，所以f ， QC的优先级为150，NQ d的优先级为120，然后我们将DQ D ，因为D 120正好小于150是。

好的，所以它将C更新为130，因为一旦我们查看D 120 Plus 10，它将为1 ，是130小于150是的，所以我们看问题是当我们在B时好吗，对于可能遇到相同问题的人，我将以任何方式回答，因此。

问题是可以的，我们处于磁珠状态，并且有一条从B到A的路径，花费20 ，所以我们不应该回头看看答案吗？ ，回头看看a，因为我们已经访问过a，因此您可以看到70 ，加20等于90，而90大于50则很好。

Texters的工作很好，那么好D是120，那么C就应该是130， ，那么H会是150。人们对这个例子有何感想？ ，关于Dijkstra的一般，是的， [音乐] ，然后，如果您去的话。

那么所有代表您的车上的权威，那么您就是，基本上，我们必须要有某种存储方式来关联，每个节点都具有与先前顶点相同的成本，因此例如，当我们查看何时处理E时，我们必须标记B ，我们喜欢旅行的G，是的。

我们给Ewing评了70分， ，他们以前很担心，所以您必须提出一些建议，像BFS，我们必须想出一些方法来跟踪，因为这个先前的顶点才对，是的，问题是说优先级队列具有，当时我们知道的最低成本是。

所以那是百分之一百，考虑它的好方法，所以只看四个顶点，从优先级队列全部访问了DQ ，优先队列中的费用对于那些像，仅使用访问的顶点即可达成协议，是的，这是您作业时必须考虑的一个问题，抱歉，请尝试，好吧。

是的，是的，所以在这种情况下，答案是，从例如变成a是B-f-D-C-H，它的成本C是路径C ，花费了150 ，好的，所以请记住当我今天谈论BFS和DFS时，他们记得，那个运行时是什么，哦。

V +寻求我们对每个顶点进行一次检查， ，迪克斯特拉的每条边都有一点不同，所以，优先队列的工作方式，因为我知道你们都，在您的优先队列上工作时，您可能会注意到，我们最好的。

可以做的是拥有NQ和DQ并更改log n的优先级，这是您的关键，优先级队列具有运行时间，因此无法在恒定时间内执行这些操作，喜欢在恒定的时间内进行所有这些操作，所以基本上每次都，您必须更新优先级队列。

它是对数V操作而不是O ，一个操作的原因，这就是为什么您会像V log V Plus这样进入，假设您的图形已连接，则意味着每个顶点，至少有一条边可以写成对数V是的，所以，它与您每次都息息相关。

因此每次您想添加当前，节点，您正在查看该节点正确的所有边缘，因此对于每个节点，边缘，您最终只能查看优先级队列，因此您可能不得不更改，优先级，例如每次您看到边缘时，这都在改变优先级，作为对数V的操作。

因为您对我们的一方是一个很好的问题，如果您是，对所有这一切都感兴趣，例如161是一个很棒的课程，可以带他们去看看图，算法和大O以及非常详细的信息，但士气就是这一点，幻灯片是。

基本上Dijkstra是解决该问题的一个非常好的算法，可以解决，但是如果您只是想在两个节点之间找到一条路径，那就是，最好使用BFS或D上的DFS，因为它具有更快的运行时间，好吧。

让我们谈论一个像Dijkstra的plus plus一样的恒星，所以我们说，试图找到一条从A到C的道路，假设这是您的，绝望，你不能通过正确的，所以如果我们是任何人有任何。

Dijkstra算法的想法看起来就像Dijkstra算法一样，这是Dijkstra的算法，如果可以的话，理想的情况是在这里，它不知道正确地做那件事，所以基本上你会发生什么，喜欢它的人会在这里探索。

然后在这里喜欢这里，正确进入C，因为它正在注视着所有方向的分支，不知道像嘿，我的目标在这里，所以我也许想尝试，尝试以这种方式移动，这样的问题是我们唯一的信息是，考虑到Dijkstra的距离是。

从起始顶点到当前顶点，我们在右边，所以我们知道了距离，从A到B，我们只是在做这些，我们一直在跟踪这些成本，如果迪克斯特拉的人足够聪明，你可能会像你一样遥不可及，可以尝试根据某种方式猜测从B到C的距离。

启发式的好吧，就像我们试图从你那里知道这里到这里，我们实际上最终倒退了，这不好，您也可以看到，在这里，因此，如果我们要尝试摆脱这种情况，请确保此上下文正确，是您下一件作品的样子。

所以如果我们试图从这里走到这里，看到就像走到角落一样，就像没有办法，将会是最快的道路，就像我们一直在这里和这里所知道的那样，很多，额外的工作吧，这个想法还可以。

让我们尝试为算法提供一些有关此未知数的提示，从B到C的距离，也许可以让我们变得更聪明，决定，而不是盲目地向各个方向走，以便做到这一点，我们将使用一种称为启发式的东西，基本上是求和。

指标就像是对某个未知距离的猜测，因此很明显，如果我们知道，我们可以使用的距离，但这就是我们要解决的问题，那不是一个很好的解决方案，所以从本质上讲，这只是在尝试，像一个非常准确的猜测。

这些启发法有什么重要意义，是他们需要始终低估成本还是喜欢做对，但要知道，确切地说，它永远都不能高估成本，所以一个很好的例子是，您尝试了解自己是否正在实施Google Maps，并且。

试图找到从旧金山到纽约的最便宜路线，绝对的最短路径就是你所知道的实际路径，旧金山到纽约的直线距离，因为，没有比沿着直线前进更快的方法了， ，就像他们实际使用启发式方法的一种启发式方法的例子。

诸如此类的事情也有试探法来尝试预测给定的电子邮件是否，是否为垃圾邮件，并且可能查看发件人的收件人数量密钥，像if这样的词可能包含尼日利亚王子一词可能是垃圾邮件，所以。

这是计算机科学中其他地方使用的启发式方法的一个例子，对于一颗星星，我们需要提出一种启发式方法来猜测距离，然后，您会听到所有可允许的启发式超级幻想术语，意味着我们需要并且我们永远都不能高估距离，因为。

如果我们高估了距离，那么我们就会陷入错误的情况，关于我们好像走错了方向，也许我们会选择一个，最佳路径，所以基本上恒星是如何运作的，就是整个a2b事物，与Dijkstra相同。

但是从B到C使用这种额外的启发式方法，因此您，希望将两者都纳入我们的优先事项，因为我们想看看，在我们查看之前，我们认为与目标的距离较短的节点，距离目标较远的节点，就像我们不想，向后走到某个地方。

您对此有什么疑问，是的，这是一个很好的问题，例如，您如何选择一个，启发式um基本上，您必须对图形有所了解才能，选择一种启发式方法，因为如果您一无所知，很难，就像您不能依靠某种信息进行启发式搜索一样。

在Google Maps示例中，我们知道就像您不能在两个之间，放置比直线距离快的任何东西，但是如果要映射，这样的Wikipedia无效，因为您没有像这样的概念，直线。

所以它实际上取决于获取有关您的图形和，知道一些关于您的图的信息，这就是尝试出现的示例，使用启发式方法，您认为此图将是一个很好的启发式方法，其中，你知道旅行到一个广场，你只能这样旅行。

这个方向或您无法诊断的方向，是的，所以一个建议是可以的，就像我们可以使用，这就是欧氏距离这是您在几何学中学到的东西，可能值得像x的平方根减去x1减去x2再加上（如果有的话） ，看到了。

但是您基本上知道是否要绘制直线距离，所以是的，我们可以完全做到这一点，对于，请记住，是否存在一种更简单的启发式方法，如果，我在这里，我想到达这里是我需要走的最少正方形数，有人会说听起来正确吗。

我只是听不清楚，回来，像是的，你像是在我们一样举起你的手，我们需要到达这里，我们只能说好，我们必须喜欢Moute ，你知道至少我们要一直走到这一步，这样，因为我们不能做任何对角线的欧几里得距离，工作。

所以这是您知道的直线距离，但这仅仅是，易于实施，特别是使此幻灯片看起来像，好多了，因为如果您的直线距离不是我要做的所有事情，所以是的，我们会说您知道在这种情况下，要花六点时间才能看到，从这里开始。

因为您必须走到这条路，这样，好吧，真的，基本上很快，所以这是Dijkstra的代码，这是明星，迪克斯特拉（Dijkstra）是明星，你并没有改变太多，最大的不同是，您必须先了解费用和优先事项。

然后再将其合并，启发式的，所以是的，我们需要付出成本再加上启发式的知识，将原始节点优先级存储为零，现在我们将从，启发式，然后在我们排队时，我们需要将启发式纳入，从那个节点到最终目标，哦，太好了。

非常感谢，祝你有美好的一天。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P2：【Lecture 02】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

上次谁告诉我，如果您怀孕的话可以sc猫砂，我要在我爱人的妻子中使用那个，所以谢谢我，有几条公告开始了我们的讲座，我们本周将运行以帮助人们处理各种事情，因此，一个是我知道你们中有些人来自106 AJ班。

JavaScript，您知道，由于该类是相对较新的类，因此我们认为，从那门课和那种语言过渡可能会更困难，在106 B中向我们提供JavaScript，因此，如果您修了106 AJ，并且需要帮助， 。

从语言转换过渡到今天晚上7点，晚上在惠普大楼101室再次面向106名AJ人，我要说的是它将着重于JavaScript和C ++之间的差异，如果您来自Java的6/8或常规版本，或者来自某些。

其他类型的编程背景左图标或我推荐的东西，也许不参加本节，因为它不会针对您的特定需求，需要我鼓励你今晚去，在7点，我们小组的负责人Shreya将主持该次会议，好的， ，您可能想知道的会议是明天晚上七点。

在Tresidder，我们要做一个可爱的创作者，帮助会议，因为我认为很多人最终陷入困境或中途，在整个设置过程中，使一些Creator正常工作并出现了某种错误，信息弹出，他们不知道如何解决它。

所以请带上笔记本电脑，我们会为您修复它，希望它能正常工作，所以明天，在7时令人印象深刻，将有一些我们的TAS和一些我们的，那里的部门负责人我们将会有几个人在帮助，所有出现的疯狂可爱的创作者们。

我鼓励你去，是的，我明天也要给你们发送电子邮件，我希望您注册各个部分，我希望您提交以下信息的偏好设置，次您将在本周四到现在之间进行操作，周日，然后在下周初，我们将把您分配到您的部分，以便。

我要开始提醒您明天您将无法做，直到明天下午才开放，直到星期四好，所以，就像回顾一样，我们现在所处的位置您知道我们所做的很多事情，如果您单击以下链接，则会在讲座页面下的网站上发布： ，说讲座可以向下滚动。

我会像全班视频一样发布，我在这里记录在计算机上的代码，我将发布所有我们编写的代码，幻灯片，让我们the了一口可爱的创意项目，你知道我会在下课后再做一次，好吧，所以，让我们回到它，我们正在学习C ++。

我们正在学习我，开始谈论函数嘿，所以我写了一个叫做Song的函数，打印一些消息，一些我认为有用的歌词，然后我，重复两次，我从程序的主要部分两次调用了该函数，好的，这样所有的作品都可以正常工作。

但是在演讲结束时，我向您展示的是如果您剪切此功能并将其粘贴到，就像同一程序不再编译一样，这里产生一个错误，它说对不起，我无法控制它说这首歌是，没有声明，这实际上只是一个C ++怪癖，它必须要有东西。

在Java或JavaScript等许多其他语言中使用它们之前声明，您可以调用一个函数，然后在文件的较低位置写入，该函数的定义，它将理解它将找出C ++，而不是，如此之多。

这是令人讨厌的解决问题的一种方法，就是始终，在main之上声明函数，但是我认为一个很普通的样式是，首先是主要功能，然后是其他功能，因此如果您要这样做，则，您需要执行的操作的方式现在让我跳到幻灯片上。

这是我们遇到的问题，这是一个不同的功能，示例，但是如果您尝试调用一个函数然后编写其主体，您将，得到一个错误，该函数做什么只是计算，但在C ++中解决此问题的方法是使用一种称为，函数原型。

您要做的就是写出标题，返回类型的名称，参数类型，然后放入分号和，基本上，您是在告诉编译器，就像我保证的欠条一样，以后我要写这个函数，所以请不要给我编译器错误，如果，我尝试调用该函数，现在程序可以运行了。

程序可以编译了，所以我如何做到这一点，我认为很多程序员都是这样做的。

该函数我在哪里，你在这里写函数，然后一次，完成编写后，复制标题，然后转到此处的顶部，该程序导入后，您粘贴相同的标题，但您将，分号，再一次称为函数原型好吧，现在我编译，而且它的工作原理和行为方式相同。

所以这只是一点C ++问题，我们必须解决，好了，如果您知道是否有任何参数， ，这需要一个索引，我必须在这里和下面的X处写索引，那里的标题将从原型到主体的匹配，稍后再进行功能介绍，让我再谈一些同类的功能。

关于我今天要去听课的地方，所以让我实际备份一些幻灯片。

这来自于本书的第2章和第3章，您甚至无需编写某些函数就可以调用的函数是，关于数学计算的东西，有一个名为C math的库，您可以，包括使用那些尖括号的海图包含，记住有时包含和有时会有引号，方括号记住区别。

通过了解我对C数学库有什么了解，那些角度记录，这是一个标准的系统库，附带了正确的语言，来自斯坦福，不是我们本地的项目，而是全球的，是的，所以每个C ++安装功能都应附带此功能，有点熟悉。

大多数语言都具有绝对的功能，取值三角函数平方根这些东西都在这里，在Java中，我知道并非每个人都来自Java ，登录C ++，您无需编写数学点，而只需编写函数的名称，说符号或平方根或电源好吧。

所以这些都是有用的，我不会去，他们非常详细，因为我猜你已经看过这种，操作，之后我们可能需要它们，好吗，所以我在哪里谈论，我们讨论了原型的申报单，让我教你一些。

C ++对函数所做的不同操作是一个很酷的功能，它被称为默认参数，这是如果您想拥有一个其参数，可选的值，您可以在函数的标题中声明参数，但随后您可以说出池并为其赋值，即主叫方，可以传递一个值。

或者如果他们不传递一个值，那么您将使用此默认值，因此，我写了一个叫做打印行的函数，你传递一个数字和一个字符，它将打印该字符重复多次，只是一个小工具，函数，但我决定的是如果您不传递参数，我将使用。

默认重复次数为10，默认字符为星号，因此，平均只有五只幼犬的宽度而不是字符，默认，字符传递这些参数，我将做一个星号的10个副本，这是一个，有点愚蠢的例子，但我只是想表明这个想法。

这里的排序问题是参数从左到右，所以，如果您省略此示例中，它将无法通过没有宽度的字符，您只能在正确的地方忽略它，所以无论如何，有时在语言中有用的功能允许我们拥有一个变量，函数的参数数量还可以。

Java没有javascript有，但是JavaScript几乎允许任何东西，因此C ++和JavaScript共享，在某些方面作为默认参数，我们本周不会使用太多，我想谈谈参数的工作原理。

因为C ++ ，与其他语言有一些不同，所以有一个概念，可能不知道其名称，但您可能暗中了解它的名称，称为值语义，这意味着当您传递参数时，您实际上是，这样做是为了传递该参数值的副本，从而，这表明，例如。

在此程序中，我试图编写一个，称为swap的函数，您传递了两个is，我交换了它们的值，以便，交换函数a的末尾的值曾经是一个无檐小便帽，他，评估需要正确，这是我输入的三行的结尾，尝试将这些值放入a中。

然后将x值放入B中，所以最后，该函数的值我已经交换了值，但是当我回到我身边时，我却很害怕，值仍然是x + y，我还没看过，您是否了解为什么这样的情况，例如功能交换并没有真正做到。

任何您了解的内容都可能看到了，我们看到的地方，来自，因为这些变量是朋友或B，这些变量成为， x和y的值就是这样，所以如果我交换ASD，我交换的副本是，不他妈的原始变量好吧，这就是所谓的值语义。

这个大问题的幻想术语不是每个参数在，传递参数时，您可以想到六个示例之一吗？ ，您更改了它们的值后，您仍然会在主菜单或，在运行时或在每个被调用的前沿，如果您将基因对象传递给其他任何对象。

如果您传递了数组然后可以更改元素，则可以通过yes ，在阵列中，然后您回到我面前，阵列仍在更改，我是的，所以您在上一期中看到了某些价值，当然，当您通过它们时，它们的确会发生变化。

但是像intz这样的简单事物，它具有复制权，因此进行复制的想法就是这种价值语义，认为其他形式的行为可以使您传递某些东西，并且能够，被改变，这是另一种称为参考的语义，语义，所以我想再谈一谈参考语义。

当您传递参数时，您实际上携带的是原始变量，在多种语言中，下一个参考语义的一个功能是，由数据类型自动确定你们刚才说的很好，传递它共享对象的数组，因此隐式看起来像什么类型的。

您传递的值会更改参数将使用的行为，但如果不是，它在C ++中的工作方式，每个数据类型都可以作为值或，作为参考，所以这段代码就是传递示例，整数作为引用，所以这意味着我们要做的是编写一个，在该函数中。

参数中的变量类型后面的与号和，当我说交换是百分比a和人B时，这意味着什么，确实是我们的X＆Y ，他们是相同的他们不是复制他们是彼此相同的名字， a和B是x和y的别名，所以如果我在那里修改a和B 。

它确实确实在这里修改了数据库或x + y，所以现在最后一个函数，幻灯片的输出是1735，但是这个是35，确实将它们交换了1735 17 ，像Java这样的语言，如果您将信息作为参数传递，然后。

想要更改信息或计算新的东西，您将如何获得，从函数返回到main的信息将返回到您调用的位置，通常使用return来返回值C ++，您可以返回值，或者您可以这样做，这是从，函数，您将其作为参考传递。

然后更改参考，指的是这样一种有趣的概念，我们将利用，我们在编程时会遇到这种情况，因为基本上我们想要的任何数据类型，使用它作为参数，我们需要确定在传递它时是否要复制它，或者，我们是否要在通过时分享它。

这是我们需要做出的决定，这的特定示例是一个称为输出参数I的示例，不知道您是否曾经看过xkcd漫画，这是一种愚蠢的怪异漫画，在网络上，他们有一件有趣的事情，就像您可以约会那些，距离您的年龄不远，但更多。

只是一个愚蠢的想法，如果您，想写一个函数来计算我允许的年龄范围，根据这个愚蠢的公式，你会怎么做，因为你需要，返回需要返回最小年龄和最大年龄的两件事，你知道我的意思的范围，那么你如何很好地返回两件事。

不能，但是您可以有两个参考参数min和Max可以填写，这些值，并且基本上将这些值发送给调用方，因此，您只需过去48年的中世纪年龄， ，我在这里是程序的主要部分，然后是这些变量，不论年龄大小。

我都会根据此最小值和最大值填充它们，公式等等，在函数的末尾，Young对于男性具有这个价值，而old具有Max的值，所以我已经使用了这些参数，传递信息，但提供存储输出信息的存储空间，超出功能范围。

所以实际上您会注意到我什至没有分配，您对它们主要感兴趣的任何值都可以将它们传递为，参数没有任何价值，因为重点在于，不使用只是腾飞的值作为新值，而是替换任何值，值曾经是可以的，所以这个想法称为输出参数。

，他们活泼开朗，他们有钱，所以可以，我希望他们也能清理垃圾箱，但是无论如何，这就是，输出参数，这也是发送两个，信息，如果您只打算返回一件东西，则可以只使用一个，为此返回，但由于您要输出两件事。

因此这些参考，参数是不错的选择，所以嘿，让我们练习吧，写，等式叫二次方程，你知道二次方程就可以了，在2a二次公式上的正负b平方负4ac ，解形式为ax平方加BX加C的二次方程等于0，因此如果。

您想将二次方程写为C ++函数，需要的参数以及将传递的参数类型，参考，值8老板会传递给您什么，好吧，B和C，所以我让我开始写作，你告诉我该怎么做。

在这里，嗯，这是最后一个挠曲程序，我要关闭我已经完成的那个程序，这里又有一个，所以你要我写一个二次函数，然后你，在C中的it B中说，以匹配平方加BX加C等于其他。

像这样的输出参数是二次方程通常具有，并非总是两个真实的根，但通常如此，所以这些根将是实数。

我将这些根源介绍给调用此功能的人员，好吧，是的，我通过引用将它们传递给他们，就像那些最终成为实数一样，因此，也许双“＆”号的根为一，而第二“＆”号的根为二，或类似的权利，您可能会说您想退还他们，但。

由于其中有两个，很难归还，因此您必须归还，他们的阵列或一些看起来很傻的东西，因此，只需将它们作为参考，并像我对迪克的kcd所做的那样填写，约会的事情，该函数是否在左侧返回任何值，我认为。

结果是这些根源正确，所以我认为这是我需要做的主要事情，产生，所以也许我不需要返回任何东西，我只是使用输出参数，输出您可能在想的信息，为什么我不只是使用C输出来打印，结果的根源您为什么认为这可能是。

是将结果存储在这些变量中还是更好地进行打印？ ，还是两者兼而有之，或者您如何决定这样的事情？ ，是的，他是对的，如果您将它们打印得很好，它说的会更加个性化，您可以在控制台上看到它们，但是它们消失了。

如果您想计算它们并将其用作更大的一部分该怎么办，计算或程序中的其他内容您基本上无法将其打印出来，它已经消失了，因此返回它的功能更加多样化，完全正确，因此，我认为我们应该这样做，但你知道这个主意是。

在缅因州打电话称这件事就像在这里，我要声明，一些变量来存储路线，我不必给它们任何值， ，然后我将a和B与C的传递值称为二次传递值，然后这些，变量是BR将要存储在其中的结果，计算好的快速问题。

为什么我不通过这些作为参考？ ，为什么不对B和C进行in和符号，我该怎么办？ ，决定你怎么看，是的，我不会改变B的值，和C，为什么要确保您知道自己并不总是想正确分享事情，我的意思是。

您是否与朋友共享电话？没有，您想拥有自己的空间吗？ ，好吧，您确实与某人合住了宿舍，也许您希望您不，写，所以您可能希望删除该“＆”号，然后再删除，我不知道这是什么比喻，但是是的，我想如果您的目标不是。

修改不需要的内容以使其成为“＆”号和一些参考，学生开始担心效率，例如我是否可以参考？ ，内存可以更快地运行吗？不必担心它可能在某些地方，微观层面，但不足以解决问题，编译器确实擅长，无论如何都要优化。

所以这不是使程序快速运行的方法，担心或如何保存内存回答有四个字节的内存，不用担心，好吧，让我们在这里实际进行计算，请记住，二次方程式为负B加或负基B 。

在2a处减去负4ac的平方，对吧，让我们看看我是否可以尝试这样做。

负B部分，您不能说加号或减号，所以我们将其作为加号，和减号加上平方根，如果我想要平方根就是其中之一，看到数学函数，我可以说喷射喷射来自于。

我们的程序的平方根是b平方减去4ac B乘以B减去4 。

乘以C，然后是2a以上的全部，所以所有这些，在那里被2a除，所以右边是根1，然后根2相同，但是，而不是加号-因为加号或减号是我认为如果，您想提高效率，可以将这部分拉出来不是，叫行列式或尖叫或类似的东西。

所以也许我会打电话给，我忘记了判别双精度D等于哪个，所以我也许会，说D，所以我不必两次计算该东西，或者我什么都不知道，写出来，你可以在这里优化一点，然后再优化，成为根2，就是这样，我希望计算出两个根。

，公式，所以现在我在缅因州这里叫它，让我们看看是否有，正确的答案，所以它说根是4，负1是听起来正确X ，减4倍X加1我认为看起来不错，是的，我们在CS中，这几乎是强制性的。

我们所有人都会像基本简单的代数一样吸取数学，和数学之类的东西，但是我认为我发现我最尴尬了，当我尝试做加减运算时，看着你的人越多，你就不能像一位数字或，无论如何看起来都在工作的重点，例子是玩参考参数。

只是谈论参数，通过C ++传递，所以你们对此有疑问吗？ ，参数是的，哦，这是一个有趣的问题，所以如果这是一个参考，那么如果我刚刚写了，像42在这里，所以现在像42是路线1所以现在我要更改42的值。

成为其他值，例如42岁时存在生存危机， ，现在还有其他一些价值，答案是不起作用，我是说我可以告诉你，如果您尝试编译，它将说我的意思是该错误使您感到困惑，基本上不能使用带有文字双精度值的双引用。

传递一个文字值，只是一个数字，作为参考参数，您必须，传递一个内存位置，基本上是一个变量，你必须传递一个，可以在内存中被引用是的，这样就不会起作用了，关于参考参数的问题，是的，此程序假定。

二次方程式有两个实根，但并非总是如此，这种情况我认为您确定的方式就是您查看此D ，在这里DI相信的迹象告诉你有多少真正的根，所以我认为，只是为了继续前进，我要把它弄碎，但是你会。

最起码的话假设有两个真实的根，否则你会说在D上做if-else ，正弦值，因此您将需要检查是否有，是不是有两个根，是的，这对于B和C的某些值是不起作用的，如果我传入一个新对象该怎么办，是的。

我看看你是否在某种新物体中害虫，我的意思是我会说，简单的答案是您传入变量链接，因为变量名称，代表内存中的位置，实际上引用就像我想要的，从主共享到二次共享该内存，因此您无法传递任何，没有存储位置。

它可能是变量的名称，可能是，数组的索引，它必须是您已分配放置空间的地方，一些东西，最简单的答案就是变量，所以如果你只是，声明了一个新对象，就在我有此突出显示的地方，将其存储为任何名称，但也不希望这样。

所以是的，变量名是最简单的答案，很好的问题了，是的哦，记录默认传递的是什么类型的东西，答案什么都没有，然后我将讲到每一秒钟，每件事都是作为副本传递给C ++ ，除非你放了一个＆号，所以我可能会破坏了。

一分钟，但是就像你有一个大的东西，比如一百万个数组，任何人都将其作为参数传递的元素，您实际上不想复制那些，数百万个元素占用大量内存和时间，因此您实际上会，通过引用传递诸如此类的某些信息，但您会做出。

一定要放那些安伯森一家，但你必须做到这一点，因为人们永远做不到，为你，你总是必须决定通过事情，通过引用自己，所以您只需要考虑一下，您不需要多考虑的其他语言，所以我想说。

我想说的最后一件事是关于函数和参数以及东西，解决一个大问题，您必须考虑如何将问题分解为，小块，有时我们称其为分解问题，是好事还是坏事，我不会花时间在106 B上讲我，我想解决一个主题时就想到它。

但是我确实认为这是一个主题， ，学生可以在我已经在课堂网站上写了讲义的地方复习，在讲义区域，我将其称为程序分解讲义，建议您看看它，其中有一些我认为的代码示例，当你上交作业时，很容易沉稳，没有那么富有。

我们将对您具有良好分解代码的代码进行评分，所以也许您想，查看讲义中的一个好例子或一个反例，或两者兼而有之，他构成了一个问题，你肯定知道，函数的大小优于其他函数，但存在某些依赖性。

在比其他更好或更差的功能之间，如果您觉得自己很生锈，建议稍微刷新一下，关于如何分解一个大问题，好吧，我认为是一种很好的简单启发式方法，如果您查看缅因州，缅因州是否对总体。

程序将要做或确实意味着所有不好的事情或仅缅因州，缅因州有一条线跳到其他地方，而另一处则完成所有，缅因州的工作可能也很糟糕，应该让您知道其中大部分调用的少量行吗，其他功能一起做大块的工作，好吧，去看看。

讲义，如果您想了解更多信息，以便我继续前进，那就很多，每堂课都要包装材料，所以我想谈一谈弦乐，在C ++中，您可能已经了解了字符串，但是我将着重于， C ++中不同或独特的事物，所以您知道字符串是，对。

它是一个字符集合，所以如果您说string s等于您好，想要使用字符串，您必须包括一个免费的库，因为没有用，在C ++中免费，所以您说要包含字符串，并且要有尖括号，这样您，知道这是系统问题。

现在您可以说string s等于hello string ，可以是从零到多的任意数量的字符，所以很多，您对Java或JavaScript的字符串有很多直觉，在这里会很好，就像它们的索引从零开始， 。

您可以切出不同的字符，并可以进行操作以大写，小写并转换字符串并创建子字符串并搜索内容，就像这里的很多东西一样，只是方法名称略有不同，或者，坏消息是C ++具有两种不同类型的字符串， ，导致错误。

我将尽力在一分钟内帮助您了解差异，但这很糟糕，这不是马蒂不喜欢的许多事情之一， C ++是他们弄乱了两种类型的字符串哦，好吧，让我，给你看一些例子，所以这里有一些更熟悉的东西。

你知道如果你声明一个字符串，那么字符中的索引从零开始，在此示例中，索引从零到七个独立字符，如果您来自以下位置，则它们本身将存储为称为care的数据类型的值，如果您来自JavaScript。

则Java与Java基本相同，并没有真正的概念，即使只是，在C ++和Java中仅一个字母，各个字符是不同的，称为care的类型，它是原始数据类型，因此如果您要访问，您可以使用方括号来实现单个字符。

例如s括号， 3是索引3处的第四个字符，它是字母D ，如果您要访问个人，这里的示例在Java中很酷，性格你还记得怎么做吗，这里有一个叫做care的方法，还有一个叫做substring的方法，所以。

几乎没有什么不同的语法，实际上，该Intex稍好一点，一小会儿C ++比Java更好的功能谢谢，嗯，存储个别字符，因为这些护理值可以是，自由地转换为int和从int转换的字符值实际上只是，整数编码。

因此，如果将字符转换为INT，它将给您，一些数字，我们稍后可能会讨论，但是无论如何，这是里面的内容，一个字符串，您可以执行各种操作，在字符串上，您可以用加号连接字符串，例如，如果我有字符串Mar 。

我可以将Mart关联起来，这很酷，您可以在C ++中做的一件事，如果您可以询问哪个屏幕出现在屏幕的前面或后面，您将无法使用Java进行操作，其他顺序，也可以通过说等于来询问它们是否彼此相等。

等于或不等于，所以如果我问s 1是否大于2 ，字符串Marty是否比字符串晚于字母顺序， Cynthia区分大小写，它使用这些数字ASCII和涂层，比较，但这是比较字符串顺序的好方法，您可以。

说等于等于不等于询问街道是否等于特定文本，还是没有用Java，您记得您不应该，使用equals equals比较Java JavaScript中的字符串，Java可以。

记住如何比较一个字符串和另一个必须写点EQ的字符串， UAL就像方法一样，C ++做到了这一点，您可以说，像其他所有酷的类型一样，等于等于，这里很好，嗯，一件有趣的事，这是微妙的，我认为这将是。

一些学生迷失了Java和JavaScript中的字符串被称为，不可变的字符串，一旦创建了字符串，其值就永远不会改变，您可能会说，那不是真的，我一次做了一个字符串，然后我，大写它完全是你错了马蒂。

但实际上你，是不是您创建了一个新的第二个流，将其大写并替换了，第一个和第二个您从未真正更改过字符串，使它只是用C ++中的其他字符串替换它就无法更改，字符串，这样您就可以像调用故事一样调用这些方法。

那里存储了什么，如果还有更多停止代码，可以停下来停下来，我想我是，与Java稍有不同，但在大多数情况下可能不会影响，您的编码风格非常多，这些只是您可以做的一些小事情，用字符串做，所以是的。

我承认我没有向您展示该方法，但我只是，举个简单的例子，我认为这是比赛需要索引的幻灯片， ，从那里开始的长度，那么多字符将它们切出，这棵树是的，我比辛西娅大得多，军医命令比看到的要大，所以后者越大越好。

如果排列成较小的，则较早的方式与以intz相同的方式较少，首先是大不稳定，后来只是按字母顺序比较，实际上当我制作幻灯片时，开玩笑是因为我和这个叫辛西娅·李的女人一起上课，我只是，想表现得比我还大。

所以我不知道哪个好笑，她的距离比我还远，但我在溪流地带我变得比，她至少嗯，所以这里有一些这样的方法，我猜是，这些方法是不言自明的，也许是不同的，您已经用Java或JavaScript调用过的名称的名称。

例如，在Java中，您可以说出子字符串，但是在C ++中，它是substr，但是您知道我的意思，你可以说找东西没什么不对，我认为这在Java中称为索引，您可以要求输入相同的长度，多种语言。

所以我对这些方法不甚了解，也不应该太，令人震惊的可能是，唯一奇怪的是当您搜索事物时，说在这些方法中找到您通常知道的东西，返回一个int像发现什么索引一样正确，如果您说Marty员工并搜索步骤。

它将找到6的索引，对，因为S从那里开始，但是如果您搜索某物，在大多数语言中都找不到，因为它返回的是返回的英寸数，表示未发现实际上像一些负数一样，不是，在C ++中找到负一错误，它不返回负一错误，回报。

所以有点愚蠢，所以有些学生会写等于吗，否定的，并且永远都是假的，因为它暂停或返回，随便什么，但我不知道其中有些奇怪，但我认为这是，在这一点上，可管理的怪异对到目前为止关于，字符串方法是的，哦。

点比较它很像Java的“比较”概念，如果您有两个字符串，则传递到哪里，则少一个将是，负数与相等的负数相比更大，则为零，如果您左边的那个更大，它将是一个正数，因此它返回一个。

有符号整数表示两个字符串的相对顺序，是的，当我向这些表格显示斜体字或，粗体就像占位符部分一样，无论变量是什么，叫你会在那写那个变量名，所以如果你有一个字符串，叫名字。

你要写名字点比较名字点水平线其他字符串，是的，为什么在暂停中输入字符串，为什么不在引号中，当您想创建一个新值时，该字符串是一些变量，因此，他们已经确定这是一个变量，并且变量名称不会输入，带三个值的引号。

所以这就像一个附带的筛选库，内部变量，好吧，我想要一些数字，这是一些魔术数字，这可能是一个很大的数字，一个非常小的整数，所以无论该数字是多少，您都可以。

希望看到我们始终可以正确尝试，所以我们先包含字符串，然后再，字符串名称等于Marty步骤，然后让我们找出名称，然后，让我们看看暂停是否是暂停indle我的猜测有些疯狂，我认为是因为它可能不在该索引上。

所以，这意味着我猜它不在任何地方，是的，你去那就是我不知道，但这就是n暂停的值。

好的，另一个问题，这个数字代表什么只是一个常数它只是一些魔术，数字，它可能是64位整数的最大可能值，整数，所以它可能就是它的最大值，在字符串中可能找不到它，所以它只是一个。

恒定值基本上您不必担心该值是多少，寻找可以的东西，所以这些是字符串，这里还有一些字符串，我们在斯坦福大学觉得C ++字符串所缺少的功能，这对其他现代语言的Java JavaScript很有帮助。

所以我们做了，引用中名为stir Lib的图书馆是我们当地的斯坦福图书馆，它有一些，像开始这样的功能，所以它以大写到小写结尾，这些不是，在默认字符串库中，我们还包括一些用于。

将字符串与其他数据类型相互转换，例如仅将整数转换为，这种东西加倍，C ++包括这些东西，其他方法，但是很难做，我们想让它更容易一点，关于语法的事情是，我们编写的方法是外部的，函数。

您必须将字符串作为参数传递，而不是，上一张幻灯片中的那些是字符串内部的方法，说出流名称，然后说一个点，然后说出您想调用的方法，例如，例如，如果我想做大写版本的martístep，我不能。

过来这里说大点的名字点，方法不是自动，完成任何事情，因为没有这样的方法，而是你要做的就是你，包括这个混乱的Lib字符串库H，然后再次在这里您仍然不，用大写字母说，而不是用大写字母说。

函数返回字符串的大写版本，因此您必须说出名称，等于它本身的大写形式，类似于您可能使用的形式，记住从Java之类的东西，所以现在当我打印名称时，这是Mari步骤，大声对你大喊，所以在那里这些功能还有其他。

该库中的函数，您也可以在课程网站上查看，是其他功能，是所有这些之上的，所以这个想法是实际的，字符串对象本身随这些一起提供，这是C ++培训的一部分，在这里对这些人进行分类，就像有人已经写信给你分类一样。

不能在类中添加更多方法，因此我们不能使方法像在内部一样，字符串，但我们可以编写您在字符串中传递的外部函数，我们会做一些事情，所以我们除了最后一个，幻灯片哦，我想您必须同时包括搅拌Lib和琴弦。

从技术上讲，我们的搅拌Lib包括绳子，所以您确实会得到两者，但我认为，最佳做法是只包含您认为需要的所有内容。

所以哦，我不想刷这些转换功能，这些很有用，将整数转换为字符串，反之亦然，例如将字符串转换为字符串。

就像您知道int或字符串年龄搅动等于42一样，就像某人的年龄或，无论如何，您想获得int 42，很多人都有这种本能， ，您想投下等于42岁的东西，因为，你已经学会了自己，就像有些人已经学会了你。

可以在不同类型之间键入类型转换，我认为在JavaScript中有一个，称为parse int或其他功能的函数，但是不能正常工作，取而代之的是，您需要调用我们的称为字符串的函数为整数，然后经过年龄搅拌。

然后它将返回您知道的int 42，现在您，如果将其保留为字符串，则可以使用该int计算内容，数值计算就可以了，如果您要吃42和，您由于某种原因想要字符串42，还有一个要整数的字符串，还有。

整数字符串可以。

所以这是一个运动问题，我是说我正在混合很多东西，我们今天已经学到的和混合引用，我已经有了字符串，你应该，一秒钟看一下，一次就在右侧获得了多个选择，你看看它，我们将在一分钟内谈论它的输出。

所以一个很勇敢的人想告诉我他们认为正确，回答，马蒂的妈妈国家环保总局，好吧，你怎么知道的，所以我们通过A和B这是Marty并向右走，所以Marty是这并向右走，可以，所以我要在这里删除。

但是根据您的回答，您仍然可以， M在这里的输出中，为什么M仍然在那里但未被传递，引用它作为常规参数传递，它是字符串的副本，因此，当我删除字母M时，更改不会恢复正常，这样。

消除答案C和E然后说B加等于0 ，字符串a在第一个字母处的字符0是字母A ，因为M被删除，所以B变成了stepa，然后我们插入foo这样，变得僵硬的oopah这些更改作为参考已通过。

直接修改main中的B变量，因此它们会持续存在，因此当我们打印a的完好无损而b已更改时，是的，我，认为你是对的，我认为是D，如果没有得到，那是好的，我的意思是，今天第一次看到参考文献，但您可能想练习。

逐步在代码中包含参考参数和内容的其他问题，像这样我喜欢在测试中我喜欢有一个，代码编写问题和共同阅读的混合体，我将向您展示一些我要说的代码，它是做什么的，所以您必须通过这个小谜团来解决难题，问题。

看看输出结果是什么，您对此有一些疑问，有道理的问题，我尽量避免说出有道理，因为我猜格里·甘蔗是其中之一，他说我们其他的教授很有道理，我想有人削减了，他一直都这么说，他们剪接起来，你们看到了这件事。

他说的YouTube很有意义，大概一分半钟，我现在说我每天都在，怕你们会把这些拼接在一起，我猜是所有咒骂词中的一个超级剪裁，但是，是的，无论如何，要去看它在斯坦福大学的意思是Big O我在那儿。

我在那儿，那里我在伯克利一两个是的，无论如何，让我们继续前进，您可以从可以询问的键盘上读取字符串，用户输入一个字符串，您可以说嘿，您叫什么名字，等他们，要输入答案，我们在上一堂课中输入了整数。

说一个整数，你也可以说获取行从用户我读取行，上次谈到C的情况，您可以间接使用C我，说虽然我认为C n不是很好，也许不是很好，选择和C in不好的另一个原因是，当您尝试读取一个，流一次只能读取一个单词。

所以如果您说自己的名字叫约翰·杜，它只会读John部分，所以大多数人都觉得这很奇怪，当您按ENTER键时，您键入的所有内容均是您的输入，因此我们有一个，名为get line的函数。

您会说出提示消息是什么，它将，向他们询问该消息，然后等待他们键入一行，返回整行，所以我认为这是正确的方法，令人困惑的是已经有一个功能，所以我推荐中间的那个是蓝色的，得到一行以读取用户输入的字符串，好吧。

我不会，真的花所有的时间在这张幻灯片上，让我们做一些运动问题，让我们一起编写一个名为name diamond的函数，然后传递一个字符串参数，然后打印出字符串字母的菱形图案，就像这样。

可以将其作为功能的控制台输出，所以也许，如果您想继续玩下去，可以帮助我，步骤站点，所以我们写一个名为Diamond的网站。

所以，我当然首先要你告诉我标题。

参数是否命名为diamond正确使用字符串，所以string s ，好吧，NIEM钻石的退货类型是什么，是的，我的意思是你说的有些人可能已经说过了，你知道我明白了。

人们对此有些困惑，因为此功能的结果是。

打印文本，所以人们走了哦，这是一个字符串，所以它返回一个字符串，但我不希望您返回我要求您打印出的字符串，字符串作为输出，我希望该输出在控制台上，我不希望您返回，如果要我解决一个问题。

我希望您输出它们是不同的，问题，我想让你退还一些东西，我一定会用这个词，返回问题的描述，我会说返回或返回那个或，随便什么，但不要使用return一词，我暗示您不需要，返回任何东西，是的。

我希望您打印输出，这是一个无效的方法，所以还可以，我需要打印所有的RT，所以我该怎么做，有人帮我解决。

再次打印m，然后MA和ma是两个Y，然后开始打印， RT Verde好的，那么我该怎么做，我会接受部分答案，让我开始，告诉我一些对您有所帮助的内容，好吧。

让我们一支钢笔在for循环中做索引我想我可以做到，对于int的部分，我等于零，并且我小于字符串长度，所以它称为s ，点长度好吧，现在我在做什么每一行好吧，写这些子字符串，如果您愿意。

Mme ma是那些字符的r个子范围。

如果我将这些字符串方法备份到这里，可能会有所帮助，所以你说了子字符串，所以如果我要开始索引并增加长度，它将给我，你知道从那里开始有很多字符，所以如果我要打印Em Mema 。

您是在说我想做点什么吗？开始是什么，什么是，长度从零开始，就像我要打印的前几行一样，只是第零个字符我可以走多远，好吧，如果我看到了怎么办，那和substr不会修改s，它基于s返回一个新的字符串，所以我。

可以尝试一秒钟，我们可以测试一下，让我让我，注释掉所有其他内容，因为我只想有一个空的main，所以让我们开始吧，名字迪蒙·马蒂（Dimond Marty），我能得到什么？玛特（Mart）就在眼前。

是看起来像第一行的长度，它打印零个字符，所以我的意思是，也许我们想说我加一只印多一点，所以现在我，起床去Marty好吧，很酷，这是一个不错的开始，所以您可能会说得很好，天哪。

我该如何更改此循环以同时打印其他部分，我认为，同一循环必须完成全部工作，我们可以与他们一起生活，我们到目前为止，也许这部分是钻石的前半部分，也许，我们将在下半年编写另一段代码，好吧。

我该如何打印这样的东西，好像前面有空格，所以也许一秒钟我们可以忽略空格，让我们尝试打印，首先在每一行上正确的小子串，那么我该怎么做，您认为还可以，我只是要再次遍历，字符串，但是索引是不同的。

那么如果我把它放在这里是什么意思。

您只传递一个参数，这意味着从该索引到末尾，但是在此之前省略所有内容，好吧，让我们看看是否可以让我尝试一下。

搞清楚那是怎么回事，但是打印两次却很聪明，所以我喜欢两次见到我的名字，但这不是正确的输出，所以也许，再说一遍，就是我加一个起点，再加上一个，让我们看看现在是否有帮助，很好，除了我希望这些人搬过来。

所以我该如何将他们搬到，正确的你怎么看，哦，我可以用空格替换字符吗，是的，我可以猜到，我当时想就像在这里我想做两件事我想打印一些，空格数，然后第二个我想打印s的子字符串，所以我，如果我可以避免的话。

我宁愿不喜欢mutilate，尽管我当然会，认为如果您不介意我可以那样做，我宁愿，弄清楚我需要打印多少空间，然后再打印那么多空间，就像我怎么知道有一天我需要打印多少个空格。

尚未从字符串的正确链接中听到消息-如果您要打印，角色反复没有魔法命令，所以我们只需要做一个，为此循环，就像它的四个循环jj小于j加，看到空间，我不是说Endel不会走下去，只是往前走，然后。

问题是要在您的建议的点上移动多少个空格，长度-我可能是正确的，它可能偏离了我们一个，试试看，嗯，我要告诉你一件事，空格的数量正在增加，所以，因此，如果您减去我，那将使数字下降，那么。

如果只有我的空间那是什么，如果可以的话那是什么，那是，接近，但我被一个人吸引了，似乎我有很多加一，正确的问题，所以也许我再加上一个空格是一个我们有名字的好工作团队，所以无论如何我只是在玩字符串。

以播放字符串方法，我的目标是运动时间到了，我没时间了，所以我会，让您今晚和明天查看这两节课，设置可爱的创作者，明天下午我会通过电子邮件向您发送有关部分注册的信息，谢谢大家。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P20：【Lecture 20】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

抱歉，您在视频中错过了生成树定义的人，如何，许多人认为一个合法的生成树举起你的手，好吧，有多少人认为这不好，为什么我们需要增加优势或获得优势，摆脱边缘有多少人认为添加边缘以使生成树有多少。

人们认为摆脱边缘是的，所以在这种情况下，这是不合法的，生成树，因为它具有循环权，您可以绕开，图，所以如果我们现在要摆脱边缘，这将是一个跨越，树好吧，那两个人有多少呢？ 。

手有多少人认为两棵不是一棵大树好吧有多少人认为，没有足够的优势，多少人认为太多了，所以这一个人也有，有一个周期的问题，所以如果我们摆脱这种边缘，现在您有一个，好吧，三个人怎么会认为这是一个跨越。

树上有多少人，边缘太多，边缘不足，是的，所以如果我们要，在此处添加边，然后我们会突然有一个连通的图，因此在，图形未连接，您无法彼此到达每个顶点，就像这些都是他们自己的岛屿，所以如果我们添加一条边缘。

那么，您将有一个有效的最小生成树，因此正确答案为无，太棒了，所以在进入之前您对跨树有什么疑问，最小生成树，好的，因此最小生成树是具有最小总数的生成树，边缘权重成本正确，因此在此示例中，这将是最小值。

该图的生成树，因为它们就像是，成本最低但仍构成有效生成树的边，是的，所以当我们谈论树木时，您就像哦，也许我们，可能包括这个边缘，而不是您知道这个边缘或其他东西，但是现在，您将使用权重8的边缘而不是。

权重4的边缘，所以我们不再有最小生成树了，为什么不，与伙伴交谈，并尝试找到该图的最小生成树，就像最小生成树一样，我们在谈论从一个点到另一个，还有一点，因为我们所有的路径搜索算法，寻找两点之间的路径。

因此最小生成树的宽度为图，属性，它与任何两个顶点都不相关，因此最小生成树，总是与图形中的所有顶点一样，它不在，任何两个特定的顶点，是否有人想要为此图建议最小的生成树，是的，所以我们可以摆脱这个，好吧。

只是让它更清晰一点，就像包括这个，边缘边缘边缘边缘冷却，太棒了，所以任何人都可以看到其他最小的生成树中的三个，一，是的，所以我们可以摆脱这个问题，我们将这些问题包括在内，还有其他人是的，是的，完全可以。

这就是这一个，这一个，这个和这一个恰好所以我们为什么不做，为什么这个不是，最小的生成树，您可以像这样完全摆脱B到D ，因此，该生成树不超过最小生成树，因为，成本是3加3加3加3加7。

即19而不是3加3加3 ，加1加7，这是17好的，所以这很有用，如果，你知道6个顶点7个边，这东西比人类少，擅长在有成百上千个顶点和边线但，一个名叫船员学校的家伙想出了一种算法，可以很快找到一个最小值。

图的生成树，是的，您将在您的图上实现，功课，所以基本上它的工作方式是您一开始就没有边缘，图，然后我们将基于边缘权重和，那么，当优先级队列不为空时，我们将DQ一个优势，如果它，连接到图中当前未连接的部分。

然后我们将包括，它在我们的最小生成树中，否则我们什么都不做，您对该算法有什么疑问，我们将举一个例子-是的，是的，所以我们不一定要解释Manoah的扇形树木的工作原理，我们不是。

明确地喜欢从图形上删除边缘通常它们是如何工作的，之类的返回一组包含最小生成树的边，但是，是的，所以总的来说，就像遍地都是，在您的图表中并将其添加为您的优先级，但是从概念上讲，我们可以，想一想。

图中没有任何边，而您正在添加边，回到图表中很好的问题，是的，如果这些端点，如果我们知道您是否已经连接，例如此处已连接，包括你知道这个边缘这个边缘这个边缘这个边缘然后我们，从D到e观察这个边缘。

现在D到e已经连接好了，对吧，你能走这种方式从D到e吗，如果我们要连接它，这样，我们现在有了一个循环，可以打破最小的生成树，问题好吧，让我们在船员学校做一个实际的例子，所以这是。

边缘的优先队列我在图中将它们分级，因此我们可以直观地看到，重新添加它们的想法确实有意义，因此我们将选择哪条边，首先看看是的，因为这是最低的成本，好多人认为。

将其包含在我们的最小生成树中有多少人认为不包含它，有多少人仍然对船员学校感到困惑，是的，所以，我们想包含它，因为我们是一个连接，这两个顶点这一个和这个顶点，它们当前未连接，我们的图。

所以这必须是连接这两点的最便宜的方法，好吧，让我们加入一个好吧，所以我们的下一个优势是B 2 ，这边有多少人认为，包括有多少人认为，不要包括它，好吧，所以B 2也连接了两个边，当前不在，我们的图好吧。

我们的下一个边是C 3，这里有多少人，想想包括多少人认为不包括好酷，参与度肯定会增加，因为这很棒， um d4在这里包括不要包括ok be 5在这里包括，不包括是的，所以如果我们包括e5。

我们将得到这个周期，在这三个音符之间1 2 3所以我们不想包括5或最小值，生成树好的um f6包括f6在这里包括不包括是的所以f6 ，连接当前未连接到整个组的这个顶点，好吧。

尝试突出显示当前已连接的设备，确定g7在这里，到这里包括不包括是的，所以什么也不做g7每个八个都在这里，到这里有多少人认为包括不包括在内，所以在这里，这两个节点是与星星相连的，这5个节点。

带有圆圈的音符已连接，但彼此未连接，因此，我们想要，所以您确实希望包括h8，以便我们连接，我们可以连接这些，现在两组笔记都已经连接好了，你会得到I 9，这里有多少人认为包括不包括，好吧。

J 10就在这里包括不包括yeah k 11这在这里包括，不包括L 12井，这里包括不包括是，这里的M 13包括不包括，所以如果我们包括， m 13我们将有一个循环，从这里这里这里这里这里来回。

所以我们不想包含它，这里包含的14个不要包含，是的o 15此处不包含好的P 16此处不包含，这里包括不包括好吧，我们现在需要继续吗？ ，有没有连接的节点，是的，所以我们不需要优化，继续进行Q和R。

因为我们已经连接了所有节点，我们的图表是一个很好的问题，所以问题就像我们实际上如何，像人类一样在视觉上知道我们可以看到事物是否相连，但是我们该怎么做，作为计算机，我们将讨论，大概五分钟，是的。

所以这与最小生成树匹配，我们才得到总成本，只要将所有边缘权重加起来就可以得到60 ，是任何低成本的生成树，是的，因此该算法可以找到，最小的生成树，因此不会有更低的成本，这个图有一个等价的生成树。

有多少人认为是，很多人认为不，所以对于这个特定的图，您将不会有一个，因为所有边缘权重都是唯一的，所以只有一棵最小生成树，在第一个示例中，我们看到有多个最小跨度，树木，因为有三个边缘，成本为三。

所以我们可以使用任意两个，这三个边缘中的一个，但由于所有边缘权重都不同，因此您，只会有一个最小的生成树这是另一个例子， Wikipedia只是像这样显示，哦，我们有一个周期，所以您不包括，这个边缘。

然后在这里我们找到了最小的生成树，所以回到您的，质疑我们实际上将如何实施职业学校，因为，像我们这样的人确实做得很好，但是我们如何才能自己实现，一件大事是，我们正在使用优先级队列，因此您认为分配。

五个很辛苦，就像一切都回来了霍夫曼这个任务优先，队列很大，然后我们还需要讨论如何确定是否，这两个顶点已经有边缘的端点了，在我们的图中连接，因此，将其概念化的一个好方法是，我们将拥有不同的。

原来如此的顶点，您看到了将其中一些标记为标签的感觉，圈子，其中一些有星星，而星星和圈子不是，就像我尝试代表这些集群的方式一样，连接哪些顶点，这个想法是，您将拥有这些簇，并且随着。

您需要能够在将边线添加到，最小生成树，您还需要非常迅速地确定是否，一条边的两个端点是否在同一个群集中，做到这一点的方式，我鼓励您考虑一下，因为您必须在家庭作业中执行此操作，所以我没有明确。

很抱歉回答您的问题，但这是一种非常好的心理模型，所以，也许考虑一下我们已经了解的一些数据结构或技术，本季度实施此方法是的，对不起，是的，所以基本上是这个主意，就像您添加想要的边一样。

您要考虑作为节点的边，它们作为同一集群的一部分相互连接，所以我当时，在我们的示例中表示，我们只是通过，可能在某些顶点上有星星，而在其他顶点上则有圆圈，像这样实际绘制出来，就像，同一组是的。

所以问题就像为什么我们需要最小的跨度，就像我们刚才谈论这棵树20分钟，是的，他们习惯了，制作很酷的迷宫他们也更重要地习惯做事，如电源线之类的东西，您需要连接大面积。

而且您希望以尽可能最低的成本做到这一点，所以您不希望这样，你就是一个例子，也许你想让这个国家的每个人都能，例如访问该国的所有其他地区，但您不想建立一个，一堆多余的路，因为你就像一条有限的路，预算。

因此您需要一个最小的生成树来连接您的城市，这个国家的大问题是，还有其他人在哪里吗？ ，认为最小的生成树在现实生活中会很好，我认为您可能在某种程度上得到了一些不一定，最小生成树，但像新航空公司一样。

可能会尝试最小化，用类似的飞行路径生成树，因为您可以，就像连接地方，然后随着航空公司的壮大一样，开始添加周期，好吧，关于我们的克鲁学校的最后问题， ，转到图实现中，所以像我所说的，图是数据结构。

所以我们一直在讨论有关如何实现不同数据结构的法律，让我们讨论如何实现图形，这样的想法是我们讨论图形，存储顶点和边，因此您需要某种方式来表示这些顶点， ，边缘和内存需要有很好的方式来查找或访问，在右边。

我们将看到三种不同的潜在实现，图和一些值得思考的好问题，例如，如果您，想要添加一条边如果要超出顶点会发生什么，如果您要查找边缘，则尝试搜索特定的边缘，节点的邻居这样的事情，所以对，请记住。

这取决于您的喜好取决于哪个，您要根据要使用的功能使用的实现，您的图表还可以，因此也可以尝试考虑哪些实现，最适合我们一直在学习的不同算法，因此第一个，一个可能是最简单的代码了，只是让我们列出所有。

图中的边，所以我们甚至不像显式地存储顶点，只要记住，像哦，如果这是一个边缘B，则意味着必须，我们图中的顶点a和B ，弄清楚那里是否有多快，或者希望我们弄清楚是否，例如，在我们的图形中有一条边。

例如在a和D之间存在一条边，是的，这是不可靠的操作，因为您必须经历所有，图的边缘，有时当我们谈论图时，我们会说，大约oh E与Ovey Ovey的边数和oh V的数，的顶点，但是如果我们只是想知道如果。

我们的图中有一条边，我们必须查看图中的所有边， ，如果我们想找到给定顶点上的所有邻居，那是什么，这样做的成本，是的，所以问题就像我们要查找所有顶点还是所有顶点，您说过V乘以e，这意味着对于每个顶点。

我们都需要经历，整个边缘列表，所以如果我们想像所有邻居一样找到它的话，那会很好，所有顶点，但是我们只想找到一个顶点是它的邻居，只是BOV，所以您只需要浏览一下该列表即可，是的， ，完全正确的想法。

所以好吧，基本上故事的寓意是边缘，列表，您必须遍历整个列表才能进行基本上任何操作，你想这样做不是超级伟大，就像一个人可能会想，也许有比要继续浏览我们的内容更好的东西，每次都有完整的数据结构。

但是有一些优势，它们真的很容易实现，每个循环都非常容易做到，在边缘上，它们也很容易向右添加顶点，就像我在，只在这里画一个顶点，每个都不需要调用，我不需要更改边列表，完全是因为连接年龄的RNA边缘还可以。

让我们再多一点，专业，所以我们不只是存储所有边缘，为什么不存储所有，顶点，并拥有每个Verta并为每个顶点知道所有邻居，所以我们就像基本上存储了每个顶点的所有边，所以有一些。

您认为比边缘列表操作更好的操作，是的，所以这真的很适合发现你知道邻居被宽恕了，像您刚去的顶点，您会在数据结构中找到该顶点， ，看起来像所有邻居的全部清单，这真的很好。

还有什么可能是好的还是有什么更糟糕的，是的，我很想知道是什么时候将顶点存储到此处的列表中，他们是按顺序排列还是不是按顺序排列，所以您可能没有顺序，像这样的顶点只是您可以想象的字母。

并不是真正有序的字符串，因此您不一定要，在这里订购，实际上我们将讨论我们如何实际实现这一点，但是，通常您会像地图一样使用它，或者它很容易添加，此图的文本是是否，如果我们在此处添加H，您会知道。

需要改变我们的代表，是的，是的，所以当我们在这里添加H时， ，如果我们想添加，只需将其添加到邻接列表的末尾，你说对了的一条边，我们需要在这里添加，我们需要说好，这指向D和D点D包含H，所以还好。

就像一个，正确的成本，所以对于我们的边缘列表，我们没有像存储B C那样存储，我们没有存储CB，但是我们需要同时存储两种方式，因此我们必须，存储两倍的信息，这基本上是另一个潜在的成本。

确实很擅长向图添加新的顶点和边，将其视为恒定的时间，这也非常适合发现，给定顶点的邻居最糟糕的是很难确定，给定的边是否存在正确，因为为此，我们必须，遍历该顶点的所有邻居，所以如果我们正在寻找。

A我们必须从这里开始，好吧B是我们想要的， D我们想要的是G而我们没有想要的，所以我们不得不，浏览整个列表，您对邻接有什么疑问，列表和边缘列表到目前为止，是啊，那是一个错字，对不起，这是。

不应该在这里对不起，好吧，现在有第三种称为邻接矩阵，这样，可行的是您在右侧的任一侧都有顶点，因此您会，如果两个节点之间存在边，则基本上像1一样放置，如果，不是因为它有对角线对称，因为如果有边缘。

从A到B，从B到a的边也有无向图，所以，从我们已经讨论过的操作来看，这是一个好广告还是坏广告？ ，关于，是的，所以添加新顶点真的很不好，因为就像，这么说吧，我们突然将H添加到了这里。

我们不得不喜欢添加它，整个额外的列和行在这里不想画上黑色，但是，这里有一个额外的列，您必须用所有这些填充它，零，这实际上是非常昂贵的操作，因为通常，不喜欢这是一个实际成绩，您必须知道复制所有内容。

如此精确，以至于很难找到邻居，很好，是的，所以这样可以找到所有邻居，对于一个节点或一个顶点，我们必须去那一行，就像我们试图寻找， C的所有邻居，我们要去这里，我们必须看看所有，不同的顶点。

看看它们之间是否有边，这是一个主要的，对我们的边缘列表进行了改进，因为我们的边缘列表必须经过，整个边的列表非常正确，在这种情况下，我们，只需要遍历所有顶点，但这仍然不是很好，因为像，与我们的邻接列表。

我们只需要仔细查看，邻居基本上和它的权利一样好，所以这是一种媒体，那如何确定图中是否存在边缘，在您试图找到G之前，您是否知道G在那个不好的邻居，如此多的人认为这是一个很好的数据结构，在边缘列表和。

邻接表列出了多少人认为比边缘列表和邻接表更糟糕，列出是的，所以它实际上真的很擅长，因为为了找到一个，和G或邻居，你就可以了，就像你可以直接去这个地方看看，在这里，看看就像哦，那里有一个邻居。

这是一次操作的O，是邻接的另一大缺点，矩阵是您必须正确存储所有这些信息，所以如果您，拥有成千上万个节点，但是之间只有一条边，平均而言，每个节点在图形中最终会带有很多零，那里有很多多余的空间，你们都对。

这些不同实现之间的成本差异还是原因，你会用另一个，是的，很好的好问题，所以问题就像您将如何存储重量，因此，通过我们的矩阵，我们可以知道您将权重直接放在此处，而不是像零或一个那样的符号，您将如何为另一个。

所以对于边缘列表，您可以拥有，权重就像边缘结构中的一个字段，这样边缘就可以，两个顶点分别是起点和终点，并等待您拥有的邻接表，并将其存储为额外字段，因此更像是，将权重添加到邻接列表和边以及边列表中。

而不是添加权重，到邻接矩阵，然后如果有向图，您失去了很好的对角线属性，因为您不再有保证，就像如果a是a相对于B的边缘，那么B相对于a的边缘，所以您知道这里，我们看到哦，从A到B有一条边。

但从B到a没有一条边，所以这些是，在谈论加权图和有向图时的巨大差异还可以，假设我们要实施广度优先搜索，所以我们有三个，正确的选项，我们有边列表，邻接表和邻接矩阵。

有多少人认为边缘列表是实施广度优先的最佳方法，实际搜索是否可以帮助有多少人认为邻接表是，最好的办法，有多少人认为邻接矩阵是最好的方法，让我们开始吧，超过零参与，所以这个图表基本上就像。

这些不同的实现方案（例如， ，没有一种可以普遍地改善这种情况了，这取决于您在做什么，所以绿色的东西就像，那个操作的赢家，红色的东西是失败者，所以添加，顶点最擅长无边缘，杰森则看到列表，更糟的是邻接矩阵。

因此对于广度优先搜索，请记住从上周开始，排成一列，是的，你们都认为多少，任何人都想要喜欢的最佳使用数据结构，并且，是的，所以邻接表对于广度优先搜索确实非常有用。

因为您对顶点的每个邻居都有喜欢的步骤并将其排队，进入您的队列，这样对邻接表非常有用，因为它，仅邻居的数量，而不是顶点或，边数，船员学校算法又如何呢？所以任何人对他们哪一个都有任何想法，认为最适合那个。

是的，所以对于船员学校来说，列表很好，因为您需要遍历图的所有边缘，因此，如果要对邻接矩阵进行此操作，则必须，通过像V平方与邻接列表或边缘列表相比，仅在边缘的数量上，所以我的意思是实际上这取决于。

您想对图形做什么，以便在面试中被问到，就像嘿，您可以首先实现图形吗？ ，就像你想和这个家伙做什么，因为，你们是否都想看看我们是如何实现图形的？ 。

这个选择好吧，所以这是图点H，基本上是基本图。

基于，因此这里有一组节点和一组边，所以这组，边缘基本上就像我们在谈论的那个边缘列表，但是，我们还存储了节点，其背后的想法是当您进入基础，在这里保留在顶点上的图形，基本上，当您去查看顶点时。

您会看到它具有，这样一来，如果您查看一个顶点，就会看到其中包含一系列边，与之相关联，所以基本上，这意味着如果您返回图表。

并且您想查看两个点是否已连接，您实际上经历了，必须穿过该顶点的所有边缘，所以实际上，这种混合边缘列表邻接列表方法，因为您拥有这套，边缘，所以很容易在图表中获得所有边缘，这非常好，确定巡航目标。

然后您还有一个邻接表，因此很容易找到，邻居，因为我们要您做的另一件大事就是全力以赴，正确的路径查找算法，所以就像您实际上可以在这里看到的一样，你知道我们实际上必须遍历整个邻居清单吗。

只是为了确定两个边是否相连，这是我们做出的一种权衡，在知道我们要你们做的任务的基础上，早先有人问过这些是按顺序存储的，它是如何工作的。

基本上，您不会按顺序存储它们，因为不一定，顶点的顺序取决于它们存储的类型，例如，以至于它们通常被命名为，顶点就像边缘列表，或者您只存储边缘集合，在每个顶点内部，这是我们在实现邻接过程中所做的工作，列表。

然后对于邻接矩阵，通常会有一个映射，就像实际的网格一样，你们是否对实现有任何疑问，当您使用每个对象时，它们之间的权衡是的，它是边缘和对象，因此，在我们的示例中，edge实际上是抽象的，您可以使对象像。

是的，一般来说，你只是做一个结构更有意义，因为，不一定有方法会像您需要的那样，轻松访问它的所有字段，所以这就是为什么它通常是，开始，是的，所以等等，你看看我是否可以。

拉起它，这是您的代码，所以边缘还可以，是的，您可以看到。

对于每个边，都有一个起始顶点和一个结束顶点，这仅仅是，就像您可以将完成称为“完成”还是“结束”，然后它也可以存储，就像我们为加权图所讨论的权重一样，如果您想，看到这样的顶点，所以就像顶点的名称。

然后是集合，从该顶点引出的边的数量，这样您就可以，邻居真的很容易，因为您只需经历所有这些边缘，然后，找到那个边缘的终点，实际上我猜这两个都是回答您问题的课程，所以它们是，是的，所以问题是使用弧线或边线。

这是一种技巧，别名是官方术语，就像一个昵称，因此您可以致电使用，无论是圆弧还是边线，它们都是快速返回圆弧或边线的弧形，之所以这样做，是因为有时候人们会忘记什么，他们被称为我们也对向量做了类似的事情。

其中​​我们包括大小，和长度作为方法，因为没有人想记住向量是否具有大小，方法或长度方法大问题，还有其他任何问题，请在开拓者上开心，您怎么说。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P21：【Lecture 21】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

好吧，所以我们今天在这里，我想教你一些事情，在我开始之前，我称之为哈希，我想快速地提到几件事，所以，到今天为止，第七项作业已经增加，称为“开拓者I” ，认为实际上可能已经向您展示了她的演示。

演讲权这是一个程序，您可以在其中编写图形通过搜索算法，找到通过迷宫和其他种类的图，所以是的，这显然是，这是一个图形作业，根据您在，过去的一周，这将是我们在此完成的最后一项家庭作业，上课我们快要结束了。

所以我知道你们都为完成而感到兴奋，四分之一，然后去春假之类的东西，所以做作业，七个星期比星期一到期，它应该在3月12日在这里到期。 ，然后你知道与此同时它总是很有趣，就像你在做什么，其余的讲座都正确。

因为您已经完成了功课，您需要了解的所有内容，我想这是我的观点，是的，还有其他几个，我知道，有些人一直在检查自己的状态，上课并问一些问题，我相信今天不是真的，是在五点钟退出课程的最后一天，或者。

这样的事情，所以我当然希望你们没人选择退出我，希望大家都留下来，但我想您知道那是截止日期，如果这对您来说是个重要新闻，那么有人会问成绩，我在班级网站上发布的信息，您知道我们如何计算它们。

或者为什么不计算它们，我的成绩更高或类似的东西，我认为我的简短答案是，只是我当时发布的重要信息只是基于作业1 ，到3和期中以及您的某些部分，所以有一堆，尚未添加到这些数字中的数据，因此您知道是否。

不喜欢您看到的百分比或成绩数字，或，不管我怎么说，还有很多故事要写，但是反正好吧，让我开始教你。

关于缓存好，这是今天的主题，这里是大图。

这里的背景是我们一直在学习如何实施所有这些，不同的ADT拥有所有这些不同的收藏，所以我们了解了您，实现向量和列表，我们了解了如何使用二进制来实现集合，正确的搜索树。

所以我们一直在学习我想要的所有这些不同技术，讨论今天如何实现哈希集和哈希图，这是一个，真的很酷的想法真的很酷的想法，你还记得我告诉过你的，在哈希集中添加，删除和搜索什么是Big O，它是1的o 。

那是最好的大O，很快就对，所以你知道我会，希望您会有一些好奇心，例如如何制作具有，不断地寻找事物，你该怎么做，如果你只是，想像一下如何实现看起来好像不是的集合。

所以这就是我今天想教给你的，所以这来自于本章， 15本教科书，让我们想象一下我们正在尝试实现一套，整数让我们保持简单我会保证我们会回到你的角度。

制作一个集合或一个列表或其他具有其他类型的数据（例如字符串或，别的，但从一组intz开始，好吧，如果我们基本上，以我们一直学习的方式存储它，就像向量是，只需添加即可实现或实现数组堆栈的方式。

该元素进入下一个可用索引，因此如果它是内部集合，则为，像这样的未排序的未填充数组，那么效率是多少，的添加/删除，并包含在此表示形式中添加的最大功能，哦，是的，您偶尔可以把它放到最后吗？ ，数组。

但这很罕见，所以没关系，包含的Big O是什么，是的，因为您必须遍历所有元素以进行搜索，正确的东西是什么被删除的哦，是的，由于几个原因，一个是因为如果我要求您删除值49， ，必须去找到它。

然后一旦找到它就必须将它从那里拉出来，而且您可能想将所有内容移到正确的位置，是的，原因有很多，因此无论如何，这种表示法添加起来很快，但是搜索起来却很慢，和删除，我会说一套可以做的最重要的事情是。

如果添加缓慢或删除缓慢，有时会包含操作，您可以，容忍这一点，所以您要做的就是在构建时有一定的加载时间，集合，可能需要一分钟才能将所有数据添加到集合中，但是，如果搜索速度很快，这就是您真正想要的，是的。

所以一次搜索包含n的这个大O的事实真的很糟糕，因为我们只考虑大，只有当n是一个非常大的值时才重要，当n是一个大数对，所以我有十亿个元素，我必须，看看所有这些都不好，所以我不喜欢这种实现方式，一个集合。

但是好的，我们了解了如何使用二进制来实现集合，搜索流什么是添加和删除的大O并包含二进制文件，搜索树，它是n的对数n的对数比n好得多，我认为实际上是在说，对你来说已经很正确了，n的对数很好，好。

我想探索一下，也许我们可以做得更好一些，所以，让我们在竞赛领域中待一会儿，而不是使用未排序的数组，如果我们有一个排序数组怎么办，换句话说，当您添加一个值时，我会，找出合适的位置放置它。

我将每个人都移到上面并放置它，在那里，如果您说要阵列，然后他说要添加，谷你十一我会环顾四周， ，弄清楚值11应该按此处的排序位于索引3处，然后我将所有人移至该位置，将11放在索引3上，那么多长时间。

是否需要向该排序数组中添加一些东西，为什么呢？ ，基本上是从转变开始，例如寻找，正确的位置就像发现它应该在不需要的索引3处去，确定您是否知道为什么不放弃举手的所有事件，是的， ，我们，是的。

您可以对此进行二进制搜索，类似于如何进行二进制搜索，在二叉搜索树中搜索，您可以看中间，然后向左跳或，根据它的大小而定，您可以使用二进制搜索来找到，如您所知，正确的插入位置为log n，但实际插入的位置。

的偏移量，如果它更接近，数组正确，所以这是一个漫长的搜索加上结束切屑过程，这加起来就是，哦，数组与指针的关系如何？我在C ++和arraign中的意思是，它是使用指针实现的，但各个元素未存储在此处。

作为指针，链表将所有元素存储在一个大列表中， intz的内存块，因此加起来平均需要n的o ，因为搜索要包含的内容需要花费多长时间， n的日志，与您可以使用的二进制搜索过程相同，找到插入点。

您可以用它来跳来跳去看看是否有一个值，包含在数组中还是不正确，好了，删除要花多长时间，如果我说删除值8或删除值23或其他任何值，则删除，为什么很像添加，您使用二进制搜索来查找事物的位置，并且。

然后一旦找到它，就必须移动二进制搜索记录日志，移位需要n的总和为，所以如果您查看广告包含，并将其删除，如果您将其与最后一个未排序的相比， ，未排序的一个是我们走1和n，所以如果您比较这两个，它们都是。

有点坏，您可能会说好，等等哪一个比坏还是坏，另外我会说这更好，因为搜索确实，包含运行时非常重要，因此添加，在这里比较慢，加上未排序是1的o在这里加上n， ，更长的时间，但我认为值得的是更快地包含更快。

包含记住，我不知道你们是否还有强烈的本能。 ，这些不同的大O，但是像n的对数一样小于n ，一百万的对数是20十亿的对数是30一兆的对数是40对数，比n小很多，所以我认为这更好，因为搜索是，最后还可以。

但我认为我们可以做得更好，再做一次，因此二叉搜索树，您可以通过Ashley的所有节点，左侧和右侧以及所有节点来学习，那东西比所有东西都更好，因为那是一个东西，所以我希望你会看到。

这比我们到目前为止所看到的这两个中的任何一个都更好，到目前为止我们已经看过一个，但是如果我们要坚持一分钟，任何其他有其他方法的总线，我们都可以将其作为数组，工作真的很好，让我向您展示一个奇怪的想法。

这就是下面的想法，散列如果您将值n存储在索引n上怎么办，而不是存储它，在第一个索引中，第二个索引是第三个索引，如果您添加值7 I ，如果添加元素2，它将把它放在索引7的数组中，我将其存储在。

数组和索引以获取它，无论您添加什么，我都会将其放在该索引中，数组有点奇怪，但是我想如果能做多久我就能做到，是否需要向数组中添加一些东西，需要花费固定的时间，对，因为您只是跳到正确的索引，然后输入值。

那里您不必移动任何人，只需花费恒定的时间即可跳，到数组的任何特定单个索引，因此添加一些内容，如果我说数组包含，那么奇怪的想法将花费1的哦，这个集合是否包含值7，您将如何回答该问题？ 。

大声'会让您喜欢这里包含内容的过程是吗，他说1的o你就是对的，就在我想知道，集包含7我转到索引7，看看那里是否有7，是否存在，那里有一个包含7的集合，但是如果有一个零，那么没人，添加了一个7。

如果我看一下索引7，我完全有答案，我不需要，再看下一个6或索引8或其他地方，如果这里有7 ，那是唯一可能正确的地方，所以添加一个搜索包含一个哦你如何删除我说我不，想要在集合中再减去7，您要做什么呢。

只需将零，那要花多长时间？o神圣添加删除包含大，哦，这是一个好主意，这就是我无法想到的哈希，这个想法有任何问题，您能想到吗？ ，我希望您对此表示怀疑，然后说这是胡说八道，这行不通。

因为为什么出了问题好呢，所以有些值我真的无法添加，如果您说加负二则没有数组索引负二，好吧，那我想听听您的反对意见，让我们看看，我们可以修复它们，因为您说得对，这完全是我描述的问题，算法无法解决该问题。

但是如果我们能采用您所有的各种，异议并解决它们，我们就不会有一种神奇的快速存储方式，如果我们能找到解决这类问题的方法，那就是哈希，设置基本上是解决了所有问题的想法，好吧，我。

针对您的问题提出以下解决方案，我将维护两个数组，正数和负数，因此如果您说负数，我会将其存储在，索引2的第二个数组，那是负数组那那是怎么回事，零是的，我怎么知道零是否包含或可能不为零，如果包含索引。

我将存储一个，如果不适合则存储一个零，我也许可以为，零，我在那里存储一些东西，指示它是否在那里，对，这整个想法也很好，你可以把它转过来，转换为布尔值的正确数组，然后将其正确或错误或其他，是的。

所以我认为到目前为止一切都很好，我认为我认为我们为您打了补丁，从概念上讲，我们修复了您在此处提出任何其他问题的反对意见，是的，是的，这是一个很好的问题，这是存储一组intz的好主意。

但是我怎么用它来存储一组字符串或一组双打或类似，如果是双打，我分别有3。5和3。7，我都把它们都放进去了吗？ ，他们都放在三个桶中，或者无论您知道什么，您是怎么做的，如果您不介意，我想再说一遍。

也许我会调整措辞，在这里，我要说的是，看看是否可以找出如何使这项工作成为一组， intz，然后我们可以解决这个问题，但是之后，我们坚信我们可以通过第一权利做到这一点，您还有其他权利，对此表示反对。

如果我想要一个非常大的数字，例如set dot，在12中加一百万怎么办，对，所以现在我必须有一个包含一百万个索引和12个索引的数组，这样我就可以，翻转最后一个在其中具有值，然后翻转所有其他具有。

零在其中，这似乎是一种浪费，似乎很大，问题好吧，我对您问题的解决方案是购买更多的内存，而我有很多，内存，所以我的数组可以很大，没关系，这就是我对您的解决方案，问题听起来不像是一个很好的解决方案。

为什么我们不需要，考虑一个可能比实际上更好的解决方案，即使价值不是，像我想的那样大，我要添加18和12，它们不适合这里，有点异议权，它超出了数组的范围，所以我，猜想您能做的是将尺寸调整为20。

然后就足够了， 18或任何其他空间，但是如果您增加一百万，肯定会出现问题，如果您有非常非常大的价值，那么您将拥有一大堆空白，零索引很好，人们最终真正要做的是，环绕它，以便他们说您知道您有一千个索引。

如果，您想存储0到999的值，但是您可以添加，值1543，您会在索引543中将其回绕并扭曲，您可以按其数组大小的千分之一对其进行修改，所以它就在那里，我们引入了一个不同的问题，但这有点像黑客。

用于很好地解决这个问题，让我向您展示一些，关于这个想法的更多信息，这称为哈希，所以您知道这句话，就像您谈论的那样，单词哈希被许多计算机科学所使用，哈希标签或与之无关的任何内容或哈希代码上的哈希字符。

键盘与此无关，但它与哈希一样是相同的哈希，映射哈希集哈希表（如果您之前已经听说过此类短语） ，哈希我通常在说哈希的定义是当您映射一个，将较大的值域转换为较小的固定域，通常为的域，整数。

以便将所有intz映射到一小部分，可用作速率索引的索引，用于存储它们和数组，您用来存储这些值的过程称为哈希表，通过，如果我给你做映射，基本上就是所谓的哈希函数，要添加到集合中的元素，然后告诉我它的索引。

应该把从数据到索引的映射称为哈希，函数，所以我们的算法是获取给定的哈希编码或哈希值，您只返回了相同的int，你们带来了一些非常好的，对此表示异议，因此对否定词不起作用，您可能会有很多，零。

这是你们带来的一些东西，好吧，让我们修补一下我们的功能以在某些情况下起作用，一个就是您，只要取我提到的绝对值，我就可以拥有第二个数组，底片，但另一种方法是绝对值，因此如果您，说你想有两个负数。

我可以把它放在索引2中，我可以做的另一件事是，如果我可以，把它们包起来我在一分钟前说过，因为那是49 mod 10好的，所以，哈希函数，您可能会说数组容量，所以这是怎么了，这个版本有人M有什么问题： 。

是，现在，有多个不同的值散列到同一个值中，索引，如果我尝试添加负2和2或37和47和57 ，这些值想转到相同的索引，我必须处理该问题，将多个值散列到同一索引中的问题称为冲突，是我的下一张幻灯片不是。

而是在我谈论之前，我只想指出这种碰撞，将它们存储在数组的哈希索引中，这是1的大O，对所有，这些东西是1的大O，因为您只需转到索引即可，循环遍历我们之前讨论的任何其他索引，所以这样，本质上。

算法添加方法转到哈希码的索引，然后，将值存储在该索引处索引，查看该数字是否存储到该索引中，删除我并将其放回原位，以查看是否看到这就是您要做的全部，是的，我希望您能看到所有这些都是1的大O，因为没有。

循环，没有递归，没有什么会拖慢我们的脚步，正确的1的大O，但是我们仍然面临的最大问题是，可能相互碰撞并进入相同索引的多个值的问题，这就是所谓的碰撞，所以当您实施时，哈希集，您必须想出一些无法解决的冲突。

只是忽略它们，因为如果我只是忽略它们，我会覆盖值吗，看到在第三行中我添加了值24，然后在第五行中，有54岁，哎呀，我用54岁写了24岁，所以现在如果你问我24岁是否是，在集合中，我不知道正确。

我看到了54，我看不到24，所以我不知道，回答我丢失了信息，这不好，好，那么您如何很好地处理碰撞，您可以通过不同的方式，这样做，我们又尝试了不同的冲突解决策略，修正这个想法。

使其仍然可以处理碰撞的一种方式，称为探测探测是将元素放在下一个索引中的地方，不太喜欢这个主意，但是您可以做到这一点，就像想像自己，在索引4处有24，现在您要添加54，然后将其添加到24索引中，你说哦。

这已经花了，所以你就去下一个，放在下一个中，我正在尝试为此进行现实世界的类比，就像如果您去上一年级的宿舍，那已经有人在那里，您刚搬到隔壁或其他地方的东西，正确的问题，所以您可以这样做。

这是解决冲突的唯一方法，问题在于，现在很难像我想说的那样搜索东西，现在，如果我问您集合中是否包含54，代码需要做什么，你包含54我该怎么做，正确，所以我要做的就是使用哈希函数告诉我，去索引号4。

所以我去那里，我看到我在寻找， 54我转到索引4，我看到24是错误的值，但没有停止，而是，说不，这不是这里，我必须继续前进，看看是否，因此，我必须继续前进直到谢谢，找到它在这种情况下是包含的。

或者我达到了，我想如果我，达到0意味着它不可能在这里，因为它会降落在其中一个，那些在零权利之前的索引，因此添加删除和，包含的内容有些不同，因为您必须喜欢跳起来看看，这些索引，但请稍等。

听起来好像开始消失了，从这里的一个大企业的O到哦，如果您想， 1对，当然，我希望您从那些奇怪的Big O问题中学到了什么，在中期，并不是每个循环都意味着某事物变成n的大O 。

这取决于您要遍历的事物的数量，所以这些，像我必须循环几次这样的小循环，这样做，搜索你成为他们去莱文吧你认为我的意思是什么，你的高清在哪里告诉你类似的东西，你说如果只看一个像几个元素的常数。

可能不是他们去参加活动，是的，我想答案是，这些团块预期会持续多久，只会成为，几个元素会聚在一起，否则将成为一个巨大的沉船，一种元素，您必须循环遍历一半的数组，所以我猜是。

取决于这些小块的元素我是否有关于这些小块的幻灯片，的元素称为簇，因此基本上如果簇太大，那么我们就不会再有Big O了，它将接近N的Big O ，但是只要集群真的很短，我们就可以了，所以我出去了。

我计算数字的方式在这里会相互冲突，这个集群真的很长，所以如果你问我是否，包含值94，我必须以2 X 4开头，并且必须一直， 9和0甚至看我是否能在那找到它，所以我的意思是不好，是的问题，使用现有数据。

接下来我将添加16，所以我将要做的是，如果您想增加16位，请坐下，然后知道它已满，请转到，下一个转到下一个转到他们，直到找到零，然后我去所有，到9的方式我找不到零，所以我会回绕以在那里索引零。

它离家很近，您最终将要存放它，现在您可以做的一件事就是减少这些团块的数量，我选择10个不同的数组大小是因为我必须绘制PowerPoint 。

幻灯片很难在一张小的PowerPoint幻灯片上显示50个索引，但是就像，数组大小为20，我希望您能看到一些结块会消失，下降，因为像24和86之类的东西在4和6索引中会下降，但是，像14和54。

它们会在14指数中上升，因为那是他们的20 ，知道我的意思，例如拥有不同的数组大小或更大的数组，无论如何，尺寸会在某种程度上帮助解决此问题，解决冲突不是我认为是最好的方法，尽管我。

希望向您展示一种我认为更好的方式的方式称为，链接单独链接是在数组的每个索引处而不是，存储单个值，您存储一小部分值，通常在以下位置实现，无叶的哈希表变成了一个整数链接列表数组，所以我。

猜测是否要按字面意义拍这张照片，像索引零是一个链接，集合中所有以零结尾且索引为1的ins的列表，以英寸等结尾的所有英寸的列表，这是因为您知道，我选择的数组大小为10，所以您会制作一些像散列的小节点。

这基本上与您拥有数据的链接节点链接列表节点相同，然后接下来您只需将它们链接在一起，这样您就不必再喜欢了，看看下一个索引，或者说知道是否包含54 ，到链接列表和索引4，然后在其上循环查看是否有54 。

还是全部，您不必去索引5，下一个索引6或任何一个，这样我就更好地喜欢这另一件事，我不知道我是否，提到我不认为我是这样说的，但是如果你，这个探测模型您可能会用完空间，您会在哪里看到像，如果您用完了索引。

您将无处可放任何东西，因此您，可以使阵列处理该问题，但实际上您可能会得到一个像，整个数组将是不好的，所以关于这个数组的事情很不错，从技术上讲，您永远不会用完空间，只是可以继续加长，这些列表。

只要您需要就可以了，所以这是解决，碰撞问题，但它仍然存在该循环和我们遇到的Big O问题，一直在谈论，如果您添加的所有值都以它结尾，与您所知道的2454一千四百一四千八百八十，对于叉上所有m的值。

您都了解它们都在，哈希表的索引相同，因此您基本上只是存储，您的设置为一个链接列表，所以如果我问您它是否包含某些内容， ，必须像他们所有人一样遍历，所以好像那不再是一个大孩子了，所以我不知道。

您仍然相信我，我们可以在这里完成一项业务的整个大目标，我似乎对此做了一些幻灯片，所以我们必须做一些事情，但是，我想我的意思是您知道数据是否全部聚集在一起，不好，所以我们可以使它少聚在一起的一种方法是。

为我们的哈希表选择不同的大小，我选择大小10的事实是，实际上是一个不好的选择，因为这意味着所有以结尾的数字，相同的数字值会全部排列在一起，似乎太笨拙，对我来说，您可能会选择17号或51号，或者。

某些原因以及您选择类似怪异数字的原因是，改装和包裹非常混乱，就像你可以把所有这些，我在这里写的值，并检查当您以17为底的时候所有的mod是什么，他们碰撞的可能性不大，因为那只是一个奇怪的随机现象。

我选择的素数是数字，但是无论如何，在实践中这样做是因为您存储了这些数据的小链接列表，并且，只要链表很短，对于大多数数据而言，那么基本上这些添加和删除以及包含操作是什么。

1的大O并不意味着它仅查看单个元素，而是意味着，当n为n时，不必统计更多的元素，较大的确定，所以如果使用，与每个索引中的链接列表的链接如何将内容添加到，哈希表我有一个新值，我要加24。

所以我想你们已经，知道我要去索引4，然后把它放在那里，我应该把它放在那个链条上的什么地方， 14岁之后那肯定是正确的，我认为还有一个更好的选择，放的地方比54开头的原因，更好，是的。

因为我们在这里谈论的是链接列表，所以我所拥有的只是，这个小小的前指针可以走到链的末端以将24附加到末端，那会花我一些时间，它是走到最后之后的下一个下一个下一个，对，我不想那样做，连锁的顺序并不重要。

只是存储每个拥有那个mod的人就可以了，没关系，所以就把它放在最前面，这样就让他的下一个成为54岁， ，让清单开始是他，你们知道如何在清单的前面插入，一个链接列表，您已经完成了很多次。

之前需要花费多长时间，在链接列表的最前面插入一些内容，它们会一遍无循环，只是改变您完成的前指针，所以我试图说服自己，如果我们做到这一点，我们将添加和删除并包含将是很大的哦，我知道我可以相信一个运行时。

因为这些是1的大O ，图片以及我们现在正在谈论的内容，如何包含包含如何工作良好包含14我知道这将是一个，索引4正确，所以你们知道这只是我在搜索链接列表，所以我，创建一个当前指针。

我将其指向你们拥有的链表的最前面，像这样多次编写代码，而我却找不到数据或， null next next next ah-ha我发现它返回true对，所以我，需要包含一个循环。

但是唯一的问题是您知道该循环，我正在做的不是n的大O，因为我假设元素，是散布的，所以不是所有的n都在任何一个屈曲中，然后删除是非常简单的删除，只是你们知道如何，从链接列表中删除，只需将指针指向它周围。

如果我想要，删除54转到54之前的节点，然后使其下一个指针指向，大约54到正确的典型链接列表之后的那个，就是这样，您将集合实现为哈希表，所以我想这样做，与你们或者至少尝试我想尝试读取哈希以设置具有添加。

并删除并包含4次，我们可能只做原子包含，因为我认为，那是最有趣的两个，但让我们看看是否，可以这样做，所以如果你去可爱的创作者，我会发布一个项目。

今天有一个名为hash int set和hash set的文件，我有这个哈希节点，这是下一个数据中的一个数据，我想实现这些，方法构造函数添加包含，等等，好的，现在在这里我要写，众所周知。

我们之前实现了基于数组的集合，通常有三个字段，您有一个数组用于存储数据，容量可以告诉您阵列的长度，而容量可以告诉您，您实际添加了多少个值，所以我们使用了一个竞赛堆栈。

你我以为你的数组优先级队列和堆优先级做到了，排队，所以这三个专用变量应该是三个，对您来说有些熟悉，也许令人困惑的一件事是为什么这是一个，哈希节点star star哦，天哪，至少现在您正在显示双指针。

在放下最后期限聚会之前，我这个恐怖的明星是为什么，我写，是的，是的，完全一样，如果您想在Java中使用数组事件，请在，方括号，但是在C ++中，您在星号中表示星号是指方括号，放在右边。

所以如果我想要一个哈希节点数组，我真正想要的是。

这十个指针中的每一个都是一个前指针，该数组确实在存储，所以我真的想要哈希节点指针，我想要一个数组。

这些权利，但在C ++中，您将括号括起来写成星号，以便将其哈希，节点指针就可以了，所以我称它为哈希表，现在在构造函数中，我将其设置为，就是我所说的哈希表，它是一个新的散列节点指针数组，其大小为，十行。

所有十行都为空，所以我想，写添加删除和包含让我们来谈一谈添加，所以如果您想，像这样添加一个值是他们说您知道哈希集点添加37或其他，对，所以告诉我告诉我一些我要在此处添加的内容，价值37哦，您是对的。

对不起，它应该是哈希节点star 10，是的，我需要，十个指针，谢谢，帮助我添加一些东西到这个集合中我该怎么做首先我要去哪里，放这个值我怎么知道在哪里放yeah是的，让我们获取哈希码，换句话说。

就像您知道的int一样，使用此值并将其映射到什么索引，是哈希函数哈希码的正确索引，因此在我们的幻灯片中， 。

已经讨论过哈希函数是什么，无论它在哪里，这里的int mod的绝对值取决于我们已经拥有的数组的容量。

在此之前就谈到了这一点，所以我可以自由地将其放入此文件中，我在这里编写了一个名为哈希码的函数，哈希码返回的绝对值，正确的值调制速率容量，所以我可以调用哈希码，所以现在如果我在这里。

想知道在哪里放置这个东西，我会说int hash等于，值，如果那是37，那会给我回7的感觉，这样，我说在哈希表括号中的哈希值等于值，那是我想做的事情，但这不是正确的语法，否则我在这里想念的是什么，哦。

等等，我们正在努力，所以我们将改变。

对对对，所以我们基本上需要将这张我画的图片做一个哈希注释，在这里，如果我要进行新记录，则必须创建一个新的哈希节点，然后，在该存储桶的链的最前面将哈希表插入其数组中。

如果什么都没有，那将成为唯一的要素，数组，所以我想我要做这样的事情，散列节点star新节点是存储该值的新散列节点，我的意思是，基本上我会说哈希节点哈希等于新节点，但我仍然不见了。

因为像链表中可能已经有一些东西我不想，丢失它以了解我现在编写的代码将取代以前的任何代码，只满足于此节点，所以在这张图片上缺少了什么。

在这里，我创建了这个新节点，并更改了该指针以指向，新节点缺少什么，是的，我需要将这个家伙附加到其余的东西上。

之前在那里，所以我认为我要说的是下一个新节点等于什么，目前该链的前部，现在将其连接到那里，因此此插入，这个人在链表的前面，好吧，所以我只在前面写插入，我认为我可能是错的，但我认为我将其设置为即使所有。

我们写的是添加我可以运行它，它只会打印出表格让我，看看那是真的，等等，在我想我要说之前，等待，让我们开始吧，我在这里有一个主电源，我想我在这里做什么，我正在设置一个场景，然后添加它们，哦。

之后我必须按Enter ，每个广告，哇，它崩溃了，是的，我想我没有设置其他私有变量，认为这就是这里发生的事情，所以在构造函数中，大小为零， ，容量是十，我认为如果不设置这些，主要是bar倒。

基本上没关系，我尝试进行设置，这样我就可以看到之前和之后，添加17准备好，然后我按Enter键，然后添加41。 ，他加了29，再次将他放在第41位，糟糕，我可能不应该这样做，因为那是重复的。

也许我们可以，修复在第二次添加中再次出现9个重复的事件，共有29个，他在37圈，所以你可能会说等等我刚刚写的那幅画怎么样，一些帮助打印数组的方法我在上课之前写的那不是，神奇的命令或其他任何东西。

但您会看到吗，这就是我们的代码，在81的链接列表的最前面插入这些新人，到目前为止，除了重复之外，还算不错，我们有一个漂亮的，好的添加功能让我们编写代码来防止重复，因为我们的测试。

表明我们能够添加两个相同的值，我们不应该那样做，好的，现在让我们来做包含让我们来做包含帮助，知道现在如何将事物添加到哈希集中，如何在，哈希集告诉我一些我可以写的代码，您认为好吗。

请确保我们再次获取该哈希码，我给您，暗示您知道递归如何只讲基本情况或其他正确的方法，在处理哈希集时，有一些共同的主题，总是先像哈希代码一样抓住它，因为这是，您想处理集合的地方吗，好吧。

我现在在那儿做什么。

我这样做是因为我的意思是基本上，就是这个，我现在知道我正在搜索84，所以我已经计算了，那将在第四个索引中，所以现在我需要做什么，遍历链表遍历，查找他们要求的值。

关于，所以你们知道如何遍历链表，您说当前是散列节点或，篡改或等于该链的前端，位于该索引的前端，该链称为哈希表哈希这是一个前指针数组，因此，那是感兴趣的最前面的指针。

所以你说遍历列表我知道如何在当前时反向链接列表，不是null指针，我会做某事，但是接下来我会做cur等于cur ，对，我们已经完成了一百万个链接列表循环，就像我在做什么，访问这些索引中的每一个。

问号部分会出现什么，如果当前节点的数据等于我正在搜索的值，则，是的，这个集合确实包含这个值，所以换句话说。

就像您要搜索84一样，我正在循环地说当前数据等于84 ，不好，接下来是当前数据84否，下一步，依此类推，找到或停止。

当您发现不对时，然后如果我一直到最后，我什么也没退，然后我知道那不在那里，我应该退回false ，对，就是那样做，我觉得对我来说，嘿，也许，这样可以帮助我们避免重复， ，重复是的，是的，完全正确。

只是呼叫包含您是否知道我包含此内容，价值回报不要再添加它，这就是您知道的一点点，说好，我不必走链条寻找它或那是什么，好的，链条很短，不用担心，所以嗯，让我们再次运行它，并对其进行测试。

使它在17到达17 ，在9到达那里，在29到达那里，在41再次到达那里，在9不再这样做，再次没有做到这一点保佑您在29岁时再次做到这一点，所以我认为，我们的广告效果很好，我的意思是说，包含正在工作。

因为我们没有添加这些重复项，但我想我，对包含的内容进行了一些明确的测试，哦，天长地久，好吧，包含41个真实，包含9个真实，包含29个真实，包含41个真实，所以我，意味着这些是哈希如何工作的胆量。

我不知道您是否，相信我，这是一个大O，因为我的意思是我认为当你看着，这张图片并不完全令人信服，因为那是一个大O，因为，它聚集在第五个索引中，所以我不知道那好吗，但是，我在几分钟前说过。

哈希映射哈希集的大小为，选了十个，以便我可以向您解释，以便画出，它，即使在Berkley，您也很容易计算出mod 10 ，大多数情况下都跟着有关的讲座，但是如果，您不想要太多的麻烦。

让我立即尝试解决此问题， ，快速地说明一下，而不是十个，让我们十七岁吧，只是不同的数字而不是整数，您知道这不会，完全解决了问题，实际上我没有提前进行测试，但是还可以，等一下，我要调整一下它的大小。

这样您就可以在这里看到它了，让我们尝试十七，在四十一时在九点到达那里，在第二十九时你注意到吗？ ，二十九不再来了，他们只是在那里发生29 mod ， 17是12对，所以它不会以相同的方式发生冲突。

过去在20在9在29在41在37在37在81在69在20现在看起来我发生了碰撞，二十七和三十七，所以我仍然有一个，但你至少看到这样，当我选择像，怪异的数组大小，因此，如果您深入研究，就像实际的哈希集。

例如我们库中的哈希集或随附的哈希集， Java或Python或任何您会发现它们选择了非常奇怪的尺寸，例如， 137之类的东西，当他们调整大小时，它们跳了3。2或有些奇怪，他们选择了，奇怪的大小。

因为它通常会使数据更有可能，像这样好好均匀地散开，您仍然会拥有这些锁链，您仍然会有几个人，但就像您会发现，您可以添加，很多数据，在大多数情况下，您只有两个或三个链，会说好的。

这是哈希集如何工作的基本概念，我有几个，我想谈更多的时间，但是到目前为止您对什么有疑问吗，我们一直在做或者它是如何工作的，你走了，哦，现在的大小是多少，大小为零，只是因为我忘了说加号，基本上。

当您添加时，您只需说出我的尺寸加上加号，然后尺寸就会增加，就像我想你可以想象的那样，循环并查看所有节点，计算它们，但要花很多时间，所以我只保留一个int字段，为此，让我让我指出一些事情，记住当您打印时。

散列集就像所有杂乱无章的顺序一样，我说，哦，这是个无法预测的命令，如果我愿意的话，您明白为什么现在会发生这种情况吗？ ，打印出来，我可能会从顶部开始，然后向下循环到右侧。

所以他们要打印的顺序是1769 ， 20 30 755五个看起来很随意不是吗？不是完全随机吗？ ，基于这种散列的节奏，它孕育了所有的节奏，其mod为17的mod首先为零。

然后所有其mod为17的mod为1。 ，分钟，所以它不是随机的，但对没有，了解到快乐又对，所以这就是为什么当您打印这些收藏集时，他们看起来很奇怪，我快没时间了，我要告诉你的最后一件事我。

这就是哈希集如何工作的主要思想，我最后要说的是，当你在哪里，当哈希集太大时，我在这里，你知道我们总是，有一个很好的想法，你有一个数组，你在这里调整大小，现在，我希望您能看到您实际上不需要，因为您可以。

只是让变化变得越来越长，如果你想，但我希望您会看到那时大O开始变得starts ，您正在查看这些长链，因此如果我更改阵列，您现在就可以，大小，它可以更好地传播元素，这称为重新哈希处理。

但是重新哈希处理是，不平凡的，因为比如说您在那儿拥有一条链，就像您知道自己一样，如果将尺寸从10调整为20，则在接下来的二十四个45414中有一个链，您必须将其中一些从索引4移至索引14。

因为它们是mod ，进行了更改，因此当您调整哈希表的大小时，您实际上必须去查看所有，元素并将其移至最适合您理解的新索引，如果该阵列中所有黄色的凡尔赛将在此处在左侧，但是现在您将大小调整为20。

它们就过去了，因此调整哈希表的大小是，与调整常规向量数组或类似的东西的大小相比，它不那么琐碎，好的，我今天没有时间，请度过一个愉快的周末， ，开始做作业7，下周见。