diff --git "a/pA-8eBZvN1E.json" "b/pA-8eBZvN1E.json" new file mode 100644--- /dev/null +++ "b/pA-8eBZvN1E.json" @@ -0,0 +1,10817 @@ +[ + { + "text": " ", + "start": 0.0, + "duration": 17.255 + }, + { + "text": "SPEAKER 1: All right, this is\nCS50 and this is week five.", + "start": 17.255, + "duration": 3.685 + }, + { + "text": "And let's take a look at\nwhere we left off last time.", + "start": 20.94, + "duration": 2.62 + }, + { + "text": "You may recall this guy here,\nBinky from our friends at Stanford.", + "start": 23.56, + "duration": 4.14 + }, + { + "text": "And we used Binky to start\ntalking about pointers.", + "start": 27.7, + "duration": 3.25 + }, + { + "text": "What is a pointer?", + "start": 30.95, + "duration": 1.209 + }, + { + "text": "So, a pointer is just\nan address, the location", + "start": 32.159, + "duration": 2.336 + }, + { + "text": "of some piece of data in memory,\nbecause recall at the end of the day", + "start": 34.495, + "duration": 2.875 + }, + { + "text": "your computer just has a few pieces\nof hardware inside of it, one of which", + "start": 37.37, + "duration": 4.36 + }, + { + "text": "is RAM or Random Access Memory.", + "start": 41.73, + "duration": 2.18 + }, + { + "text": "And in RAM you have the ability to\nstore bunches and bunches of bytes,", + "start": 43.91, + "duration": 4.04 + }, + { + "text": "or kilobytes, or\nmegabytes, or gigabytes,", + "start": 47.95, + "duration": 2.117 + }, + { + "text": "depending on how much memory you have.", + "start": 50.067, + "duration": 1.583 + }, + { + "text": "And if you assume that no\nmatter how much RAM you have you", + "start": 51.65, + "duration": 3.41 + }, + { + "text": "can enumerate the bytes-- this is byte\n0, this is byte 1, this is byte 2,", + "start": 55.06, + "duration": 4.06 + }, + { + "text": "and so forth-- you can give each of\nthe bytes of your computer's memory", + "start": 59.12, + "duration": 3.19 + }, + { + "text": "an address and those addresses\nare simply called pointers.", + "start": 62.31, + "duration": 3.149 + }, + { + "text": "And now in C we have the\nability to use pointers", + "start": 65.459, + "duration": 3.471 + }, + { + "text": "both to go to any location\nin memory that we want", + "start": 68.93, + "duration": 3.5 + }, + { + "text": "and even to dynamically allocate\nmemory in case we don't necessarily", + "start": 72.43, + "duration": 3.43 + }, + { + "text": "know a priori how much memory\nwe might need for a program.", + "start": 75.86, + "duration": 4.177 + }, + { + "text": "Now, in terms of your\ncomputer's RAM, recall", + "start": 80.037, + "duration": 1.833 + }, + { + "text": "that we divided the\nworld into this picture", + "start": 81.87, + "duration": 2.0 + }, + { + "text": "here whereby if this rectangular region,\narbitrarily, represents your computer's", + "start": 83.87, + "duration": 5.01 + }, + { + "text": "memory, here is how the\ncomputer divvies it up", + "start": 88.88, + "duration": 2.02 + }, + { + "text": "when you're actually using a program.", + "start": 90.9, + "duration": 2.37 + }, + { + "text": "At the bottom of your computer's area\nof memory, you have the so-called stack.", + "start": 93.27, + "duration": 4.31 + }, + { + "text": "And recall that the stack is where\nany time you call a function,", + "start": 97.58, + "duration": 3.17 + }, + { + "text": "it gets a slice of\nmemory-- a frame of memory,", + "start": 100.75, + "duration": 2.51 + }, + { + "text": "if you will-- for all of its local\nvariables, all of its arguments", + "start": 103.26, + "duration": 2.84 + }, + { + "text": "and anything else that it might need.", + "start": 106.1, + "duration": 1.69 + }, + { + "text": "On top of that might go another\nslice or frame of memory", + "start": 107.79, + "duration": 3.14 + }, + { + "text": "if that first function calls another.", + "start": 110.93, + "duration": 1.93 + }, + { + "text": "And if that second function in\nturn calls another function,", + "start": 112.86, + "duration": 2.56 + }, + { + "text": "you might have a third\nframe on the stack.", + "start": 115.42, + "duration": 2.064 + }, + { + "text": "Of course, this doesn't end well if you\nkeep calling function after function", + "start": 117.484, + "duration": 3.166 + }, + { + "text": "after function after function.", + "start": 120.65, + "duration": 1.2 + }, + { + "text": "And so, hopefully you don't accidentally\ninduce some kind of infinite loop", + "start": 121.85, + "duration": 3.13 + }, + { + "text": "such that these frames pile on\ntop of each other infinitely", + "start": 124.98, + "duration": 3.08 + }, + { + "text": "many times, because eventually they'll\nrun the risk of hitting the heap.", + "start": 128.06, + "duration": 3.39 + }, + { + "text": "Now, the heap is the same\ntype of physical memory.", + "start": 131.45, + "duration": 2.1 + }, + { + "text": "You're just using it in\na slightly different way.", + "start": 133.55, + "duration": 2.59 + }, + { + "text": "The heap is used any time you want\nto dynamically allocate memory,", + "start": 136.14, + "duration": 3.95 + }, + { + "text": "when you don't know in\nadvance how many bytes", + "start": 140.09, + "duration": 2.23 + }, + { + "text": "you need but you do know once the\nprogram is running how many you now", + "start": 142.32, + "duration": 2.95 + }, + { + "text": "want.", + "start": 145.27, + "duration": 0.57 + }, + { + "text": "You can ask via functions\nlike malloc the operating", + "start": 145.84, + "duration": 3.13 + }, + { + "text": "system for some number\nof bytes, and those bytes", + "start": 148.97, + "duration": 2.26 + }, + { + "text": "are allocated from the heap.", + "start": 151.23, + "duration": 1.78 + }, + { + "text": "So, those two have addresses or numbers.", + "start": 153.01, + "duration": 1.862 + }, + { + "text": "And so, the operating\nsystem, by way of malloc,", + "start": 154.872, + "duration": 1.958 + }, + { + "text": "just figures out which of\nthose bytes are not yet", + "start": 156.83, + "duration": 2.041 + }, + { + "text": "being used so that you can\nnow put whatever piece of data", + "start": 158.871, + "duration": 3.229 + }, + { + "text": "you have in that particular place.", + "start": 162.1, + "duration": 1.972 + }, + { + "text": "Now, beyond that [? appear ?]\nthings like initialized data,", + "start": 164.072, + "duration": 2.458 + }, + { + "text": "uninitialized data.", + "start": 166.53, + "duration": 0.91 + }, + { + "text": "That's where things like global\nvariables that are initialized or not", + "start": 167.44, + "duration": 3.26 + }, + { + "text": "end up that might be outside\nof your main function.", + "start": 170.7, + "duration": 2.36 + }, + { + "text": "And then above that is the\nso-called text segment,", + "start": 173.06, + "duration": 2.12 + }, + { + "text": "which are these zeros and ones\nthat actually compose your program.", + "start": 175.18, + "duration": 3.75 + }, + { + "text": "So when you double click an\nicon on Windows or Mac OS", + "start": 178.93, + "duration": 3.33 + }, + { + "text": "to run a program or you type dot slash\nsomething in the Linux command line", + "start": 182.26, + "duration": 3.99 + }, + { + "text": "environment in order to run a program,\nthe bits that compose your program", + "start": 186.25, + "duration": 3.83 + }, + { + "text": "are loaded also into memory\nup into this region here.", + "start": 190.08, + "duration": 4.1 + }, + { + "text": "So, at the end of the day, you have\naccess to just pretty generic memory,", + "start": 194.18, + "duration": 3.92 + }, + { + "text": "but we use it in these different ways.", + "start": 198.1, + "duration": 1.74 + }, + { + "text": "And it allows us to\nultimately solve problems", + "start": 199.84, + "duration": 2.88 + }, + { + "text": "that we might not have\nbeen able to in the past.", + "start": 202.72, + "duration": 2.646 + }, + { + "text": "Recall for instance this example here,\ndeliberately shown in red because it", + "start": 205.366, + "duration": 3.124 + }, + { + "text": "was [? buggy. ?] This does not work.", + "start": 208.49, + "duration": 2.09 + }, + { + "text": "Now, logically, it does do the swap that\nwe intend whereby a goes into b and b", + "start": 210.58, + "duration": 6.24 + }, + { + "text": "goes into a.", + "start": 216.82, + "duration": 0.74 + }, + { + "text": "And we achieve that result by\nway of this temporary variable", + "start": 217.56, + "duration": 2.5 + }, + { + "text": "so that we have a temporary placeholder\ninto which to store one of those values", + "start": 220.06, + "duration": 4.14 + }, + { + "text": "while doing the swap.", + "start": 224.2, + "duration": 1.31 + }, + { + "text": "But it had no permanent impact on the\ntwo variables that were passed into it.", + "start": 225.51, + "duration": 5.02 + }, + { + "text": "And that was because by default in C any\ntime you pass arguments to a function,", + "start": 230.53, + "duration": 3.46 + }, + { + "text": "those arguments are passed\nso to speak, by value.", + "start": 233.99, + "duration": 2.83 + }, + { + "text": "You get copies of those values\nbeing passed into a function.", + "start": 236.82, + "duration": 3.49 + }, + { + "text": "And so, if main, for instance,\nhas two variables, x and y--", + "start": 240.31, + "duration": 3.29 + }, + { + "text": "as they did last time--\nand you pass x and y", + "start": 243.6, + "duration": 2.19 + }, + { + "text": "into a function like this\none here swap, x and y", + "start": 245.79, + "duration": 3.16 + }, + { + "text": "are going to get copied\nas a and b respectively.", + "start": 248.95, + "duration": 2.75 + }, + { + "text": "So you might perfectly,\nlogically, correctly swap a and b,", + "start": 251.7, + "duration": 3.63 + }, + { + "text": "but you're having no permanent\nimpact on x and y themselves.", + "start": 255.33, + "duration": 5.129 + }, + { + "text": "But what if, per this\ngreen version here,", + "start": 260.459, + "duration": 3.071 + }, + { + "text": "we reimplement swap to be\na little more complicated", + "start": 263.53, + "duration": 3.15 + }, + { + "text": "looking, but at the end of\nthe day actually correct?", + "start": 266.68, + "duration": 3.47 + }, + { + "text": "Notice now we've declared\na and b not to be", + "start": 270.15, + "duration": 2.38 + }, + { + "text": "integers but to be pointers to\nintegers, the addresses of integers.", + "start": 272.53, + "duration": 4.61 + }, + { + "text": "And that's what's implied by\nthe star that we're putting", + "start": 277.14, + "duration": 2.51 + }, + { + "text": "right there before the variable's name.", + "start": 279.65, + "duration": 1.89 + }, + { + "text": "Meanwhile, inside of the\nbody of this function,", + "start": 281.54, + "duration": 2.004 + }, + { + "text": "we still have three lines of code.", + "start": 283.544, + "duration": 1.416 + }, + { + "text": "And we're still using a temporary\nvariable, and that in itself", + "start": 284.96, + "duration": 2.86 + }, + { + "text": "is not a pointer.", + "start": 287.82, + "duration": 0.73 + }, + { + "text": "It's just an integer\nas before, but notice", + "start": 288.55, + "duration": 2.44 + }, + { + "text": "we're using this star notation\nagain, albeit for a different purpose", + "start": 290.99, + "duration": 3.18 + }, + { + "text": "to actually dereference these pointers.", + "start": 294.17, + "duration": 2.58 + }, + { + "text": "Recall that int star a and int star\nb means give me a variable that", + "start": 296.75, + "duration": 5.4 + }, + { + "text": "can store the address of an integer.", + "start": 302.15, + "duration": 1.86 + }, + { + "text": "That's declaring a pointer.", + "start": 304.01, + "duration": 1.81 + }, + { + "text": "Meanwhile, if you just say star\na without declaring something", + "start": 305.82, + "duration": 3.8 + }, + { + "text": "to the left of it with\na data type like int,", + "start": 309.62, + "duration": 1.99 + }, + { + "text": "you're saying go to the\naddress that is in a.", + "start": 311.61, + "duration": 3.02 + }, + { + "text": "So if a is an address,\nstar a is at that address,", + "start": 314.63, + "duration": 4.02 + }, + { + "text": "which of course per its declaration\nis going to be an integer.", + "start": 318.65, + "duration": 3.11 + }, + { + "text": "Similarly, star b means\ngo to the address in b.", + "start": 321.76, + "duration": 2.4 + }, + { + "text": "Star a means go to the address in a\nand put the former into the latter,", + "start": 324.16, + "duration": 5.35 + }, + { + "text": "ultimately putting the value of temp at\nthe address in b-- so absolutely more", + "start": 329.51, + "duration": 4.36 + }, + { + "text": "complicated at first glance,\nbut if you consider again", + "start": 333.87, + "duration": 2.25 + }, + { + "text": "the first principles of what's\ngoing on here, all we are doing", + "start": 336.12, + "duration": 3.31 + }, + { + "text": "are moving things around in memory.", + "start": 339.43, + "duration": 3.027 + }, + { + "text": "And we can do that now\nbecause we have the ability", + "start": 342.457, + "duration": 2.083 + }, + { + "text": "to express the locations, the\nnumeric locations of where", + "start": 344.54, + "duration": 2.91 + }, + { + "text": "things are in memory.", + "start": 347.45, + "duration": 1.05 + }, + { + "text": "But nicely enough, we,\nthe programmer, don't have", + "start": 348.5, + "duration": 2.28 + }, + { + "text": "to care where things are in memory.", + "start": 350.78, + "duration": 1.97 + }, + { + "text": "We can access things symbolically\nas we're doing here with a and b.", + "start": 352.75, + "duration": 4.33 + }, + { + "text": "So even though we might\nhave seen on the screen", + "start": 357.08, + "duration": 2.18 + }, + { + "text": "or you might see while debugging\nactual addresses of memory,", + "start": 359.26, + "duration": 3.37 + }, + { + "text": "rarely does that actually\nmatter in practice.", + "start": 362.63, + "duration": 3.02 + }, + { + "text": "We can deal with everything we've\nlearned thus far symbolically.", + "start": 365.65, + "duration": 3.58 + }, + { + "text": "Now, last time we also took a\nlook at the world of forensics,", + "start": 369.23, + "duration": 3.57 + }, + { + "text": "and we took a look at how images are\nimplemented and specifically file", + "start": 372.8, + "duration": 3.1 + }, + { + "text": "formats like BNP, and JPEG,\nand GIF, and yet others.", + "start": 375.9, + "duration": 3.61 + }, + { + "text": "And we glanced into [? Asmila's ?]\nhere as we tried to enhance this image,", + "start": 379.51, + "duration": 4.13 + }, + { + "text": "but of course, there was only\nfinite amount of information.", + "start": 383.64, + "duration": 3.64 + }, + { + "text": "So, what you see is what you get\nin terms of any kind of glint", + "start": 387.28, + "duration": 3.07 + }, + { + "text": "or suspect in her eyes.", + "start": 390.35, + "duration": 1.91 + }, + { + "text": "But we did this in part\nso that we could also", + "start": 392.26, + "duration": 2.1 + }, + { + "text": "introduce another feature of C that\nallows us to declare our own data", + "start": 394.36, + "duration": 4.06 + }, + { + "text": "types, indeed our own data structures.", + "start": 398.42, + "duration": 2.697 + }, + { + "text": "For instance, we proposed\nthat if you wanted", + "start": 401.117, + "duration": 1.833 + }, + { + "text": "to write a program\nthat stores a student,", + "start": 402.95, + "duration": 3.1 + }, + { + "text": "you could actually declare\nyour own student data type", + "start": 406.05, + "duration": 2.93 + }, + { + "text": "inside of which is a name and\ninside of which is a dorm,", + "start": 408.98, + "duration": 3.87 + }, + { + "text": "and anything else that\nyou might actually want.", + "start": 412.85, + "duration": 2.15 + }, + { + "text": "Meanwhile, this syntax here gives\nus a new data type called student", + "start": 415.0, + "duration": 4.35 + }, + { + "text": "so that if we want to write a\nprogram that implements students,", + "start": 419.35, + "duration": 2.73 + }, + { + "text": "we can actually wrap related\ninformation together like name and dorm", + "start": 422.08, + "duration": 4.18 + }, + { + "text": "without having to maintain\na whole bunch of strings", + "start": 426.26, + "duration": 2.872 + }, + { + "text": "for just names and a whole\nbunch of strings for just dorms.", + "start": 429.132, + "duration": 2.458 + }, + { + "text": "We can actually encapsulate things\nall inside of one structure.", + "start": 431.59, + "duration": 3.69 + }, + { + "text": "And indeed encapsulation is another\nprinciple of computer science", + "start": 435.28, + "duration": 3.09 + }, + { + "text": "that you'll see throughout program\nand throughout the field itself.", + "start": 438.37, + "duration": 3.98 + }, + { + "text": "So, what do we now do this time?", + "start": 442.35, + "duration": 2.38 + }, + { + "text": "So, today we introduce more\nsophisticated ingredients", + "start": 444.73, + "duration": 4.07 + }, + { + "text": "with which we can solve problems and\nwe revisit a problem from the past", + "start": 448.8, + "duration": 3.7 + }, + { + "text": "that we thought we had rather\nknocked off and had solved.", + "start": 452.5, + "duration": 2.86 + }, + { + "text": "So, this might represent\na whole bunch of names,", + "start": 455.36, + "duration": 2.91 + }, + { + "text": "a whole bunch of numbers, a whole bunch\nof telephone numbers in a phone book", + "start": 458.27, + "duration": 3.87 + }, + { + "text": "back to back to back to\nback stored in this case", + "start": 462.14, + "duration": 2.67 + }, + { + "text": "in the form of an array, the simplest\nof data structure, so to speak,", + "start": 464.81, + "duration": 3.11 + }, + { + "text": "that we've discussed thus far.", + "start": 467.92, + "duration": 1.25 + }, + { + "text": "And an array, again, is a contiguous\nblock of memory each of whose element--", + "start": 469.17, + "duration": 4.5 + }, + { + "text": "typically are of the same data type,\nintegers, or strings, or the like--", + "start": 473.67, + "duration": 3.82 + }, + { + "text": "and they are by definition\nback to back to back to back,", + "start": 477.49, + "duration": 3.03 + }, + { + "text": "which allows you random access.", + "start": 480.52, + "duration": 1.56 + }, + { + "text": "Which means you can jump\nto any of these locations", + "start": 482.08, + "duration": 2.083 + }, + { + "text": "instantly just by using in C\nthat square bracket notation", + "start": 484.163, + "duration": 2.957 + }, + { + "text": "or as we saw last time\nusing pointer arithmetic,", + "start": 487.12, + "duration": 3.46 + }, + { + "text": "actually using the star operator\nand maybe adding some number two", + "start": 490.58, + "duration": 3.29 + }, + { + "text": "and address to get at\nsome subsequent address.", + "start": 493.87, + "duration": 3.44 + }, + { + "text": "But it turns out there's a few problems\nwith this fundamental approach.", + "start": 497.31, + "duration": 4.01 + }, + { + "text": "Nice and as simple as it is, it would\nseem that we rather paint ourselves", + "start": 501.32, + "duration": 4.13 + }, + { + "text": "into a corner with this approach.", + "start": 505.45, + "duration": 1.96 + }, + { + "text": "This array has 1, 2, 3, 4, 5, 6 total\nelements, at least as depicted here.", + "start": 507.41, + "duration": 5.86 + }, + { + "text": "So that's fine if you want\nto insert a number, and then", + "start": 513.27, + "duration": 2.36 + }, + { + "text": "another number, and\nthen four more numbers.", + "start": 515.63, + "duration": 1.791 + }, + { + "text": "But what if you want to then\ninsert a seventh number,", + "start": 517.421, + "duration": 2.636 + }, + { + "text": "not to mention an eighth number\nor a ninth number or the like?", + "start": 520.057, + "duration": 2.583 + }, + { + "text": "Well, where do you put them?", + "start": 522.64, + "duration": 1.14 + }, + { + "text": "Well, you might think,\nwell, that's fine.", + "start": 523.78, + "duration": 1.708 + }, + { + "text": "I'm just going to go put the\nseventh number over here,", + "start": 525.488, + "duration": 2.732 + }, + { + "text": "or the eighth number over here,\nor the ninth number over there.", + "start": 528.22, + "duration": 3.37 + }, + { + "text": "But you can't just blindly do that.", + "start": 531.59, + "duration": 3.1 + }, + { + "text": "If this memory is being\nmanaged not by you", + "start": 534.69, + "duration": 2.19 + }, + { + "text": "per se but by malloc and by the computer\nitself inside-- and your program,", + "start": 536.88, + "duration": 4.25 + }, + { + "text": "this memory over here, while\nit might physically exist,", + "start": 541.13, + "duration": 2.79 + }, + { + "text": "might be used by some other part\nof your program all together.", + "start": 543.92, + "duration": 4.065 + }, + { + "text": "It doesn't necessarily belong to\nyou unless you've asked for it.", + "start": 547.985, + "duration": 2.775 + }, + { + "text": "And the problem with an array is\nthat as we've seen it typically", + "start": 550.76, + "duration": 3.14 + }, + { + "text": "you declare their size in advance,\nas with the square bracket notation,", + "start": 553.9, + "duration": 3.2 + }, + { + "text": "and say give me six integers or give me\nsix something or others, but that's it.", + "start": 557.1, + "duration": 4.42 + }, + { + "text": "You have to decide in advance.", + "start": 561.52, + "duration": 1.58 + }, + { + "text": "You can't just grow it as you can in\nsome programming languages thereafter.", + "start": 563.1, + "duration": 3.67 + }, + { + "text": "You've rather painted\nyourself into a corner.", + "start": 566.77, + "duration": 2.54 + }, + { + "text": "But with malloc and other\nfunctions like we saw last time,", + "start": 569.31, + "duration": 3.77 + }, + { + "text": "you can actually allocate\nmore memory using malloc.", + "start": 573.08, + "duration": 3.24 + }, + { + "text": "Unfortunately, it might end up in\nanother location in your computer's", + "start": 576.32, + "duration": 3.897 + }, + { + "text": "memory, so you might\nhave to do some copying", + "start": 580.217, + "duration": 1.833 + }, + { + "text": "to take the original six\nelements and move them", + "start": 582.05, + "duration": 1.75 + }, + { + "text": "elsewhere just to make room for more.", + "start": 583.8, + "duration": 1.57 + }, + { + "text": "And there is a data function for\nthat, something called [? re-alloc ?]", + "start": 585.37, + "duration": 2.916 + }, + { + "text": "or reallocate.", + "start": 588.286, + "duration": 0.884 + }, + { + "text": "And indeed it can do exactly that.", + "start": 589.17, + "duration": 1.56 + }, + { + "text": "It can give you a bigger\nchunk of memory and reallocate", + "start": 590.73, + "duration": 2.84 + }, + { + "text": "what was previously there\nto be a larger [? size. ?]", + "start": 593.57, + "duration": 2.864 + }, + { + "text": "But you have to do a little bit of work.", + "start": 596.434, + "duration": 1.666 + }, + { + "text": "You have to invoke it\nin order achieve that.", + "start": 598.1, + "duration": 1.833 + }, + { + "text": "You can't just blindly keep adding\nthings at the end of this array.", + "start": 599.933, + "duration": 3.327 + }, + { + "text": "Now, unfortunately, while a solution\nthat might not be very efficient.", + "start": 603.26, + "duration": 4.46 + }, + { + "text": "Even if you can allocate a bigger\nchunk of memory that's bigger than six", + "start": 607.72, + "duration": 3.841 + }, + { + "text": "because you have more numbers,\nfor instance, to store,", + "start": 611.561, + "duration": 2.249 + }, + { + "text": "what if that takes a bit of time?", + "start": 613.81, + "duration": 3.059 + }, + { + "text": "And indeed it's going to.", + "start": 616.869, + "duration": 1.041 + }, + { + "text": "If you allocate more integers\nsomewhere else in memory", + "start": 617.91, + "duration": 2.52 + }, + { + "text": "you still have to copy\nthose original values,", + "start": 620.43, + "duration": 1.93 + }, + { + "text": "and now it just feels\nlike you're wasting time.", + "start": 622.36, + "duration": 1.97 + }, + { + "text": "Now, instead of just inserting\nthings into the list,", + "start": 624.33, + "duration": 2.18 + }, + { + "text": "you might have to copy it into a\nbigger space, reallocate things, grow.", + "start": 626.51, + "duration": 4.01 + }, + { + "text": "It's a lot more work.", + "start": 630.52, + "duration": 0.9 + }, + { + "text": "And all of that discussion of\nrunning time and performance", + "start": 631.42, + "duration": 3.22 + }, + { + "text": "comes back into play, because if that\nwhole copying process and reallocating", + "start": 634.64, + "duration": 4.02 + }, + { + "text": "is costing you time, your\nalgorithm or your program", + "start": 638.66, + "duration": 2.86 + }, + { + "text": "ultimately might not really be\nas fast as you might want it.", + "start": 641.52, + "duration": 3.73 + }, + { + "text": "So, what could we do instead?", + "start": 645.25, + "duration": 1.46 + }, + { + "text": "What could we do instead\nin order to solve", + "start": 646.71, + "duration": 2.54 + }, + { + "text": "this problem dynamically, so to\nspeak, that being the operative word.", + "start": 649.25, + "duration": 3.81 + }, + { + "text": "And luckily enough, last week we learned\nthat there is dynamic memory allocation", + "start": 653.06, + "duration": 4.86 + }, + { + "text": "in C by way of that function malloc.", + "start": 657.92, + "duration": 2.2 + }, + { + "text": "And we also learned that there is\nways of representing structures", + "start": 660.12, + "duration": 3.21 + }, + { + "text": "in C that you don't necessarily\nget with the language itself,", + "start": 663.33, + "duration": 3.949 + }, + { + "text": "because they're not primitives.", + "start": 667.279, + "duration": 1.291 + }, + { + "text": "They're not built in.", + "start": 668.57, + "duration": 0.96 + }, + { + "text": "In other words, let me propose\nthis as a solution to our problem.", + "start": 669.53, + "duration": 4.35 + }, + { + "text": "This is a list of, let's see,\nfive numbers it would seem,", + "start": 673.88, + "duration": 4.14 + }, + { + "text": "9, 17, 22, 26, and 34.", + "start": 678.02, + "duration": 4.16 + }, + { + "text": "Pretty arbitrary right\nnow, but you might", + "start": 682.18, + "duration": 2.16 + }, + { + "text": "imagine very simply drawing those\nsame numbers-- 9, 17, 22, 26,", + "start": 684.34, + "duration": 3.51 + }, + { + "text": "34-- in the form of an array and\nthey're clearly deliberately sorted.", + "start": 687.85, + "duration": 5.37 + }, + { + "text": "But again, what if you wanted to grow\nthat array or even shrink that array", + "start": 693.22, + "duration": 3.87 + }, + { + "text": "dynamically over time?", + "start": 697.09, + "duration": 1.76 + }, + { + "text": "Well, let me propose that we not draw\nthose numbers back to back to back", + "start": 698.85, + "duration": 3.52 + }, + { + "text": "to back literally next to each other\nbut allow ourselves potentially", + "start": 702.37, + "duration": 3.58 + }, + { + "text": "a little bit of space?", + "start": 705.95, + "duration": 1.65 + }, + { + "text": "But if that's the case and nine is here\nin my computer's memory and 17 is here", + "start": 707.6, + "duration": 4.32 + }, + { + "text": "and 22 is here, or over here,\nor over here-- in other words,", + "start": 711.92, + "duration": 3.09 + }, + { + "text": "what if I relax the constraint that\nmy numbers or my data types more", + "start": 715.01, + "duration": 3.43 + }, + { + "text": "generally have to be stored contiguously\nback to back to back to back in memory", + "start": 718.44, + "duration": 4.27 + }, + { + "text": "and instead allow them to be anywhere,\nindeed anywhere a function like malloc", + "start": 722.71, + "duration": 3.6 + }, + { + "text": "wants to give me more\nmemory, that's fine.", + "start": 726.31, + "duration": 2.12 + }, + { + "text": "If it wants to give me memory up here\nin my computer, I'll deal with that.", + "start": 728.43, + "duration": 2.53 + }, + { + "text": "If it wants to give me extra\nmemory over here, that's fine.", + "start": 730.96, + "duration": 2.458 + }, + { + "text": "I'll deal with it, because I'll use\nthese conceptual arrows to stitch", + "start": 733.418, + "duration": 4.092 + }, + { + "text": "together my data structure this time.", + "start": 737.51, + "duration": 3.096 + }, + { + "text": "And now, where have we seen\nthese kinds of arrows before?", + "start": 740.606, + "duration": 2.374 + }, + { + "text": "What feature of C allows\nus to connect one thing", + "start": 742.98, + "duration": 3.64 + }, + { + "text": "to another where a la chutes and\nladders get from one place to another?", + "start": 746.62, + "duration": 4.48 + }, + { + "text": "Well, that's exactly what we saw\nlast time which was pointers.", + "start": 751.1, + "duration": 3.13 + }, + { + "text": "While we've drawn these here per the\nsnippet from a textbook using arrows,", + "start": 754.23, + "duration": 4.67 + }, + { + "text": "those are really just pointers.", + "start": 758.9, + "duration": 1.51 + }, + { + "text": "And what does each of\nthese rectangles represent?", + "start": 760.41, + "duration": 3.22 + }, + { + "text": "Well, clearly a number in the\ntop half of the rectangle,", + "start": 763.63, + "duration": 3.07 + }, + { + "text": "but I claim that at the bottom\nhalf of these rectangles", + "start": 766.7, + "duration": 3.11 + }, + { + "text": "let's consider that bottom rectangle\nto just be another piece of data,", + "start": 769.81, + "duration": 3.22 + }, + { + "text": "specifically an int star, a pointer.", + "start": 773.03, + "duration": 2.79 + }, + { + "text": "Or rather not a pointer because it seems\nto be pointing not just to the number", + "start": 775.82, + "duration": 4.13 + }, + { + "text": "but to this whole rectangle,\nso I need some new terminology.", + "start": 779.95, + "duration": 3.37 + }, + { + "text": "I need some kind of structure to\ncontain an integer and this pointer.", + "start": 783.32, + "duration": 5.58 + }, + { + "text": "And for that, I think I'm\ngoing to need a struct.", + "start": 788.9, + "duration": 2.4 + }, + { + "text": "And indeed let me propose that to\nsolve this problem we give ourselves", + "start": 791.3, + "duration": 4.54 + }, + { + "text": "this building block as a new\nC data type called a node.", + "start": 795.84, + "duration": 3.802 + }, + { + "text": "You can call it anything\nyou want, but the convention", + "start": 799.642, + "duration": 2.208 + }, + { + "text": "would be to call something like\nthis in a data structure-- that's", + "start": 801.85, + "duration": 2.27 + }, + { + "text": "like a puzzle piece or a building\nblock in a data structure", + "start": 804.12, + "duration": 2.458 + }, + { + "text": "would be called a node.", + "start": 806.578, + "duration": 1.192 + }, + { + "text": "Let me propose that we\ndefine it as follows.", + "start": 807.77, + "duration": 2.98 + }, + { + "text": "I'm using that same syntax from last\ntime with which we declared a student", + "start": 810.75, + "duration": 3.31 + }, + { + "text": "data type, but here I'm saying\ninside of this data structure,", + "start": 814.06, + "duration": 3.66 + }, + { + "text": "this node shall be an int.", + "start": 817.72, + "duration": 2.154 + }, + { + "text": "And that's pretty straightforward.", + "start": 819.874, + "duration": 1.416 + }, + { + "text": "Just like a student might\nhave a name and a dorm,", + "start": 821.29, + "duration": 2.041 + }, + { + "text": "this node will have an\nint called n arbitrarily.", + "start": 823.331, + "duration": 3.589 + }, + { + "text": "And then the only piece of detail\nthat's a little bit new now is", + "start": 826.92, + "duration": 3.67 + }, + { + "text": "the second line, struct node star next.", + "start": 830.59, + "duration": 2.769 + }, + { + "text": "Now, what does that mean?", + "start": 833.359, + "duration": 1.041 + }, + { + "text": "It's pretty verbose, but struct node\nis just recursively, if you will,", + "start": 834.4, + "duration": 4.73 + }, + { + "text": "referring to this same\ntype of data structure.", + "start": 839.13, + "duration": 2.95 + }, + { + "text": "Star means this is going to be a\npointer, the address of one such thing,", + "start": 842.08, + "duration": 3.72 + }, + { + "text": "and next is just an arbitrary\nbut pretty reasonable", + "start": 845.8, + "duration": 2.36 + }, + { + "text": "name to give to such a pointer.", + "start": 848.16, + "duration": 2.06 + }, + { + "text": "So this line here,\nstruct node star next,", + "start": 850.22, + "duration": 2.83 + }, + { + "text": "is the incantation in C\nwith which you declare", + "start": 853.05, + "duration": 3.74 + }, + { + "text": "one of those arrows that will\npoint from one node, one rectangle", + "start": 856.79, + "duration": 3.9 + }, + { + "text": "to another node, another rectangle.", + "start": 860.69, + "duration": 2.57 + }, + { + "text": "And the fact that we have a\nlittle bit of additional verbiage", + "start": 863.26, + "duration": 3.44 + }, + { + "text": "up here, typedef struct\nnode, is because again C", + "start": 866.7, + "duration": 3.58 + }, + { + "text": "is a language that is read\ntop to bottom, left to right,", + "start": 870.28, + "duration": 2.53 + }, + { + "text": "so words have to exist\nbefore you actually use them.", + "start": 872.81, + "duration": 2.77 + }, + { + "text": "So, whereas last time when\nwe declared a student,", + "start": 875.58, + "duration": 2.064 + }, + { + "text": "we didn't actually mention struct\nstudent or anything like that.", + "start": 877.644, + "duration": 2.666 + }, + { + "text": "We just said typedef open curly brace.", + "start": 880.31, + "duration": 2.26 + }, + { + "text": "Today, when declaring\na node, we actually", + "start": 882.57, + "duration": 2.26 + }, + { + "text": "have to have some additional syntax\nhere just called struct node.", + "start": 884.83, + "duration": 3.167 + }, + { + "text": "And technically this\nword could be anything,", + "start": 887.997, + "duration": 1.833 + }, + { + "text": "but I'll leave it as\nnode for consistency.", + "start": 889.83, + "duration": 2.09 + }, + { + "text": "And that allows me\ninside of this definition", + "start": 891.92, + "duration": 2.68 + }, + { + "text": "or to specify that the\nsecond data member is", + "start": 894.6, + "duration": 3.75 + }, + { + "text": "going to be a pointer to exactly\nthat kind of data structure.", + "start": 898.35, + "duration": 3.08 + }, + { + "text": "But typedef, just to be clear, allows\nme to type a smaller name for this data", + "start": 901.43, + "duration": 4.75 + }, + { + "text": "structure here, which I will\nsimply called node at this point.", + "start": 906.18, + "duration": 4.89 + }, + { + "text": "So, what can we actually do with\nthis kind of data structure now?", + "start": 911.07, + "duration": 3.066 + }, + { + "text": "And, indeed, let's give\nthis data structure a name.", + "start": 914.136, + "duration": 2.124 + }, + { + "text": "Let's start calling a linked list.", + "start": 916.26, + "duration": 1.89 + }, + { + "text": "Previously, we had arrays, but now\nwe have linked lists, both of which", + "start": 918.15, + "duration": 3.482 + }, + { + "text": "at the end of the day are types\nof lists, but linked lists,", + "start": 921.632, + "duration": 2.458 + }, + { + "text": "as the name suggests, are linked or\nthreaded together using pointers.", + "start": 924.09, + "duration": 3.66 + }, + { + "text": "Now, when you have a linked list,\nwhat might be some operations,", + "start": 927.75, + "duration": 3.146 + }, + { + "text": "some algorithms that you\nmight want to run on them?", + "start": 930.896, + "duration": 2.124 + }, + { + "text": "Well, if you've got a linked list of\nsay numbers, for the sake of discussion,", + "start": 933.02, + "duration": 3.208 + }, + { + "text": "you might want to insert a\nnew number into that list.", + "start": 936.228, + "duration": 2.253 + }, + { + "text": "You might want to delete\na number from that list", + "start": 938.481, + "duration": 1.999 + }, + { + "text": "and you might want to search that list.", + "start": 940.48, + "duration": 3.034 + }, + { + "text": "And that allows us to then\nconsider how we might implement", + "start": 943.514, + "duration": 2.416 + }, + { + "text": "each of these kinds of things.", + "start": 945.93, + "duration": 1.32 + }, + { + "text": "But it turns out while all simply--\nwhile fairly simple intuitively,", + "start": 947.25, + "duration": 4.36 + }, + { + "text": "we're going to have to be a little\ncareful now by way of our pointers.", + "start": 951.61, + "duration": 3.25 + }, + { + "text": "So, let's more formally declare a\nlinked list to look something like this.", + "start": 954.86, + "duration": 3.3 + }, + { + "text": "It's a collection of nodes\nthat are linked together", + "start": 958.16, + "duration": 2.95 + }, + { + "text": "with pointers as represented\nby these arrows here,", + "start": 961.11, + "duration": 2.9 + }, + { + "text": "but we're going to need some\nspecial pointer, at least", + "start": 964.01, + "duration": 2.8 + }, + { + "text": "at the beginning of the list.", + "start": 966.81, + "duration": 1.259 + }, + { + "text": "Let's just call it first.", + "start": 968.069, + "duration": 1.041 + }, + { + "text": "It doesn't necessarily\nstore a actual integer.", + "start": 969.11, + "duration": 3.15 + }, + { + "text": "It itself first is just a\npointer to the start of the list.", + "start": 972.26, + "duration": 4.28 + }, + { + "text": "And by way of that pointer can we access\nthe first actual node in the list.", + "start": 976.54, + "duration": 3.52 + }, + { + "text": "From there can we get at the second,\nfrom there can we get at the third,", + "start": 980.06, + "duration": 3.0 + }, + { + "text": "and the fourth, and the fifth,\nand any number of others.", + "start": 983.06, + "duration": 2.0 + }, + { + "text": "And this syntax over here\nmight just represent null.", + "start": 985.06, + "duration": 2.46 + }, + { + "text": "Because you don't want\nto have that pointer just", + "start": 987.52, + "duration": 1.38 + }, + { + "text": "pointing off into no man's land, that\nwill have to be a null pointer so", + "start": 988.9, + "duration": 3.12 + }, + { + "text": "that if we check for that\nwith a condition we know,", + "start": 992.02, + "duration": 2.125 + }, + { + "text": "OK, we're at the end of the list.", + "start": 994.145, + "duration": 1.627 + }, + { + "text": "So, let's pause for just a moment\nand consider these three algorithms--", + "start": 995.772, + "duration": 2.958 + }, + { + "text": "insert, delete, and search, and\nconsider what's going to be involved.", + "start": 998.73, + "duration": 5.115 + }, + { + "text": "Well, how would you go about\nsearching for an element of this list?", + "start": 1003.845, + "duration": 3.565 + }, + { + "text": "Suppose I wanted to find the number 22?", + "start": 1007.41, + "duration": 2.86 + }, + { + "text": "What do you do?", + "start": 1010.27, + "duration": 0.88 + }, + { + "text": "Well, me, I, the human can just\nlook at this and be like all right,", + "start": 1011.15, + "duration": 2.791 + }, + { + "text": "22 is right there.", + "start": 1013.941, + "duration": 1.489 + }, + { + "text": "But a computer can't do that.", + "start": 1015.43, + "duration": 1.26 + }, + { + "text": "A computer every time\nwe've had this discussion", + "start": 1016.69, + "duration": 1.64 + }, + { + "text": "can only look at one thing at a time.", + "start": 1018.33, + "duration": 1.76 + }, + { + "text": "But moreover the computer this\ntime is even more constrained", + "start": 1020.09, + "duration": 2.9 + }, + { + "text": "because it can't just use\nour old friend binary search", + "start": 1022.99, + "duration": 4.04 + }, + { + "text": "or divide and conquer, because how do\nyou get to the middle of a linked list?", + "start": 1027.03, + "duration": 4.285 + }, + { + "text": "Well, you have to find your way there.", + "start": 1031.315, + "duration": 1.764 + }, + { + "text": "The only thing you have in a\nlinked list from the outset", + "start": 1033.079, + "duration": 3.231 + }, + { + "text": "is one pointer called first or whatever\nit is, but one pointer that leads you", + "start": 1036.31, + "duration": 4.44 + }, + { + "text": "to the beginning of the list,\nthe first node in the list.", + "start": 1040.75, + "duration": 3.19 + }, + { + "text": "So, if you want to get to\nthe second node in the list,", + "start": 1043.94, + "duration": 2.25 + }, + { + "text": "you can't just go to bracket one,\nor bracket two, or bracket three", + "start": 1046.19, + "duration": 2.81 + }, + { + "text": "to get any number of other\nelements in the list.", + "start": 1049.0, + "duration": 2.0 + }, + { + "text": "You have to follow these\nbread crumbs, if you will.", + "start": 1051.0, + "duration": 2.2 + }, + { + "text": "You have to follow these arrows or these\naddresses to go from one node's address", + "start": 1053.2, + "duration": 3.67 + }, + { + "text": "to the other to the other.", + "start": 1056.87, + "duration": 1.62 + }, + { + "text": "And so, we've paid a price already.", + "start": 1058.49, + "duration": 3.14 + }, + { + "text": "And we'll see that there\nis still an advantage here,", + "start": 1061.63, + "duration": 2.3 + }, + { + "text": "but what's the running time?", + "start": 1063.93, + "duration": 1.42 + }, + { + "text": "What's an upper bound on the running\ntime of search for a linked list,", + "start": 1065.35, + "duration": 5.71 + }, + { + "text": "even if it is sorted?", + "start": 1071.06, + "duration": 1.195 + }, + { + "text": " ", + "start": 1072.255, + "duration": 2.754 + }, + { + "text": "Any thoughts?", + "start": 1075.009, + "duration": 0.541 + }, + { + "text": " ", + "start": 1075.55, + "duration": 3.07 + }, + { + "text": "Is it constant time like big O of 1?", + "start": 1078.62, + "duration": 2.38 + }, + { + "text": "Is it log of n?", + "start": 1081.0, + "duration": 1.4 + }, + { + "text": "Is it n, n squared?", + "start": 1082.4, + "duration": 3.79 + }, + { + "text": "What's the running time going to be?", + "start": 1086.19, + "duration": 1.79 + }, + { + "text": "Well, they're sorted, and that was this\nmagical ingredient, this assumption", + "start": 1087.98, + "duration": 3.27 + }, + { + "text": "we've been allowed to make in\nthe past which was helpful,", + "start": 1091.25, + "duration": 2.57 + }, + { + "text": "but that assumed that\nwe had random access.", + "start": 1093.82, + "duration": 2.4 + }, + { + "text": "In C, we had square bracket notation,\nso that using some simple arithmetic", + "start": 1096.22, + "duration": 3.28 + }, + { + "text": "we could jump roughly to the\nmiddle, and then the next middle,", + "start": 1099.5, + "duration": 2.14 + }, + { + "text": "and the next middle looking for Mike\nSmith or whatever element it is we're", + "start": 1101.64, + "duration": 3.083 + }, + { + "text": "looking for.", + "start": 1104.723, + "duration": 0.697 + }, + { + "text": "Unfortunately here, one\nprice we have already", + "start": 1105.42, + "duration": 3.15 + }, + { + "text": "paid already by taking this step\ntoward linked lists is linear time.", + "start": 1108.57, + "duration": 5.77 + }, + { + "text": "Big O of n would seem to be the running\ntime of searching a linked list,", + "start": 1114.34, + "duration": 3.71 + }, + { + "text": "because the only way you can\nstart is at the beginning,", + "start": 1118.05, + "duration": 2.58 + }, + { + "text": "and the only way you can get through\nthe list is by following these arrows.", + "start": 1120.63, + "duration": 3.9 + }, + { + "text": "And if there's n nodes\nin the list, you're", + "start": 1124.53, + "duration": 2.7 + }, + { + "text": "going to need as many as n steps to\nfind, something like 22, or 26, or 34,", + "start": 1127.23, + "duration": 4.26 + }, + { + "text": "or any elements all together.", + "start": 1131.49, + "duration": 2.277 + }, + { + "text": "Well, that's not all that great.", + "start": 1133.767, + "duration": 1.333 + }, + { + "text": "What about insert?", + "start": 1135.1, + "duration": 2.62 + }, + { + "text": "What's an upper bound on\nthe running time of insert?", + "start": 1137.72, + "duration": 4.51 + }, + { + "text": "Well, here too it depends.", + "start": 1142.23, + "duration": 1.74 + }, + { + "text": "Suppose that we don't care\nabout keeping the list sorted.", + "start": 1143.97, + "duration": 4.06 + }, + { + "text": "That's kind of a nice advantage,\nso I can be a little lazy here.", + "start": 1148.03, + "duration": 2.98 + }, + { + "text": "So, what's the running\ntime going to be if I", + "start": 1151.01, + "duration": 2.22 + }, + { + "text": "want to insert a new number like\nthe number 50 into this list,", + "start": 1153.23, + "duration": 3.54 + }, + { + "text": "but I don't care about\nkeeping it sorted?", + "start": 1156.77, + "duration": 2.39 + }, + { + "text": "Well, instinctively, where\nwould you put this element?", + "start": 1159.16, + "duration": 3.44 + }, + { + "text": "Where would you put it?", + "start": 1162.6, + "duration": 2.01 + }, + { + "text": "You might be inclined-- you kind\nof want to put it over here,", + "start": 1164.61, + "duration": 2.78 + }, + { + "text": "because it's the biggest element.", + "start": 1167.39, + "duration": 1.54 + }, + { + "text": "But again, if you don't care\nabout keeping it sorted,", + "start": 1168.93, + "duration": 1.52 + }, + { + "text": "where is the fastest, the quickest\nand dirtiest place to put it?", + "start": 1170.45, + "duration": 2.666 + }, + { + "text": "I would propose let's just put\nit at the front of the list.", + "start": 1173.116, + "duration": 2.544 + }, + { + "text": "Let's take this first pointer,\npoint it at the new number", + "start": 1175.66, + "duration": 4.11 + }, + { + "text": "50 that we've have somehow\nadded to the picture", + "start": 1179.77, + "duration": 2.52 + }, + { + "text": "as by calling malloc, asking\nmalloc for a new node.", + "start": 1182.29, + "duration": 2.63 + }, + { + "text": "And then have 50, in turn, point to the\nnumber 9, and then 9 can point to 17,", + "start": 1184.92, + "duration": 4.99 + }, + { + "text": "and 22, and so forth.", + "start": 1189.91, + "duration": 1.17 + }, + { + "text": "What if we want to insert\nanother number, 42,", + "start": 1191.08, + "duration": 1.876 + }, + { + "text": "and we don't care about where it goes?", + "start": 1192.956, + "duration": 1.582 + }, + { + "text": "Well, why don't we just put it\nat the beginning of the list?", + "start": 1194.538, + "duration": 2.562 + }, + { + "text": "Then we have the first\npointers pointing at 42,", + "start": 1197.1, + "duration": 2.76 + }, + { + "text": "which in turn should point at 50, which\nin turn can point at 9, then 17, then", + "start": 1199.86, + "duration": 3.77 + }, + { + "text": "22, and so forth.", + "start": 1203.63, + "duration": 1.267 + }, + { + "text": "So, if we're just lazy\nabout this, we can actually", + "start": 1204.897, + "duration": 2.083 + }, + { + "text": "achieve a great running time\nfor insert constant time.", + "start": 1206.98, + "duration": 3.54 + }, + { + "text": "Unfortunately, if we want\nto keep things sorted then", + "start": 1210.52, + "duration": 3.76 + }, + { + "text": "we're going to have to incur a\nlinear time cost again, right?", + "start": 1214.28, + "duration": 3.55 + }, + { + "text": "Because if we have to\ninsert 42 or 50, worst case", + "start": 1217.83, + "duration": 2.616 + }, + { + "text": "they might belong all the way at\nthe end of the list and that's", + "start": 1220.446, + "duration": 2.624 + }, + { + "text": "Big O of n steps.", + "start": 1223.07, + "duration": 2.02 + }, + { + "text": "And delete, too, unfortunately,\nwhether it's sorted or unsorted", + "start": 1225.09, + "duration": 3.75 + }, + { + "text": "is also like search\ngoing to be Big O of n", + "start": 1228.84, + "duration": 2.175 + }, + { + "text": "because you don't necessarily know\nwhen you're searching for a number", + "start": 1231.015, + "duration": 2.875 + }, + { + "text": "to delete if it's going to be at the\nbeginning, the middle, and the end.", + "start": 1233.89, + "duration": 2.999 + }, + { + "text": "So, in the worst case, it\nmight indeed be at the end.", + "start": 1236.889, + "duration": 2.551 + }, + { + "text": "You know what?", + "start": 1239.44, + "duration": 0.94 + }, + { + "text": "Why don't we instead of\nwalking through this verbally,", + "start": 1240.38, + "duration": 2.59 + }, + { + "text": "let's see if we can't\nget some volunteers?", + "start": 1242.97, + "duration": 1.782 + }, + { + "text": "Can we get seven volunteers to play--\nwow, to play the role of numbers here.", + "start": 1244.752, + "duration": 4.338 + }, + { + "text": "1, 2, 3, 4, 5, 6, and\nyes, 7, come on up.", + "start": 1249.09, + "duration": 4.78 + }, + { + "text": "All right, so I have here some\nprintouts for all seven of you", + "start": 1253.87, + "duration": 2.93 + }, + { + "text": "that represent exactly the nodes\nthat we have here on the screen.", + "start": 1256.8, + "duration": 3.35 + }, + { + "text": "Let's meet one of our first contestants.", + "start": 1260.15, + "duration": 1.67 + }, + { + "text": "What is your name?", + "start": 1261.82, + "duration": 0.5 + }, + { + "text": "AUDIENCE: Scully.", + "start": 1262.32, + "duration": 0.59 + }, + { + "text": "SPEAKER 1: Scully, nice to see you.", + "start": 1262.91, + "duration": 1.51 + }, + { + "text": "So, you shall be literally first\nand represent our first pointer.", + "start": 1264.42, + "duration": 2.89 + }, + { + "text": "So, if you want to come and\nstand roughly over here.", + "start": 1267.31, + "duration": 2.38 + }, + { + "text": "And then what is your name?", + "start": 1269.69, + "duration": 0.64 + }, + { + "text": "AUDIENCE: Maria.", + "start": 1270.33, + "duration": 0.39 + }, + { + "text": "SPEAKER 1: Maria, nice to see you.", + "start": 1270.72, + "duration": 1.416 + }, + { + "text": "And you can be the number 9 right\nnext to our first contestant.", + "start": 1272.136, + "duration": 4.694 + }, + { + "text": "And your name?", + "start": 1276.83, + "duration": 0.59 + }, + { + "text": "AUDIENCE: Sarah.", + "start": 1277.42, + "duration": 0.36 + }, + { + "text": "SPEAKER 1: Sarah, nice to see you.", + "start": 1277.78, + "duration": 1.416 + }, + { + "text": "You shall be the number 17.", + "start": 1279.196, + "duration": 1.341 + }, + { + "text": "And your name?", + "start": 1280.537, + "duration": 0.583 + }, + { + "text": "[? AUDIENCE: Satoshi. ?]", + "start": 1281.12, + "duration": 0.42 + }, + { + "text": "[? SPEAKER 1: Satoshi, ?]\nnice to see you.", + "start": 1281.54, + "duration": 1.75 + }, + { + "text": "You shall be 20.", + "start": 1283.29, + "duration": 1.367 + }, + { + "text": "And your name?", + "start": 1284.657, + "duration": 0.583 + }, + { + "text": "[? AUDIENCE: Mosof. ?]", + "start": 1285.24, + "duration": 0.63 + }, + { + "text": "[? SPEAKER 1: Mosof, ?] nice to see you.", + "start": 1285.87, + "duration": 1.666 + }, + { + "text": "And you shall be 22.", + "start": 1287.536, + "duration": 1.361 + }, + { + "text": "AUDIENCE: Jed.", + "start": 1288.897, + "duration": 0.583 + }, + { + "text": "SPEAKER 1: Jed, nice to\nsee you-- 29, formerly 26.", + "start": 1289.48, + "duration": 4.85 + }, + { + "text": "And your name?", + "start": 1294.33, + "duration": 0.695 + }, + { + "text": "AUDIENCE: Erin.", + "start": 1295.025, + "duration": 0.625 + }, + { + "text": "SPEAKER 1: Erin, nice to see you.", + "start": 1295.65, + "duration": 1.375 + }, + { + "text": "You shall be 34.", + "start": 1297.025, + "duration": 0.915 + }, + { + "text": "All right, so what we have here\nis seven elements, six of which", + "start": 1297.94, + "duration": 4.69 + }, + { + "text": "are very similar to themselves, one\nof which is fundamentally different.", + "start": 1302.63, + "duration": 3.63 + }, + { + "text": "So, Scully here represents first,\nand indeed her sheet of paper", + "start": 1306.26, + "duration": 3.11 + }, + { + "text": "is horizontal to suggest\nthat she is just a node.", + "start": 1309.37, + "duration": 2.71 + }, + { + "text": "She is just going to be the\npointer of to a node in a list.", + "start": 1312.08, + "duration": 3.69 + }, + { + "text": "Everyone else's nodes\nare vertical, as have", + "start": 1315.77, + "duration": 1.972 + }, + { + "text": "been the rectangles we've\nbeen drawing on the screen,", + "start": 1317.742, + "duration": 2.208 + }, + { + "text": "because each of these guys represents\na number as well as a next pointer.", + "start": 1319.95, + "duration": 4.4 + }, + { + "text": "Now of course, you're only seeing\nin front of you the number.", + "start": 1324.35, + "duration": 2.59 + }, + { + "text": "So we're going to go ahead\nand if you wouldn't mind,", + "start": 1326.94, + "duration": 1.56 + }, + { + "text": "use your left hand to represent the\narrow that we've long had on the screen", + "start": 1328.5, + "duration": 3.67 + }, + { + "text": "to point to the person next to you.", + "start": 1332.17, + "duration": 1.65 + }, + { + "text": "And Erin, you're a bit\nof an anomaly, but also", + "start": 1333.82, + "duration": 2.86 + }, + { + "text": "because you need to have a null\npointer at the end of the list,", + "start": 1336.68, + "duration": 3.079 + }, + { + "text": "so that you're not just\npointing aimlessly.", + "start": 1339.759, + "duration": 1.791 + }, + { + "text": "And pointing to the ground\nseems fine, so literally", + "start": 1341.55, + "duration": 2.27 + }, + { + "text": "pointing to the ground will\nrepresent-- will infer as null.", + "start": 1343.82, + "duration": 4.3 + }, + { + "text": "So, Scully, you are the only\nthing keeping this list together,", + "start": 1348.12, + "duration": 2.75 + }, + { + "text": "so to speak.", + "start": 1350.87, + "duration": 0.64 + }, + { + "text": "So, you two need to point with\nyour one pointer to Maria there.", + "start": 1351.51, + "duration": 4.48 + }, + { + "text": "So, here we have a linked list.", + "start": 1355.99, + "duration": 1.88 + }, + { + "text": "And just to make this clear, could\neveryone separate from each other", + "start": 1357.87, + "duration": 3.26 + }, + { + "text": "by a step or two in any direction?", + "start": 1361.13, + "duration": 2.58 + }, + { + "text": "Notice that the list is still--\nit's almost identical to before.", + "start": 1363.71, + "duration": 3.319 + }, + { + "text": "Can some of you take a\nstep forward, a step back,", + "start": 1367.029, + "duration": 2.041 + }, + { + "text": "but still point at the other person?", + "start": 1369.07, + "duration": 1.94 + }, + { + "text": "So, now we're capturing a\nlittle more accurately the fact", + "start": 1371.01, + "duration": 2.53 + }, + { + "text": "that these nodes and these\npointers can be anywhere in memory,", + "start": 1373.54, + "duration": 3.11 + }, + { + "text": "so long as they're linking themselves\ntogether by way of these pointers.", + "start": 1376.65, + "duration": 4.43 + }, + { + "text": "All right, so suppose\nnow that I want to insert", + "start": 1381.08, + "duration": 2.24 + }, + { + "text": "an element like 55, which happens\nto belong at the end of this list.", + "start": 1383.32, + "duration": 5.27 + }, + { + "text": "Let me go ahead and malloc\nChristian if I could.", + "start": 1388.59, + "duration": 3.82 + }, + { + "text": "So we have asked malloc for\na chunk of memory equivalent", + "start": 1392.41, + "duration": 2.6 + }, + { + "text": "to the size of one\ninteger and one pointer.", + "start": 1395.01, + "duration": 2.81 + }, + { + "text": "That is going to be represented\nwith this rectangle here.", + "start": 1397.82, + "duration": 2.53 + }, + { + "text": "Nice to see you.", + "start": 1400.35, + "duration": 0.796 + }, + { + "text": "AUDIENCE: Nice to see you.", + "start": 1401.146, + "duration": 0.406 + }, + { + "text": "SPEAKER 1: You shall be 55.", + "start": 1401.552, + "duration": 1.448 + }, + { + "text": "And I'll play the role of the temporary\npointer as predecessor pointer", + "start": 1403.0, + "duration": 3.069 + }, + { + "text": "or pointer just using\nmy left or right hand", + "start": 1406.069, + "duration": 1.791 + }, + { + "text": "to try to figure out\nwhere Christian belongs.", + "start": 1407.86, + "duration": 3.06 + }, + { + "text": "So, just like you might-- just like\nwe might want to search the list,", + "start": 1410.92, + "duration": 5.45 + }, + { + "text": "inserting is fundamentally\nrather the same.", + "start": 1416.37, + "duration": 2.75 + }, + { + "text": "The only thing I have access to\nat the outset of this algorithm", + "start": 1419.12, + "duration": 2.82 + }, + { + "text": "is my first pointer, and\nit's only by way of Scully", + "start": 1421.94, + "duration": 2.74 + }, + { + "text": "that I can even access\nthe rest of the list.", + "start": 1424.68, + "duration": 1.95 + }, + { + "text": "I cannot jump to the\nmiddle, jump to the end.", + "start": 1426.63, + "duration": 2.3 + }, + { + "text": "I can only start at the beginning\nand literally follow the pointer.", + "start": 1428.93, + "duration": 3.377 + }, + { + "text": "So, let me go ahead and do that.", + "start": 1432.307, + "duration": 1.333 + }, + { + "text": "Let me go ahead and\npoint at whatever Scully", + "start": 1433.64, + "duration": 1.37 + }, + { + "text": "is pointing at, which happens to\nbe Maria, which is the number 9.", + "start": 1435.01, + "duration": 3.066 + }, + { + "text": "55, of course, is\nbigger than that, and I", + "start": 1438.076, + "duration": 2.134 + }, + { + "text": "do want to keep the list\nsorted for today's purposes.", + "start": 1440.21, + "duration": 2.34 + }, + { + "text": "So I'm going to very carefully\nfollow the next pointer, 17.", + "start": 1442.55, + "duration": 4.32 + }, + { + "text": "Follow the next pointer, 20.", + "start": 1446.87, + "duration": 1.5 + }, + { + "text": "Follow the next pointer, 22.", + "start": 1448.37, + "duration": 1.75 + }, + { + "text": "Follow the next pointer, 29.", + "start": 1450.12, + "duration": 1.84 + }, + { + "text": "Follow the next pointer, 34.", + "start": 1451.96, + "duration": 1.83 + }, + { + "text": "Follow the next pointer,\nah dammit, null.", + "start": 1453.79, + "duration": 2.844 + }, + { + "text": "And so this is why it is important\nwith some of these algorithms", + "start": 1456.634, + "duration": 2.666 + }, + { + "text": "to have a predecessor pointer, a\nsecond pointer or really my left hand", + "start": 1459.3, + "duration": 4.15 + }, + { + "text": "so that maybe my left hand\ncan still point at Erin.", + "start": 1463.45, + "duration": 2.71 + }, + { + "text": "My right hand can realize,\nah, null, so that I still", + "start": 1466.16, + "duration": 3.46 + }, + { + "text": "have access to the last node\nin the list so that Christian--", + "start": 1469.62, + "duration": 2.92 + }, + { + "text": "if you could come over here.", + "start": 1472.54, + "duration": 1.73 + }, + { + "text": "I'm going to go ahead and tell Erin\nquite simply to point at Christian.", + "start": 1474.27, + "duration": 6.48 + }, + { + "text": "Good, and let's just say for\nstudents' sake come on over here,", + "start": 1480.75, + "duration": 4.045 + }, + { + "text": "but technically we could have\nleft Christian there and just had", + "start": 1484.795, + "duration": 2.625 + }, + { + "text": "Erin pointing at him.", + "start": 1487.42, + "duration": 0.89 + }, + { + "text": "It's just going to get a\nlittle confusing before long,", + "start": 1488.31, + "duration": 2.25 + }, + { + "text": "so we'll just cheat and\nmove you right over here.", + "start": 1490.56, + "duration": 2.299 + }, + { + "text": "But now we have a linked list\nthat has one additional member.", + "start": 1492.859, + "duration": 2.541 + }, + { + "text": "Suppose now that we want to\nmake another insertion-- pardon.", + "start": 1495.4, + "duration": 4.03 + }, + { + "text": "Let me go ahead and propose\nthat we insert say the number 5.", + "start": 1499.43, + "duration": 4.86 + }, + { + "text": "Well, the number 5, of course,\nbelongs at the beginning of the list.", + "start": 1504.29, + "duration": 5.6 + }, + { + "text": "So you know what?", + "start": 1509.89, + "duration": 0.71 + }, + { + "text": "I need to malloc.", + "start": 1510.6, + "duration": 1.02 + }, + { + "text": "Can I malloc Jordan off\ncamera five, perhaps?", + "start": 1511.62, + "duration": 4.506 + }, + { + "text": "So malloc, a very slow return value.", + "start": 1516.126, + "duration": 2.684 + }, + { + "text": "OK, we're going to store your\nnode your n value five here.", + "start": 1518.81, + "duration": 4.12 + }, + { + "text": "His pointer is undefined right\nnow, because he's not actually", + "start": 1522.93, + "duration": 2.6 + }, + { + "text": "pointing at anything.", + "start": 1525.53, + "duration": 0.99 + }, + { + "text": "And so where does he ultimately belong?", + "start": 1526.52, + "duration": 1.911 + }, + { + "text": "Well, he belongs at\nthe start of the list.", + "start": 1528.431, + "duration": 1.749 + }, + { + "text": "So, let me deliberately make a mistake.", + "start": 1530.18, + "duration": 2.03 + }, + { + "text": "Let me go ahead and update\nScully to point at Jordan,", + "start": 1532.21, + "duration": 3.24 + }, + { + "text": "thereby putting Jordan effectively\nat the front of the list.", + "start": 1535.45, + "duration": 2.75 + }, + { + "text": "Unfortunately, whom should\nJordan now point at technically?", + "start": 1538.2, + "duration": 4.62 + }, + { + "text": "It should be Maria, but this is code.", + "start": 1542.82, + "duration": 3.52 + }, + { + "text": "The only thing we can do\nis copy pointers in memory,", + "start": 1546.34, + "duration": 2.66 + }, + { + "text": "and if Scully's left hand is\nno longer pointing at Maria,", + "start": 1549.0, + "duration": 2.79 + }, + { + "text": "I have literally orphaned\nthe entirety of this list.", + "start": 1551.79, + "duration": 3.01 + }, + { + "text": "I have leaked 1, 2, 3, 4,\n5, 6, 7 chunks of memory,", + "start": 1554.8, + "duration": 4.1 + }, + { + "text": "seven nodes, because I got my\norder of operations out of order.", + "start": 1558.9, + "duration": 3.78 + }, + { + "text": "Indeed, I should have done\nwhat-- let's undo, control Z.", + "start": 1562.68, + "duration": 3.69 + }, + { + "text": "And now let me go ahead and do what?", + "start": 1566.37, + "duration": 1.82 + }, + { + "text": "Jordan should point at the exact\nsame thing Scully is pointing at,", + "start": 1568.19, + "duration": 3.8 + }, + { + "text": "which has no downside.", + "start": 1571.99, + "duration": 1.53 + }, + { + "text": "Even though it feels redundant,\nwe've not lost any information.", + "start": 1573.52, + "duration": 2.68 + }, + { + "text": "And now that Jordan\nis pointing at Maria,", + "start": 1576.2, + "duration": 2.83 + }, + { + "text": "Scully's pointer can\nbe pointed at Jordan.", + "start": 1579.03, + "duration": 2.935 + }, + { + "text": "And now, even though the\nlist looks a little weird,", + "start": 1581.965, + "duration": 2.125 + }, + { + "text": "this is a key feature\nof the linked list.", + "start": 1584.09, + "duration": 1.708 + }, + { + "text": "These nodes could have\nbeen malloc from anywhere.", + "start": 1585.798, + "duration": 2.432 + }, + { + "text": "So indeed, even though we initially\nkept everyone physically sorted", + "start": 1588.23, + "duration": 3.3 + }, + { + "text": "left to right-- and you've all cleaned\nthe list up even since-- that's OK.", + "start": 1591.53, + "duration": 5.04 + }, + { + "text": "The point is that all of these\nnodes are linked together.", + "start": 1596.57, + "duration": 3.024 + }, + { + "text": "So, thank you so much to our volunteers.", + "start": 1599.594, + "duration": 1.666 + }, + { + "text": "You can keep these pieces\nof paper and later on we'll", + "start": 1601.26, + "duration": 2.208 + }, + { + "text": "have some stress balls for you.", + "start": 1603.468, + "duration": 1.442 + }, + { + "text": "But that's the key idea\nhere behind a linked list.", + "start": 1604.91, + "duration": 6.23 + }, + { + "text": "Thank you.", + "start": 1611.14, + "duration": 1.66 + }, + { + "text": "So, of course, there are some\nmore complicated operations", + "start": 1612.8, + "duration": 3.31 + }, + { + "text": "that we might have to deal with.", + "start": 1616.11, + "duration": 1.334 + }, + { + "text": "For instance, if we want to insert\ninto the middle of the list,", + "start": 1617.444, + "duration": 2.624 + }, + { + "text": "that's going to be a little more\nof a burden on me, the program,", + "start": 1620.068, + "duration": 2.682 + }, + { + "text": "keeping track of where\nthings have to go.", + "start": 1622.75, + "duration": 2.77 + }, + { + "text": "But nicely enough, there's\nonly these three cases--", + "start": 1625.52, + "duration": 2.38 + }, + { + "text": "the beginning of the list, the end of\nthe list, and the middle of the list,", + "start": 1627.9, + "duration": 2.72 + }, + { + "text": "because middle of the list doesn't\nhave to mean literally the middle,", + "start": 1630.62, + "duration": 2.7 + }, + { + "text": "just anywhere that's not\nthe beginning or the end.", + "start": 1633.32, + "duration": 2.127 + }, + { + "text": "Of course, we should\nbe careful to make sure", + "start": 1635.447, + "duration": 1.833 + }, + { + "text": "that we handle the empty\nlist scenario, which", + "start": 1637.28, + "duration": 2.73 + }, + { + "text": "is equivalent to putting something\nat both the beginning of the list", + "start": 1640.01, + "duration": 3.19 + }, + { + "text": "and the end of the list.", + "start": 1643.2, + "duration": 1.63 + }, + { + "text": "But that would be perhaps a special\ncase we could deal with separately.", + "start": 1644.83, + "duration": 3.92 + }, + { + "text": "Of course, there are other operations\nlike inserting-- or rather removing", + "start": 1648.75, + "duration": 3.71 + }, + { + "text": "from the tail of the list,\nremoving from the head of the list,", + "start": 1652.46, + "duration": 2.68 + }, + { + "text": "and removing in the middle.", + "start": 1655.14, + "duration": 1.51 + }, + { + "text": "And that would be the opposite\nof malloc, if you will.", + "start": 1656.65, + "duration": 2.73 + }, + { + "text": "And in those cases, we\nhave to take care to call", + "start": 1659.38, + "duration": 2.29 + }, + { + "text": "our friend free to free\nthose bytes of memory,", + "start": 1661.67, + "duration": 3.0 + }, + { + "text": "give them back to the operating\nsystem so that we don't leak memory.", + "start": 1664.67, + "duration": 2.86 + }, + { + "text": "But there, too, I'm probably going to\nhave to be careful as to what order", + "start": 1667.53, + "duration": 4.28 + }, + { + "text": "I change my pointers and free nodes.", + "start": 1671.81, + "duration": 2.15 + }, + { + "text": "Because what you don't want to\ndo, and what unfortunately you", + "start": 1673.96, + "duration": 2.79 + }, + { + "text": "might very well accidentally\ndo at some point,", + "start": 1676.75, + "duration": 2.45 + }, + { + "text": "is free a pointer and then try to access\nthat pointer or change the pointer,", + "start": 1679.2, + "duration": 4.57 + }, + { + "text": "even after you've told the operating\nsystem I'm done with this address.", + "start": 1683.77, + "duration": 3.094 + }, + { + "text": "That can give you what's\ncalled a segmentation", + "start": 1686.864, + "duration": 1.916 + }, + { + "text": "fault, which is just one\nof the ways in which you", + "start": 1688.78, + "duration": 2.05 + }, + { + "text": "can deduce that kind of mistake.", + "start": 1690.83, + "duration": 3.29 + }, + { + "text": "So, let's actually implement\none of these methods.", + "start": 1694.12, + "duration": 2.779 + }, + { + "text": "And we'll pluck off one that\nallows us to actually take", + "start": 1696.899, + "duration": 2.291 + }, + { + "text": "a look at the syntax with which\nwe can manipulate pointers.", + "start": 1699.19, + "duration": 2.559 + }, + { + "text": "And let's go ahead and\nimplement a function", + "start": 1701.749, + "duration": 1.791 + }, + { + "text": "called search, for\ninstance, where search", + "start": 1703.54, + "duration": 2.02 + }, + { + "text": "I [? proposed ?] just returns a\nbool, true or false, this number n", + "start": 1705.56, + "duration": 4.15 + }, + { + "text": "is in the given the list.", + "start": 1709.71, + "duration": 1.61 + }, + { + "text": "And now, why have I said node star list?", + "start": 1711.32, + "duration": 2.26 + }, + { + "text": "Well, at the end of the day, a linked\nlist is just a whole bunch of nodes.", + "start": 1713.58, + "duration": 4.76 + }, + { + "text": "But the first of those nodes that\nwe keep calling first is of what", + "start": 1718.34, + "duration": 3.95 + }, + { + "text": "data type?", + "start": 1722.29, + "duration": 1.24 + }, + { + "text": "If you have a pointer,\na variable, that's", + "start": 1723.53, + "duration": 2.6 + }, + { + "text": "pointing to a linked list, that means\nit's storing the address of a node,", + "start": 1726.13, + "duration": 6.17 + }, + { + "text": "otherwise known as a node star.", + "start": 1732.3, + "duration": 1.48 + }, + { + "text": "So, this would be the syntax with which\nyou can pass to a function something", + "start": 1733.78, + "duration": 4.16 + }, + { + "text": "like a linked list.", + "start": 1737.94, + "duration": 0.87 + }, + { + "text": "You simply have to pass it a pointer\nto the first element in that list.", + "start": 1738.81, + "duration": 3.99 + }, + { + "text": "And if I want to go ahead\nnow and implement this,", + "start": 1742.8, + "duration": 3.17 + }, + { + "text": "let me go ahead and\npropose the following.", + "start": 1745.97, + "duration": 2.7 + }, + { + "text": "Let me go ahead here and give myself a\ntemporary value, so node star pointer", + "start": 1748.67, + "duration": 5.19 + }, + { + "text": "we'll call it, PTR.", + "start": 1753.86, + "duration": 1.33 + }, + { + "text": "And that's going to equal\nthe start of the list.", + "start": 1755.19, + "duration": 2.36 + }, + { + "text": "So, I'm just creating\nanother box of memory", + "start": 1757.55, + "duration": 1.975 + }, + { + "text": "and I'm storing inside\nof it the same address", + "start": 1759.525, + "duration": 1.875 + }, + { + "text": "that I was passed in, just so that\nI have a temporary variable that I", + "start": 1761.4, + "duration": 2.874 + }, + { + "text": "can use to update.", + "start": 1764.274, + "duration": 1.366 + }, + { + "text": "After this, let me go ahead and\nsay while that pointer is not", + "start": 1765.64, + "duration": 3.46 + }, + { + "text": "equal to null-- because recall that\nnull is this special sentinel value that", + "start": 1769.1, + "duration": 4.04 + }, + { + "text": "means end of the list.", + "start": 1773.14, + "duration": 1.53 + }, + { + "text": "So inside of this loop,\nwhat do I want to do?", + "start": 1774.67, + "duration": 3.41 + }, + { + "text": "I'm going to go ahead\nand say if pointer--", + "start": 1778.08, + "duration": 4.25 + }, + { + "text": "and now I have to get at\nthe number inside of it.", + "start": 1782.33, + "duration": 4.03 + }, + { + "text": "So, if I recall from the last time,\nwe only spent a little bit of time", + "start": 1786.36, + "duration": 3.42 + }, + { + "text": "on the student example, but\nwe said something like student", + "start": 1789.78, + "duration": 3.07 + }, + { + "text": "dot name or student dot dorm.", + "start": 1792.85, + "duration": 2.055 + }, + { + "text": "And in this case I'm inclined\nto say pointer dot n, where n is", + "start": 1794.905, + "duration": 4.125 + }, + { + "text": "the number, the integer that's inside.", + "start": 1799.03, + "duration": 2.44 + }, + { + "text": "But pointer this time\nis not a struct, per se.", + "start": 1801.47, + "duration": 2.53 + }, + { + "text": "It's the address of a node.", + "start": 1804.0, + "duration": 1.83 + }, + { + "text": "It's the address of a struct.", + "start": 1805.83, + "duration": 1.46 + }, + { + "text": "And so, perhaps the most\nintuitive piece of syntax in C,", + "start": 1807.29, + "duration": 5.54 + }, + { + "text": "at least retrospectively\nnow, is that if you", + "start": 1812.83, + "duration": 2.35 + }, + { + "text": "want to access a piece of\ndata that's inside of a node", + "start": 1815.18, + "duration": 4.22 + }, + { + "text": "and you have a pointer to that node much\nlike our arrows in the pictures imply,", + "start": 1819.4, + "duration": 4.35 + }, + { + "text": "you literally draw an\narrow using a hyphen", + "start": 1823.75, + "duration": 2.43 + }, + { + "text": "and then using a right angle bracket.", + "start": 1826.18, + "duration": 4.57 + }, + { + "text": "So, now if we do see-- whoops,\nlet me finish my thought.", + "start": 1830.75, + "duration": 3.7 + }, + { + "text": "If pointer n equals equals the n we're\nlooking for, let me go ahead in here", + "start": 1834.45, + "duration": 4.8 + }, + { + "text": "and say return true.", + "start": 1839.25, + "duration": 1.97 + }, + { + "text": "Or else, let me go ahead\nand not return false,", + "start": 1841.22, + "duration": 2.597 + }, + { + "text": "because I don't want to just check one\nelement and then blindly say false.", + "start": 1843.817, + "duration": 3.083 + }, + { + "text": "I instead want to say pointer\nshould get pointer arrow next.", + "start": 1846.9, + "duration": 5.03 + }, + { + "text": "And then only after that\nloop is all complete", + "start": 1851.93, + "duration": 3.28 + }, + { + "text": "should I say something\nlike nope, return false.", + "start": 1855.21, + "duration": 3.83 + }, + { + "text": "So, what's actually going on here?", + "start": 1859.04, + "duration": 2.05 + }, + { + "text": "The function declaration,\nagain, took in two arguments--", + "start": 1861.09, + "duration": 2.52 + }, + { + "text": "one, an int n that we're looking\nfor, two a pointer to a node,", + "start": 1863.61, + "duration": 4.68 + }, + { + "text": "otherwise known as a\nnode in a linked list.", + "start": 1868.29, + "duration": 1.867 + }, + { + "text": "And per the pictures\nwe've been drawing, you", + "start": 1870.157, + "duration": 1.833 + }, + { + "text": "can access any other element in that\nlinked list by way of the first element", + "start": 1871.99, + "duration": 4.61 + }, + { + "text": "in that list, as suggested here.", + "start": 1876.6, + "duration": 1.99 + }, + { + "text": "So, now I'm just giving myself a\ntemporary variable called pointer,", + "start": 1878.59, + "duration": 2.914 + }, + { + "text": "but I can call it anything I want.", + "start": 1881.504, + "duration": 1.416 + }, + { + "text": "And I'm declaring it as node star, so\nthat it can store the address of a node", + "start": 1882.92, + "duration": 3.57 + }, + { + "text": "as well, and then I'm\njust initializing it to be", + "start": 1886.49, + "duration": 2.2 + }, + { + "text": "the exact value that was passed in.", + "start": 1888.69, + "duration": 1.491 + }, + { + "text": "So, I don't want to accidentally\nbreak the list that I was passed.", + "start": 1890.181, + "duration": 2.749 + }, + { + "text": "I don't want to change\nthe value of my parameter", + "start": 1892.93, + "duration": 2.0 + }, + { + "text": "unnecessarily and complicate things.", + "start": 1894.93, + "duration": 1.73 + }, + { + "text": "I just really want a\ntemporary variable, much", + "start": 1896.66, + "duration": 2.14 + }, + { + "text": "like I in the world of loops that\nallows me to constantly iterate", + "start": 1898.8, + "duration": 4.33 + }, + { + "text": "through something and update it as\nI go while the whole along the way", + "start": 1903.13, + "duration": 5.476 + }, + { + "text": "I want to be checking this.", + "start": 1908.606, + "duration": 1.124 + }, + { + "text": "While pointer is not null.", + "start": 1909.73, + "duration": 1.97 + }, + { + "text": "If pointer is null, that means\nI'm at the end of the list,", + "start": 1911.7, + "duration": 3.02 + }, + { + "text": "or maybe more curiously, I was passed\nnull, in which case there is no list.", + "start": 1914.72, + "duration": 4.601 + }, + { + "text": "And that's a valid scenario that could\nhappen, even though it's a bit strange.", + "start": 1919.321, + "duration": 3.249 + }, + { + "text": "But if pointer is null, I don't want\nto proceed further inside of this loop.", + "start": 1922.57, + "duration": 5.8 + }, + { + "text": "But so long as pointer is not\nnull, let me go ahead and do this.", + "start": 1928.37, + "duration": 3.89 + }, + { + "text": "Let me follow that pointer and\ngo inside that node and say", + "start": 1932.26, + "duration": 3.98 + }, + { + "text": "is your n value equal\nequal to the [? end ?]", + "start": 1936.24, + "duration": 2.84 + }, + { + "text": "value that I've been\nasked to search for?", + "start": 1939.08, + "duration": 2.05 + }, + { + "text": "And if so, return true.", + "start": 1941.13, + "duration": 1.482 + }, + { + "text": "I don't want to just return\nfalse now because otherwise I'd", + "start": 1942.612, + "duration": 2.458 + }, + { + "text": "only ever be checking the\nfirst element in a linked list.", + "start": 1945.07, + "duration": 2.97 + }, + { + "text": "So, I now want to do the equivalent\nin spirit of i plus plus.", + "start": 1948.04, + "duration": 6.45 + }, + { + "text": "But I'm not using i's.", + "start": 1954.49, + "duration": 0.917 + }, + { + "text": "I don't need to use\npointer arithmetic here,", + "start": 1955.407, + "duration": 1.832 + }, + { + "text": "and indeed it won't work because I\nhave this thing stitched together.", + "start": 1957.239, + "duration": 2.971 + }, + { + "text": "It's not an array of contiguous memory.", + "start": 1960.21, + "duration": 2.26 + }, + { + "text": "I want to say that my\ncurrent temporary value", + "start": 1962.47, + "duration": 2.37 + }, + { + "text": "pointer should get\nwhatever pointer arrow next", + "start": 1964.84, + "duration": 3.59 + }, + { + "text": "is, and then let this loop continue.", + "start": 1968.43, + "duration": 2.46 + }, + { + "text": "If it's not null, check again.", + "start": 1970.89, + "duration": 1.38 + }, + { + "text": "If it's [? end ?] value equals what\nI'm looking for and repeat, repeat,", + "start": 1972.27, + "duration": 3.2 + }, + { + "text": "repeat until pointer equals null.", + "start": 1975.47, + "duration": 2.234 + }, + { + "text": "So, let's make this more concrete.", + "start": 1977.704, + "duration": 1.416 + }, + { + "text": "Let me go ahead and just draw\na temporary picture here.", + "start": 1979.12, + "duration": 2.75 + }, + { + "text": "And let me suppose here\nthat what I have been passed", + "start": 1981.87, + "duration": 3.21 + }, + { + "text": "is something like the following.", + "start": 1985.08, + "duration": 2.84 + }, + { + "text": "Let's do a very simple linked list\nthat has maybe the number one,", + "start": 1987.92, + "duration": 4.53 + }, + { + "text": "and has the number two,\nand has the number three.", + "start": 1992.45, + "duration": 5.74 + }, + { + "text": "And, again, I've drawn\ngaps between these nodes,", + "start": 1998.19, + "duration": 2.0 + }, + { + "text": "because they could be\nanywhere in memory.", + "start": 2000.19, + "duration": 1.39 + }, + { + "text": "So, technically they don't need\nto be left to right like this,", + "start": 2001.58, + "duration": 2.2 + }, + { + "text": "but that'll keep us sane.", + "start": 2003.78, + "duration": 1.21 + }, + { + "text": "And if this is indeed\na correct linked list,", + "start": 2004.99, + "duration": 2.19 + }, + { + "text": "there are pointers in\neach of those fields", + "start": 2007.18, + "duration": 3.11 + }, + { + "text": "that point to the next node\nin the list, and that slash", + "start": 2010.29, + "duration": 2.415 + }, + { + "text": "I drew in the last one just means null.", + "start": 2012.705, + "duration": 1.625 + }, + { + "text": "You can draw it however you want.", + "start": 2014.33, + "duration": 1.43 + }, + { + "text": "But for a linked list to work, we need\nto know the beginning of this thing.", + "start": 2015.76, + "duration": 3.39 + }, + { + "text": "So, we'll call this\nfirst, and that of course", + "start": 2019.15, + "duration": 3.34 + }, + { + "text": "has to point to the first\nelement in my linked list.", + "start": 2022.49, + "duration": 2.314 + }, + { + "text": "So, here's the state of our world.", + "start": 2024.804, + "duration": 1.416 + }, + { + "text": "It's a linked list quite similar\nin spirit to the other one.", + "start": 2026.22, + "duration": 2.59 + }, + { + "text": "It's a little shorter, just\nfor the sake of discussion.", + "start": 2028.81, + "duration": 2.291 + }, + { + "text": "And now, let's consider\nmy function search,", + "start": 2031.101, + "duration": 2.959 + }, + { + "text": "which again takes two arguments.", + "start": 2034.06, + "duration": 2.04 + }, + { + "text": "So, that the first argument\nis of type int called n.", + "start": 2036.1, + "duration": 3.4 + }, + { + "text": "And suppose I'm searching\nfor the number three.", + "start": 2039.5, + "duration": 2.72 + }, + { + "text": "The second argument is a node star,\nso the address of a node called list.", + "start": 2042.22, + "duration": 3.82 + }, + { + "text": "So, what does that mean?", + "start": 2046.04, + "duration": 1.11 + }, + { + "text": "When this function\nsearch is called, let's", + "start": 2047.15, + "duration": 3.759 + }, + { + "text": "suppose that we currently\nhave the value n, which", + "start": 2050.909, + "duration": 4.191 + }, + { + "text": "is going to be 3, because\nthat's arbitrarily", + "start": 2055.1, + "duration": 1.91 + }, + { + "text": "the number of decided to search for.", + "start": 2057.01, + "duration": 1.629 + }, + { + "text": "And then this other value pointer\nis going to be initialized-- sorry,", + "start": 2058.639, + "duration": 7.031 + }, + { + "text": "not that.", + "start": 2065.67, + "duration": 1.219 + }, + { + "text": "List is going to be\nwhatever pointer is passed", + "start": 2066.889, + "duration": 5.6 + }, + { + "text": "in as the second argument\nto this function.", + "start": 2072.489, + "duration": 2.281 + }, + { + "text": "So, let's suppose that this linked list,\nthis sample linked list at the top,", + "start": 2074.77, + "duration": 4.07 + }, + { + "text": "is indeed what is passed\nin to this function.", + "start": 2078.84, + "duration": 3.682 + }, + { + "text": "So, I've passed in 3, because\nI want to search for 3.", + "start": 2082.522, + "duration": 2.208 + }, + { + "text": "So what goes here?", + "start": 2084.73, + "duration": 1.199 + }, + { + "text": "If I pass this sample linked\nlist into my search function,", + "start": 2085.929, + "duration": 6.29 + }, + { + "text": "what is the value of list?", + "start": 2092.219, + "duration": 3.23 + }, + { + "text": "Well, list if I'm past\nthis first pointer", + "start": 2095.449, + "duration": 4.411 + }, + { + "text": "is really going to be the pointer\nto the first element in the list.", + "start": 2099.86, + "duration": 3.72 + }, + { + "text": "That's all we're saying.", + "start": 2103.58, + "duration": 1.0 + }, + { + "text": "Node star list just\nmeans give me the address", + "start": 2104.58, + "duration": 1.949 + }, + { + "text": "of a linked list, which means give\nme the address of the first node", + "start": 2106.529, + "duration": 2.791 + }, + { + "text": "in the linked list, which\nmeans that initially when", + "start": 2109.32, + "duration": 2.125 + }, + { + "text": "I call search my picture--\nmy stack frame, if you will,", + "start": 2111.445, + "duration": 3.775 + }, + { + "text": "in terms of my local arguments--\nis going to look like this.", + "start": 2115.22, + "duration": 2.88 + }, + { + "text": "All right, so with that said,\nhow does this code work?", + "start": 2118.1, + "duration": 3.44 + }, + { + "text": "We recall in this code\nhave this while loop that", + "start": 2121.54, + "duration": 2.94 + }, + { + "text": "just sits in a loop checking\nwhether the current nodes", + "start": 2124.48, + "duration": 3.69 + }, + { + "text": "n equals equals the one we're looking\nfor, and if not, it updates it.", + "start": 2128.17, + "duration": 3.08 + }, + { + "text": "So, we need one more local\nvariable called pointer that's", + "start": 2131.25, + "duration": 3.19 + }, + { + "text": "initialized to the start of this list.", + "start": 2134.44, + "duration": 3.37 + }, + { + "text": "So, this will be a pointer and\nit's initialized to the same thing", + "start": 2137.81, + "duration": 5.15 + }, + { + "text": "that my second argument\nis initialized to.", + "start": 2142.96, + "duration": 3.48 + }, + { + "text": "So, this now is the state of our world\nonce one line of code has executed,", + "start": 2146.44, + "duration": 4.87 + }, + { + "text": "that very first one in there.", + "start": 2151.31, + "duration": 2.196 + }, + { + "text": "So, now let's implement the loop.", + "start": 2153.506, + "duration": 1.374 + }, + { + "text": "While pointer does not equal\nnull, so here's pointer.", + "start": 2154.88, + "duration": 3.18 + }, + { + "text": "Does it equal null?", + "start": 2158.06, + "duration": 1.252 + }, + { + "text": "No, because if it did,\nwe would just draw", + "start": 2159.312, + "duration": 1.708 + }, + { + "text": "a slash or some other piece of syntax.", + "start": 2161.02, + "duration": 1.9 + }, + { + "text": "But it's pointing at clearly\nsomething that exists.", + "start": 2162.92, + "duration": 2.25 + }, + { + "text": "So, this node here has\nsome valid address.", + "start": 2165.17, + "duration": 2.79 + }, + { + "text": "Pointer is pointing at\nit, so it's not null.", + "start": 2167.96, + "duration": 2.5 + }, + { + "text": "So, what do I do inside of my code?", + "start": 2170.46, + "duration": 1.93 + }, + { + "text": "I check if the n value\ninside of pointer, PTR,", + "start": 2172.39, + "duration": 7.84 + }, + { + "text": "equals equals the\nnumber I'm looking for,", + "start": 2180.23, + "duration": 2.11 + }, + { + "text": "and if so, return true, otherwise,\nif not I update pointer.", + "start": 2182.34, + "duration": 3.68 + }, + { + "text": "So let's check.", + "start": 2186.02, + "duration": 0.91 + }, + { + "text": "Let's follow the arrow, PTR,\nand look at the value n.", + "start": 2186.93, + "duration": 3.42 + }, + { + "text": "Recall that the top of these boxes is n.", + "start": 2190.35, + "duration": 2.02 + }, + { + "text": "The bottom of them is called\nnext-- n, next, n next.", + "start": 2192.37, + "duration": 3.91 + }, + { + "text": "So, I followed this pointer.", + "start": 2196.28, + "duration": 1.21 + }, + { + "text": "I'm looking at the box called n.", + "start": 2197.49, + "duration": 3.08 + }, + { + "text": "Does 3 equal 1?", + "start": 2200.57, + "duration": 1.15 + }, + { + "text": "No, obviously not.", + "start": 2201.72, + "duration": 1.5 + }, + { + "text": "So I update-- pointer gets pointer next.", + "start": 2203.22, + "duration": 4.0 + }, + { + "text": "So, to be clear, pointer\ngets pointer next,", + "start": 2207.22, + "duration": 4.6 + }, + { + "text": "that second to last line of actual code.", + "start": 2211.82, + "duration": 2.09 + }, + { + "text": "So, what does that mean I need to do?", + "start": 2213.91, + "duration": 2.14 + }, + { + "text": "That means I need to update pointer\nto be equal to pointer next.", + "start": 2216.05, + "duration": 4.57 + }, + { + "text": "What is pointer next?", + "start": 2220.62, + "duration": 0.93 + }, + { + "text": "Well, here's pointer and here's next.", + "start": 2221.55, + "duration": 2.5 + }, + { + "text": "We were looking a moment ago at n.", + "start": 2224.05, + "duration": 1.43 + }, + { + "text": "Now I'm looking at next.", + "start": 2225.48, + "duration": 1.5 + }, + { + "text": "So, pointer next means that I should\nupdate whatever is inside this box--", + "start": 2226.98, + "duration": 7.11 + }, + { + "text": "and a lot more on the screen-- to\nbe equal to pointer next, which", + "start": 2234.09, + "duration": 6.35 + }, + { + "text": "is this field.", + "start": 2240.44, + "duration": 0.62 + }, + { + "text": "This field is pointing at\nthat, so that line of code", + "start": 2241.06, + "duration": 3.08 + }, + { + "text": "has the effect of updating PTR to\nsimply point at the second node.", + "start": 2244.14, + "duration": 5.05 + }, + { + "text": "So, what happens next?", + "start": 2249.19, + "duration": 1.31 + }, + { + "text": "I seem to still be in that loop and I\nsay, well, pointer does not equal null,", + "start": 2250.5, + "duration": 3.645 + }, + { + "text": "and it doesn't.", + "start": 2254.145, + "duration": 0.625 + }, + { + "text": "It's pointing at that second node.", + "start": 2254.77, + "duration": 1.416 + }, + { + "text": "If pointer arrow n equals\nequals n, but no that's not", + "start": 2256.186, + "duration": 4.034 + }, + { + "text": "the case, because I'm looking for three.", + "start": 2260.22, + "duration": 1.74 + }, + { + "text": "I'm pointing at two,\nso that is again false.", + "start": 2261.96, + "duration": 2.45 + }, + { + "text": "So, again, I don't return true.", + "start": 2264.41, + "duration": 1.61 + }, + { + "text": "I instead update pointer\nto equal pointer next.", + "start": 2266.02, + "duration": 3.13 + }, + { + "text": "So, what has to happen here, at the\nrisk of deleting my handiwork again,", + "start": 2269.15, + "duration": 7.81 + }, + { + "text": "now pointer gets pointer next,\nwhich is this element, which", + "start": 2276.96, + "duration": 4.48 + }, + { + "text": "is equivalent to pointing\nat this node here.", + "start": 2281.44, + "duration": 2.84 + }, + { + "text": "And so, now I'm still inside that loop\nwhile pointer-- not equal to null.", + "start": 2284.28, + "duration": 5.35 + }, + { + "text": "It's not null.", + "start": 2289.63, + "duration": 0.82 + }, + { + "text": "If pointer arrow n equals equals\nn, well, let's follow that logic.", + "start": 2290.45, + "duration": 3.94 + }, + { + "text": "If pointer, follow the\narrow, n equals equals n,", + "start": 2294.39, + "duration": 4.36 + }, + { + "text": "three-- which is the one I'm\nlooking for-- returned true.", + "start": 2298.75, + "duration": 4.33 + }, + { + "text": "And so, how then does this\nfunction ultimately behave?", + "start": 2303.08, + "duration": 2.8 + }, + { + "text": "It would seem in this case to return\ntrue, because I have eventually", + "start": 2305.88, + "duration": 4.04 + }, + { + "text": "found that number three.", + "start": 2309.92, + "duration": 2.39 + }, + { + "text": "What would happen by contrast if I were\nlooking not for three, but for four", + "start": 2312.31, + "duration": 4.27 + }, + { + "text": "with this code?", + "start": 2316.58, + "duration": 1.42 + }, + { + "text": "In other words, what if I'm not\nlooking for three and I want to go one", + "start": 2318.0, + "duration": 3.65 + }, + { + "text": "step further?", + "start": 2321.65, + "duration": 0.58 + }, + { + "text": "Well, one step further\nis going to update PTR", + "start": 2322.23, + "duration": 3.11 + }, + { + "text": "to equal null, that\nslash in my last node.", + "start": 2325.34, + "duration": 5.21 + }, + { + "text": "And that means code wise,\nI'm going to break out", + "start": 2330.55, + "duration": 2.65 + }, + { + "text": "of that loop, because\npointer now does equal null.", + "start": 2333.2, + "duration": 2.89 + }, + { + "text": "And so, by default that very last\nline of code return false, not found.", + "start": 2336.09, + "duration": 4.98 + }, + { + "text": "So, complicated at first\nglance, and it certainly", + "start": 2341.07, + "duration": 2.147 + }, + { + "text": "looks more complicated than\nthings we've written before,", + "start": 2343.217, + "duration": 2.333 + }, + { + "text": "but again, if you go back to basics,\nwhat does each of these lines mean?", + "start": 2345.55, + "duration": 3.46 + }, + { + "text": "Consider that there's no magic here.", + "start": 2349.01, + "duration": 2.21 + }, + { + "text": "This first line means give me a\nvariable that's a pointer to a node.", + "start": 2351.22, + "duration": 3.967 + }, + { + "text": "It'd be in other words\nthe address of a node", + "start": 2355.187, + "duration": 1.833 + }, + { + "text": "and assign it whatever I was passed in.", + "start": 2357.02, + "duration": 1.816 + }, + { + "text": "While pointer [? naught ?] equals\nnull, we've seen null before.", + "start": 2358.836, + "duration": 2.624 + }, + { + "text": "It's this special zero\nvalue, and I'm just", + "start": 2361.46, + "duration": 2.15 + }, + { + "text": "making sure that the pointer I'm using,\nPTR, does not equal that special value.", + "start": 2363.61, + "duration": 3.63 + }, + { + "text": "And then inside of this loop I'm using\none piece of new syntax, this arrow", + "start": 2367.24, + "duration": 3.21 + }, + { + "text": "notation, which just like the picture\nsuggests means go there, and then", + "start": 2370.45, + "duration": 3.51 + }, + { + "text": "look at the field called n and check\nif it equals the n you're looking for,", + "start": 2373.96, + "duration": 3.81 + }, + { + "text": "and if so return true.", + "start": 2377.77, + "duration": 1.0 + }, + { + "text": "Otherwise, update yourself\nmuch like i plus plus", + "start": 2378.77, + "duration": 3.27 + }, + { + "text": "but specifically update pointer to\nbe whatever the value is when you", + "start": 2382.04, + "duration": 4.48 + }, + { + "text": "follow the arrow in that next field.", + "start": 2386.52, + "duration": 4.234 + }, + { + "text": "So, this of course is just search.", + "start": 2390.754, + "duration": 1.416 + }, + { + "text": "We've not actually changed the\nlist, but imagine, if you will,", + "start": 2392.17, + "duration": 3.69 + }, + { + "text": "that you could now\nimplement insert and delete,", + "start": 2395.86, + "duration": 3.07 + }, + { + "text": "not simply by following these\npointers but actually changing", + "start": 2398.93, + "duration": 3.74 + }, + { + "text": "the value of next in a node to the left,\na node to the right, or a new node all", + "start": 2402.67, + "duration": 6.9 + }, + { + "text": "together.", + "start": 2409.57, + "duration": 1.47 + }, + { + "text": "So, who cares?", + "start": 2411.04, + "duration": 1.66 + }, + { + "text": "Why did we add all of this complexity?", + "start": 2412.7, + "duration": 2.01 + }, + { + "text": "We had arrays, which were working\nreally well for a whole bunch of weeks,", + "start": 2414.71, + "duration": 3.43 + }, + { + "text": "and now we've claimed that\narrays are not so good.", + "start": 2418.14, + "duration": 2.92 + }, + { + "text": "We want to use linked lists instead.", + "start": 2421.06, + "duration": 1.8 + }, + { + "text": "But why might we want\nto use linked lists?", + "start": 2422.86, + "duration": 1.81 + }, + { + "text": "Well, linked lists gives us dynamism.", + "start": 2424.67, + "duration": 1.63 + }, + { + "text": "We can call malloc and give ourselves\nmore, and more, and more nodes", + "start": 2426.3, + "duration": 3.21 + }, + { + "text": "and grow our list of numbers, even\nif we don't know in advance how", + "start": 2429.51, + "duration": 2.91 + }, + { + "text": "many such numbers we need.", + "start": 2432.42, + "duration": 1.44 + }, + { + "text": "And we can shrink them,\nsimilarly, so we don't", + "start": 2433.86, + "duration": 2.19 + }, + { + "text": "have to allocate a massive\narray unnecessarily.", + "start": 2436.05, + "duration": 2.81 + }, + { + "text": "We can shrink our data structure based\non how many numbers we actually need.", + "start": 2438.86, + "duration": 3.31 + }, + { + "text": "But we're paying a price.", + "start": 2442.17, + "duration": 1.37 + }, + { + "text": "Search is a little bit slower,\ndelete is a little bit slower.", + "start": 2443.54, + "duration": 3.15 + }, + { + "text": "Insert would be slower if we\ninsist on keeping things sorted,", + "start": 2446.69, + "duration": 3.42 + }, + { + "text": "so we've paid this price.", + "start": 2450.11, + "duration": 1.182 + }, + { + "text": "And indeed, this is thematic.", + "start": 2451.292, + "duration": 1.208 + }, + { + "text": "In CS50, in computer\nscience more generally,", + "start": 2452.5, + "duration": 2.45 + }, + { + "text": "there's often going to be\nthese trade-offs of time,", + "start": 2454.95, + "duration": 2.68 + }, + { + "text": "or space, or just complexity,\nor your human time.", + "start": 2457.63, + "duration": 3.39 + }, + { + "text": "Any number of resources\ncan be in scarce supply.", + "start": 2461.02, + "duration": 3.26 + }, + { + "text": "And, indeed, we've seen\nby way of linked lists", + "start": 2464.28, + "duration": 3.14 + }, + { + "text": "that we're solving one problem\nwhile introducing another.", + "start": 2467.42, + "duration": 2.87 + }, + { + "text": "It's like that silly\nsituation you might see", + "start": 2470.29, + "duration": 2.71 + }, + { + "text": "memes of where you cover your hands--\nput your hand around a hose that", + "start": 2473.0, + "duration": 3.44 + }, + { + "text": "has a leak and all of a sudden\nanother leak springs up over there.", + "start": 2476.44, + "duration": 2.94 + }, + { + "text": "We're just moving the problem\nelsewhere, but maybe that leak", + "start": 2479.38, + "duration": 2.72 + }, + { + "text": "is less problematic to\nus than this one here.", + "start": 2482.1, + "duration": 2.95 + }, + { + "text": "So, again, it's this\ntheme of trade-offs.", + "start": 2485.05, + "duration": 1.74 + }, + { + "text": "Now, this here is Mather Dining Hall.", + "start": 2486.79, + "duration": 1.664 + }, + { + "text": "And this, of course, is\na whole bunch of trays", + "start": 2488.454, + "duration": 1.916 + }, + { + "text": "where you might go and get\nsome food, lunch, breakfast,", + "start": 2490.37, + "duration": 2.71 + }, + { + "text": "or dinner, or the like, and you pick\nup this tray and you put food on it.", + "start": 2493.08, + "duration": 3.041 + }, + { + "text": "But what's interesting about trays,\nas Mather and a lot of cafeterias do,", + "start": 2496.121, + "duration": 3.109 + }, + { + "text": "is trays are stacked\none on top of the other.", + "start": 2499.23, + "duration": 3.46 + }, + { + "text": "And it turns out now that\nwe have this second building", + "start": 2502.69, + "duration": 3.45 + }, + { + "text": "block with which to create data\nstructures-- we're not just", + "start": 2506.14, + "duration": 3.15 + }, + { + "text": "using arrays anymore.", + "start": 2509.29, + "duration": 1.29 + }, + { + "text": "We now have pointers and this general\nidea of linking nodes together", + "start": 2510.58, + "duration": 5.46 + }, + { + "text": "in our toolkit, we can now start\nto imagine more interesting data", + "start": 2516.04, + "duration": 4.3 + }, + { + "text": "structures that solve problems\nin slightly different ways.", + "start": 2520.34, + "duration": 3.72 + }, + { + "text": "For instance, suppose\nthat I wanted to implement", + "start": 2524.06, + "duration": 2.1 + }, + { + "text": "this paradigm of stacking things on\none on top of the other like this.", + "start": 2526.16, + "duration": 4.34 + }, + { + "text": "Indeed, this is a data\nstructure called a stack,", + "start": 2530.5, + "duration": 2.13 + }, + { + "text": "and it generally has two\noperations associated with it,", + "start": 2532.63, + "duration": 2.32 + }, + { + "text": "push to push something on the stack and\npop to take something off of the stack.", + "start": 2534.95, + "duration": 4.839 + }, + { + "text": "And this is perhaps a\nuseful data structure", + "start": 2539.789, + "duration": 1.791 + }, + { + "text": "if you just want to store numbers\nor something else in really just", + "start": 2541.58, + "duration": 4.56 + }, + { + "text": "the most efficient way for you\nwithout regard really to fairness.", + "start": 2546.14, + "duration": 3.28 + }, + { + "text": "So, for instance, if this table\nhere is my initial data structure", + "start": 2549.42, + "duration": 3.95 + }, + { + "text": "and it's empty and I have a piece\nof information that I want to store,", + "start": 2553.37, + "duration": 3.602 + }, + { + "text": "I'm just going to going\nahead and put it right there.", + "start": 2556.972, + "duration": 2.208 + }, + { + "text": "And now suppose I want to push\nanother number onto the stack.", + "start": 2559.18, + "duration": 2.87 + }, + { + "text": "I'm just going to go\nahead and simply put it", + "start": 2562.05, + "duration": 2.91 + }, + { + "text": "on top, third number on\ntop, fourth number on top.", + "start": 2564.96, + "duration": 4.95 + }, + { + "text": "But I've now committed to a\ncertain property, if you will,", + "start": 2569.91, + "duration": 5.11 + }, + { + "text": "a certain property whereby the last\ntray in has to be the first tray out,", + "start": 2575.02, + "duration": 5.2 + }, + { + "text": "otherwise known in computer\nscience as LIFO-- last in,", + "start": 2580.22, + "duration": 2.68 + }, + { + "text": "first out-- because if I want to\nget that first number, I mean,", + "start": 2582.9, + "duration": 3.06 + }, + { + "text": "I've created a mess for myself.", + "start": 2585.96, + "duration": 1.52 + }, + { + "text": "I have to lift these all up or\nmove them just to get at it.", + "start": 2587.48, + "duration": 3.34 + }, + { + "text": "That just seems stupid.", + "start": 2590.82, + "duration": 1.23 + }, + { + "text": "Intuitively, the easiest thing to\ngrab is probably going to be the top,", + "start": 2592.05, + "duration": 3.62 + }, + { + "text": "but that's not necessarily\nthe first element I put in.", + "start": 2595.67, + "duration": 2.89 + }, + { + "text": "But that's OK.", + "start": 2598.56, + "duration": 0.647 + }, + { + "text": "This might still be a\nvalid data structure--", + "start": 2599.207, + "duration": 1.833 + }, + { + "text": "and indeed later in the term when\nwe introduced web programming", + "start": 2601.04, + "duration": 2.63 + }, + { + "text": "and we look at languages\nlike HTML, there's", + "start": 2603.67, + "duration": 2.07 + }, + { + "text": "actually a number of applications\nwhere it's actually super useful", + "start": 2605.74, + "duration": 2.87 + }, + { + "text": "to have a data structure where you can\njust stack stuff on top of each other", + "start": 2608.61, + "duration": 3.3 + }, + { + "text": "in order to tuck some data\naway for subsequent use.", + "start": 2611.91, + "duration": 3.39 + }, + { + "text": "And, indeed, when we talked\nabout memory in our own computer,", + "start": 2615.3, + "duration": 3.02 + }, + { + "text": "stacks clearly have some value.", + "start": 2618.32, + "duration": 2.23 + }, + { + "text": "We talked about main and then swap,\nand then maybe other functions.", + "start": 2620.55, + "duration": 2.83 + }, + { + "text": "There are many contexts, one of which\nwe've seen already, where in life you", + "start": 2623.38, + "duration": 3.48 + }, + { + "text": "actually want to stack\nthings on top of each other", + "start": 2626.86, + "duration": 2.64 + }, + { + "text": "so as to keep track of really what\ndid I do most recently, because that's", + "start": 2629.5, + "duration": 3.63 + }, + { + "text": "the next problem I'm going to\ndeal with or the next frame--", + "start": 2633.13, + "duration": 2.61 + }, + { + "text": "in the case of memory-- that I'm\ngoing to pop off of the stack.", + "start": 2635.74, + "duration": 2.74 + }, + { + "text": "So, how might we implement\nthis data structure?", + "start": 2638.48, + "duration": 2.43 + }, + { + "text": "Let me propose that if we want\nto define our own data type", + "start": 2640.91, + "duration": 3.5 + }, + { + "text": "called the stack that implements that\nidea of cafeteria trays or frames", + "start": 2644.41, + "duration": 4.9 + }, + { + "text": "in memory, let me go ahead and typedef\na structure called stack inside", + "start": 2649.31, + "duration": 5.65 + }, + { + "text": "of which are two data members.", + "start": 2654.96, + "duration": 1.682 + }, + { + "text": "Suppose that, for the\nsake of discussion,", + "start": 2656.642, + "duration": 1.708 + }, + { + "text": "I'm not going to try to store trays\nor something that doesn't really", + "start": 2658.35, + "duration": 2.833 + }, + { + "text": "exist computationally but\nrather numbers, just integers.", + "start": 2661.183, + "duration": 2.697 + }, + { + "text": "Inside of this structure\ncalled a stack is", + "start": 2663.88, + "duration": 2.21 + }, + { + "text": "going to be an array\ncalled numbers of type int", + "start": 2666.09, + "duration": 2.716 + }, + { + "text": "and it's going to store capacity.", + "start": 2668.806, + "duration": 1.374 + }, + { + "text": "So capacity, let's assume, is hash\ndefined elsewhere to be some constant.", + "start": 2670.18, + "duration": 3.61 + }, + { + "text": "So, maybe it's 10, maybe it's 1,000,\nbut it's some constant integer elsewhere", + "start": 2673.79, + "duration": 4.16 + }, + { + "text": "that limits, ultimately, the capacity\nof the stack to some integral value.", + "start": 2677.95, + "duration": 4.53 + }, + { + "text": "And then size-- this seems weird.", + "start": 2682.48, + "duration": 2.91 + }, + { + "text": "I have capacity here and then size here.", + "start": 2685.39, + "duration": 3.1 + }, + { + "text": "Well, there's the\nsemantic distinction here.", + "start": 2688.49, + "duration": 2.2 + }, + { + "text": "Just because you have\na stack ready to go,", + "start": 2690.69, + "duration": 2.21 + }, + { + "text": "as I did a moment ago-- just because\nI had this stack ready to go,", + "start": 2692.9, + "duration": 4.63 + }, + { + "text": "empty initially, it's going\nto have some capacity.", + "start": 2697.53, + "duration": 2.37 + }, + { + "text": "Realistically, I can only\ngo as high as the ceiling", + "start": 2699.9, + "duration": 2.13 + }, + { + "text": "or until the things fall over.", + "start": 2702.03, + "duration": 1.76 + }, + { + "text": "But there's also a size here,\nand the size is currently zero,", + "start": 2703.79, + "duration": 3.03 + }, + { + "text": "but the capacity might be\nlike 1,000 or whatever.", + "start": 2706.82, + "duration": 2.41 + }, + { + "text": "So, that's the difference\nthere and the size now is 4", + "start": 2709.23, + "duration": 2.82 + }, + { + "text": "and the capacity is like\n1,000 minus 4 at this point--", + "start": 2712.05, + "duration": 3.25 + }, + { + "text": "or rather, capacity is still 1,000,\nbecause that's the total possible size,", + "start": 2715.3, + "duration": 4.29 + }, + { + "text": "not the actual size.", + "start": 2719.59, + "duration": 2.1 + }, + { + "text": "But what if that's a limit?", + "start": 2721.69, + "duration": 1.54 + }, + { + "text": "What if I don't want to restrict myself\nto some fixed, finite number of trays", + "start": 2723.23, + "duration": 6.16 + }, + { + "text": "or a fixed number of numbers?", + "start": 2729.39, + "duration": 1.97 + }, + { + "text": "Well, I could instead declare\nmy stack as being a pointer.", + "start": 2731.36, + "duration": 5.82 + }, + { + "text": "Now, this pointer\ninitially has no value,", + "start": 2737.18, + "duration": 2.24 + }, + { + "text": "so let's assume that it's probably going\nto be initialized to null in my code,", + "start": 2739.42, + "duration": 4.355 + }, + { + "text": "but that too is not going to be useful.", + "start": 2743.775, + "duration": 1.625 + }, + { + "text": "Why would I declare numbers now\nnot to be in an array, which", + "start": 2745.4, + "duration": 3.767 + }, + { + "text": "felt very straightforward.", + "start": 2749.167, + "duration": 1.083 + }, + { + "text": "Normally we draw arrays left\nto right, but with the trays,", + "start": 2750.25, + "duration": 2.63 + }, + { + "text": "just imagine turning an array vertically\nand thinking of the number stacked", + "start": 2752.88, + "duration": 3.53 + }, + { + "text": "on top of each other.", + "start": 2756.41, + "duration": 1.35 + }, + { + "text": "But this is just a pointer to a number.", + "start": 2757.76, + "duration": 3.07 + }, + { + "text": "Why might I want to implement a\nstack as just a pointer to an int?", + "start": 2760.83, + "duration": 3.64 + }, + { + "text": "That seems wrong.", + "start": 2764.47, + "duration": 2.83 + }, + { + "text": "I want lots of numbers, not one number.", + "start": 2767.3, + "duration": 3.75 + }, + { + "text": "So, what could I do?", + "start": 2771.05, + "duration": 1.95 + }, + { + "text": "Well, what if in this world to implement\na stack I invoke our friend malloc", + "start": 2773.0, + "duration": 4.86 + }, + { + "text": "and I say to malloc, malloc,\ngive me enough memory", + "start": 2777.86, + "duration": 2.54 + }, + { + "text": "for 2,000 numbers or 5,000 numbers.", + "start": 2780.4, + "duration": 3.32 + }, + { + "text": "What is malloc going to return?", + "start": 2783.72, + "duration": 1.43 + }, + { + "text": "Well, by definition,\nwe know malloc is going", + "start": 2785.15, + "duration": 1.98 + }, + { + "text": "to return the address of a chunk\nof memory, and that chunk of memory", + "start": 2787.13, + "duration": 5.17 + }, + { + "text": "is going to be of whatever\nsize I ask malloc for,", + "start": 2792.3, + "duration": 3.48 + }, + { + "text": "and the address of the first is\nreally just equivalent to the address", + "start": 2795.78, + "duration": 3.44 + }, + { + "text": "of one integer.", + "start": 2799.22, + "duration": 1.28 + }, + { + "text": "And so long as I, the programmer,\nremember that I asked malloc", + "start": 2800.5, + "duration": 2.65 + }, + { + "text": "for 2,000 integers or\nfor 5,000 integers,", + "start": 2803.15, + "duration": 3.28 + }, + { + "text": "I know implicitly the end of\nthat chunk of memory and malloc", + "start": 2806.43, + "duration": 3.24 + }, + { + "text": "just need to tell me the beginning.", + "start": 2809.67, + "duration": 1.61 + }, + { + "text": "So, it's perfectly fine to implement\nthe stack by way of a single pointer,", + "start": 2811.28, + "duration": 4.53 + }, + { + "text": "because all I need to\nknow is, hey, malloc,", + "start": 2815.81, + "duration": 2.19 + }, + { + "text": "where should I put my first integer?", + "start": 2818.0, + "duration": 2.26 + }, + { + "text": "Because I know via pointer\narithmetic, per last week,", + "start": 2820.26, + "duration": 2.99 + }, + { + "text": "that I can put my next\ninteger four bytes later,", + "start": 2823.25, + "duration": 3.03 + }, + { + "text": "four bytes later, four bytes later.", + "start": 2826.28, + "duration": 1.78 + }, + { + "text": "And I'm deliberately going\nup this time, but it really", + "start": 2828.06, + "duration": 2.249 + }, + { + "text": "is just an array where you can think\nof the array as left and right.", + "start": 2830.309, + "duration": 2.961 + }, + { + "text": "So, this would be a way of giving\nourselves a data structure called", + "start": 2833.27, + "duration": 3.6 + }, + { + "text": "a stack that is not fixed from the\noutset like this previous version", + "start": 2836.87, + "duration": 4.64 + }, + { + "text": "to some specific capacity.", + "start": 2841.51, + "duration": 1.87 + }, + { + "text": "Now, we are limited only by how much\nphysical memory or virtual memory", + "start": 2843.38, + "duration": 4.24 + }, + { + "text": "my computer actually has.", + "start": 2847.62, + "duration": 3.37 + }, + { + "text": "So, suppose Apple or someone\nsimilar implemented the lines", + "start": 2850.99, + "duration": 6.22 + }, + { + "text": "outside their stores for the\nrelease of the iPhone as a stack.", + "start": 2857.21, + "duration": 5.214 + }, + { + "text": "So, it's weird maybe to think of\npeople stacking on top of each other,", + "start": 2862.424, + "duration": 2.916 + }, + { + "text": "but maybe you could imagine Apple\nfunneling everyone into the glass store", + "start": 2865.34, + "duration": 6.89 + }, + { + "text": "here in Manhattan, and then whoever is\nthe last one in gets their phone first.", + "start": 2872.23, + "duration": 5.5 + }, + { + "text": "Because why?", + "start": 2877.73, + "duration": 0.65 + }, + { + "text": "They're closest to the exit.", + "start": 2878.38, + "duration": 1.31 + }, + { + "text": "So, you have all these people show\nup super early in the morning or days", + "start": 2879.69, + "duration": 2.58 + }, + { + "text": "before, you pile them all into\nthe store saying everyone, hey,", + "start": 2882.27, + "duration": 2.47 + }, + { + "text": "please go into the corner there.", + "start": 2884.74, + "duration": 1.333 + }, + { + "text": "Please get into the store.", + "start": 2886.073, + "duration": 1.097 + }, + { + "text": "And then as soon as 9:00\nAM rolls around and it's", + "start": 2887.17, + "duration": 2.217 + }, + { + "text": "time to give out the iPhones, just for\nlogistical convenience you realize,", + "start": 2889.387, + "duration": 3.083 + }, + { + "text": "all right, why don't we just\ngive the person who came in", + "start": 2892.47, + "duration": 1.65 + }, + { + "text": "last their phone first because\nthey're closest to the exit", + "start": 2894.12, + "duration": 2.45 + }, + { + "text": "and get them out, last in, first out?", + "start": 2896.57, + "duration": 3.21 + }, + { + "text": "Good design, bad design?", + "start": 2899.78, + "duration": 2.1 + }, + { + "text": "It's correct in so far\nas everyone's going", + "start": 2901.88, + "duration": 2.92 + }, + { + "text": "to get an iPhone if supply is there,\nand that's never going to be the case.", + "start": 2904.8, + "duration": 4.27 + }, + { + "text": "So, it's not necessarily\nvery equitable or fair,", + "start": 2909.07, + "duration": 2.802 + }, + { + "text": "and indeed the humans are not\ngoing to be very pleased with Apple", + "start": 2911.872, + "duration": 2.708 + }, + { + "text": "if they used a LIFO data\nstructure or a stack.", + "start": 2914.58, + "duration": 4.34 + }, + { + "text": "What would these fans of Apple\nhardware prefer that Apple use?", + "start": 2918.92, + "duration": 6.25 + }, + { + "text": "We call it a line.", + "start": 2925.17, + "duration": 0.87 + }, + { + "text": "If you go to the UK,\nthey call it a queue,", + "start": 2926.04, + "duration": 1.85 + }, + { + "text": "which is actually a perfect answer,\nbecause there's this other data", + "start": 2927.89, + "duration": 3.49 + }, + { + "text": "structure in the world\ncalled a queue, which", + "start": 2931.38, + "duration": 2.65 + }, + { + "text": "is exactly what you would hope\nthe Apple store line would be,", + "start": 2934.03, + "duration": 3.1 + }, + { + "text": "a line whereby it's first in, first out.", + "start": 2937.13, + "duration": 3.41 + }, + { + "text": "So, the first person\nthere three days before,", + "start": 2940.54, + "duration": 1.875 + }, + { + "text": "at 5:00 AM gets his or her\nphone first, and the one person", + "start": 2942.415, + "duration": 3.325 + }, + { + "text": "who comes in at 9:01 AM\ndoesn't get their phone", + "start": 2945.74, + "duration": 2.26 + }, + { + "text": "because they're at the last\nposition in the queue or the list.", + "start": 2948.0, + "duration": 3.015 + }, + { + "text": "And a queue, nicely enough, might\njust have at least two operations--", + "start": 2951.015, + "duration": 2.875 + }, + { + "text": "enqueue and dequeue\nwhereby enqueue means get", + "start": 2953.89, + "duration": 2.84 + }, + { + "text": "into line d queue means\nget out of the line,", + "start": 2956.73, + "duration": 2.32 + }, + { + "text": "but these happen at different places.", + "start": 2959.05, + "duration": 1.604 + }, + { + "text": "For instance, if there's a whole bunch\nof people lined up here on the stage,", + "start": 2960.654, + "duration": 3.166 + }, + { + "text": "closest over there's\nthe front of the list.", + "start": 2963.82, + "duration": 1.52 + }, + { + "text": "I get here last.", + "start": 2965.34, + "duration": 0.84 + }, + { + "text": "I enqueue myself at the\nend of this data structure,", + "start": 2966.18, + "duration": 3.34 + }, + { + "text": "but you dequeue someone from\nthe beginning of the list.", + "start": 2969.52, + "duration": 2.63 + }, + { + "text": "By contrast, when we had a stack,\nwhen you push someone onto the stack,", + "start": 2972.15, + "duration": 3.97 + }, + { + "text": "you pop it off, or him or\nher off first by nature", + "start": 2976.12, + "duration": 4.5 + }, + { + "text": "of it being a LIFO data structure.", + "start": 2980.62, + "duration": 2.82 + }, + { + "text": "So, how might we implement a queue?", + "start": 2983.44, + "duration": 2.7 + }, + { + "text": "It's actually slightly\nmore complicated, 50% more", + "start": 2986.14, + "duration": 3.59 + }, + { + "text": "pieces of information you need to\nkeep track of, the front of the list.", + "start": 2989.73, + "duration": 3.25 + }, + { + "text": "But you can still do it in an array.", + "start": 2992.98, + "duration": 2.76 + }, + { + "text": "So, suppose that we do use an array,\nand let me go ahead and draw this", + "start": 2995.74, + "duration": 3.07 + }, + { + "text": "as follows.", + "start": 2998.81, + "duration": 0.97 + }, + { + "text": "Suppose that like hopscotch we\ndraw the queue for an Apple Store", + "start": 2999.78, + "duration": 6.37 + }, + { + "text": "like an array like this.", + "start": 3006.15, + "duration": 1.85 + }, + { + "text": "And here is the door of the Apple store,\nso you want to be at location zero,", + "start": 3008.0, + "duration": 3.96 + }, + { + "text": "ideally.", + "start": 3011.96, + "duration": 0.5 + }, + { + "text": "1, 2, 3, 4, 5, 6-- so\nthis is how many people", + "start": 3012.46, + "duration": 3.77 + }, + { + "text": "can fit into our queue in this case.", + "start": 3016.23, + "duration": 2.64 + }, + { + "text": "So, suppose that Alice wants to buy an\niPhone and she gets to the store first.", + "start": 3018.87, + "duration": 4.32 + }, + { + "text": "Where should she go to keep things fair?", + "start": 3023.19, + "duration": 2.76 + }, + { + "text": "This is the queue, so we don't\nwant to put her into the corner,", + "start": 3025.95, + "duration": 3.304 + }, + { + "text": "so to speak, in our first example.", + "start": 3029.254, + "duration": 1.416 + }, + { + "text": "We want to put her at\nthe front of the list.", + "start": 3030.67, + "duration": 1.833 + }, + { + "text": "So, Alice belongs right\nthere, pretty straightforward.", + "start": 3032.503, + "duration": 3.367 + }, + { + "text": "Now, Bob arrives and he comes\nin slightly after Alice,", + "start": 3035.87, + "duration": 2.62 + }, + { + "text": "so he gets to get behind Alice in line.", + "start": 3038.49, + "duration": 2.36 + }, + { + "text": "And so Bob is there, and maybe Charlie\narrives thereafter, and then so forth.", + "start": 3040.85, + "duration": 3.96 + }, + { + "text": "David maybe comes in fourth and beyond.", + "start": 3044.81, + "duration": 2.71 + }, + { + "text": "So, that's how people would\nqueue up, so to speak.", + "start": 3047.52, + "duration": 2.64 + }, + { + "text": "And now, when it's time\nfor Apple to open this door", + "start": 3050.16, + "duration": 3.25 + }, + { + "text": "and start selling iPhones, what happens?", + "start": 3053.41, + "duration": 3.26 + }, + { + "text": "We want to take Alice\nout of the list first.", + "start": 3056.67, + "duration": 2.39 + }, + { + "text": "We want to de-queue Alice.", + "start": 3059.06, + "duration": 2.18 + }, + { + "text": "So, we need to start\nremembering some information,", + "start": 3061.24, + "duration": 2.99 + }, + { + "text": "because it's not sufficient\nnow to just remove-- whoops,", + "start": 3064.23, + "duration": 4.6 + }, + { + "text": "it's not sufficient just\nto remove Alice like this,", + "start": 3068.83, + "duration": 3.72 + }, + { + "text": "because suppose that we do keep\nadding other people, person", + "start": 3072.55, + "duration": 3.096 + }, + { + "text": "d, e-- whoops, that's not an f.", + "start": 3075.646, + "duration": 2.824 + }, + { + "text": "OK, don't know what happened there.", + "start": 3078.47, + "duration": 2.7 + }, + { + "text": "Person f is here, g, h.", + "start": 3081.17, + "duration": 3.03 + }, + { + "text": "Suppose that Alice has bought\nher phone and left the store,", + "start": 3084.2, + "duration": 3.39 + }, + { + "text": "and then Bob does the same.", + "start": 3087.59, + "duration": 1.96 + }, + { + "text": "He goes ahead and leaves the store,\nand then Charlie leaves the store.", + "start": 3089.55, + "duration": 4.66 + }, + { + "text": "Where do I put person i who\nmaybe shows up a little late?", + "start": 3094.21, + "duration": 4.12 + }, + { + "text": "It would seem that I want to put\nthem at the end of the queue, which", + "start": 3098.33, + "duration": 3.45 + }, + { + "text": "makes good sense, but right now d, e,\nf, g, and h are still in the queue,", + "start": 3101.78, + "duration": 5.11 + }, + { + "text": "and this is an array I proposed.", + "start": 3106.89, + "duration": 1.85 + }, + { + "text": "My data structure's an array, so I can't\njust move d to the front of the line", + "start": 3108.74, + "duration": 5.88 + }, + { + "text": "easily.", + "start": 3114.62, + "duration": 1.1 + }, + { + "text": "I have to actually\nshift him or move him,", + "start": 3115.72, + "duration": 2.33 + }, + { + "text": "and this might conjure up some memory\nof our searching and sorting examples", + "start": 3118.05, + "duration": 3.317 + }, + { + "text": "where when we had our\nhumans on stage, we actually", + "start": 3121.367, + "duration": 2.083 + }, + { + "text": "had to physically move\npeople like an insertion sort", + "start": 3123.45, + "duration": 2.46 + }, + { + "text": "to make room for those elements.", + "start": 3125.91, + "duration": 2.17 + }, + { + "text": "And that's fine.", + "start": 3128.08, + "duration": 0.73 + }, + { + "text": "We can absolutely say, hey, David,\ncome over here please and person e,", + "start": 3128.81, + "duration": 4.284 + }, + { + "text": "come over here please, and that's\nobviously what the Apple store does.", + "start": 3133.094, + "duration": 2.916 + }, + { + "text": "But when you're implementing\nthis idea in memory,", + "start": 3136.01, + "duration": 2.19 + }, + { + "text": "you can't just ask the numbers\nthemselves or the elements themselves", + "start": 3138.2, + "duration": 3.55 + }, + { + "text": "to do that moving.", + "start": 3141.75, + "duration": 1.11 + }, + { + "text": "You need to do it for them, and\nthat's going to cost you time,", + "start": 3142.86, + "duration": 2.964 + }, + { + "text": "and that's going to be a\nprice that you have to pay.", + "start": 3145.824, + "duration": 2.166 + }, + { + "text": "But I propose that we\ncan be clever here.", + "start": 3147.99, + "duration": 3.24 + }, + { + "text": "We do not need to incur the cost of\nmoving d, e, f, g h where Alice, Bob,", + "start": 3151.23, + "duration": 6.29 + }, + { + "text": "and Charlie previously were.", + "start": 3157.52, + "duration": 3.12 + }, + { + "text": "Where can we put person i instead?", + "start": 3160.64, + "duration": 4.01 + }, + { + "text": "I mean, there's obviously\nroom in the line,", + "start": 3164.65, + "duration": 2.35 + }, + { + "text": "so maybe why don't we\njust put person i here?", + "start": 3167.0, + "duration": 2.645 + }, + { + "text": "But, again, we don't want to piss off\neveryone who's already in the line.", + "start": 3169.645, + "duration": 4.135 + }, + { + "text": "So, if this now is an array, we\nhave to be mindful of the fact", + "start": 3173.78, + "duration": 3.64 + }, + { + "text": "that the front of this list has\nto be remembered separately.", + "start": 3177.42, + "duration": 5.41 + }, + { + "text": "This data member here front really\nshould store not 0 in perpetuity", + "start": 3182.83, + "duration": 5.18 + }, + { + "text": "but really 0, 1, 2, 3.", + "start": 3188.01, + "duration": 2.2 + }, + { + "text": "It should store the\ncurrent front of the list.", + "start": 3190.21, + "duration": 3.3 + }, + { + "text": "And I need another\nvariable, presumably, called", + "start": 3193.51, + "duration": 2.63 + }, + { + "text": "size that keeps track of how many\nelements are in the list, which", + "start": 3196.14, + "duration": 3.19 + }, + { + "text": "in this case is going to be six.", + "start": 3199.33, + "duration": 2.33 + }, + { + "text": "So with a queue, if I'm\nimplementing it using an array,", + "start": 3201.66, + "duration": 2.5 + }, + { + "text": "there's some added\ncomplexity if I want to avoid", + "start": 3204.16, + "duration": 2.62 + }, + { + "text": "the inefficiency of moving\nall of these elements", + "start": 3206.78, + "duration": 3.022 + }, + { + "text": "and incurring the kind of running times\nwe saw when we talked about searching", + "start": 3209.802, + "duration": 3.208 + }, + { + "text": "and sorting the other day.", + "start": 3213.01, + "duration": 1.19 + }, + { + "text": "There's no reason mechanically to move\nd, e, f, g, h anywhere in the array.", + "start": 3214.2, + "duration": 5.49 + }, + { + "text": "We can in constant time, and maybe\nour old friend the modulo operator", + "start": 3219.69, + "duration": 3.68 + }, + { + "text": "that you might have\nused in [INAUDIBLE], we", + "start": 3223.37, + "duration": 2.33 + }, + { + "text": "can just figure out where\ni, and j, and everyone else", + "start": 3225.7, + "duration": 2.7 + }, + { + "text": "should go so long as we\nkeep track separately", + "start": 3228.4, + "duration": 2.61 + }, + { + "text": "with a queue of what the\nfront of the list would be.", + "start": 3231.01, + "duration": 2.57 + }, + { + "text": "And why is this 3?", + "start": 3233.58, + "duration": 0.98 + }, + { + "text": "Well, if I continue numbering the\narray like this, as we've often done,", + "start": 3234.56, + "duration": 4.66 + }, + { + "text": "you can now see that d is the head of\nthe list, or the front of the list.", + "start": 3239.22, + "duration": 4.21 + }, + { + "text": "And so, we should remember\nhis location there as 3.", + "start": 3243.43, + "duration": 3.96 + }, + { + "text": "But, again, what happens if\nj, k, and then l shows up?", + "start": 3247.39, + "duration": 4.45 + }, + { + "text": "There is no room for l in this\nworld, not to mention m, n, o.", + "start": 3251.84, + "duration": 3.76 + }, + { + "text": "So what if we solved\nthis problem as before", + "start": 3255.6, + "duration": 3.26 + }, + { + "text": "by changing the array from having\nsome fixed capacity to having", + "start": 3258.86, + "duration": 4.85 + }, + { + "text": "no pre-determined capacity,\njust use a pointer so that we", + "start": 3263.71, + "duration": 3.76 + }, + { + "text": "can use malloc to dynamically\nallocate a big chunk of memory,", + "start": 3267.47, + "duration": 3.21 + }, + { + "text": "remember its capacity\nultimately, but also", + "start": 3270.68, + "duration": 3.32 + }, + { + "text": "remember the front and the\nsize of this data structure?", + "start": 3274.0, + "duration": 2.87 + }, + { + "text": "So, the same idea there might apply.", + "start": 3276.87, + "duration": 3.34 + }, + { + "text": "So, at the end of the\nday, what have we done?", + "start": 3280.21, + "duration": 2.15 + }, + { + "text": "We've taken these new\nbuilding blocks, pointers,", + "start": 3282.36, + "duration": 4.04 + }, + { + "text": "and this notion of linking\nthings together using pointers", + "start": 3286.4, + "duration": 2.57 + }, + { + "text": "much like a linked list,\nand we've looked back", + "start": 3288.97, + "duration": 2.24 + }, + { + "text": "at our data structure called an array.", + "start": 3291.21, + "duration": 2.12 + }, + { + "text": "And using these now, we can implement\nwhat are generally called abstract data", + "start": 3293.33, + "duration": 3.69 + }, + { + "text": "types, a queue in a stack\ndoes not have as a low level", + "start": 3297.02, + "duration": 3.2 + }, + { + "text": "meaning as an array does, which\nis a very technical concept.", + "start": 3300.22, + "duration": 2.759 + }, + { + "text": "And in a linked list, this\nis a very technical concept.", + "start": 3302.979, + "duration": 2.291 + }, + { + "text": "It's a node with pointers\nlinking things together.", + "start": 3305.27, + "duration": 2.21 + }, + { + "text": "A stack is like a stack\nof cafeteria trays,", + "start": 3307.48, + "duration": 2.521 + }, + { + "text": "or a queue is something like people\nlining up outside of an Apple Store.", + "start": 3310.001, + "duration": 2.999 + }, + { + "text": "These are abstract data types\nthat can be implemented clearly", + "start": 3313.0, + "duration": 3.25 + }, + { + "text": "underneath the hood in at least\na couple of different ways.", + "start": 3316.25, + "duration": 3.09 + }, + { + "text": "You can use an array and\nkeep things simple, a la", + "start": 3319.34, + "duration": 2.15 + }, + { + "text": "weeks two and beyond in\nthe class, but you're", + "start": 3321.49, + "duration": 2.35 + }, + { + "text": "going to paint yourself into\na corner by fixing their size,", + "start": 3323.84, + "duration": 2.51 + }, + { + "text": "as I did a moment ago,\nby declaring this queue", + "start": 3326.35, + "duration": 2.75 + }, + { + "text": "and before it a stack to\nbe of a fixed capacity.", + "start": 3329.1, + "duration": 2.71 + }, + { + "text": "But now that we have pointers, and\nmalloc, and dynamic memory allocation,", + "start": 3331.81, + "duration": 3.35 + }, + { + "text": "and this spirit of linked\nlists, we can change", + "start": 3335.16, + "duration": 3.06 + }, + { + "text": "that to actually be\nnumbers and actually just", + "start": 3338.22, + "duration": 2.95 + }, + { + "text": "remember where things\nare underneath the hood.", + "start": 3341.17, + "duration": 2.46 + }, + { + "text": "And nicely enough, a stack\nin a queue doesn't even", + "start": 3343.63, + "duration": 2.21 + }, + { + "text": "need me to stitch things\ntogether like a linked list.", + "start": 3345.84, + "duration": 2.84 + }, + { + "text": "I just need malloc in\norder to allocate those.", + "start": 3348.68, + "duration": 4.05 + }, + { + "text": "So, let's tie these two\ntopics together if you would", + "start": 3352.73, + "duration": 2.19 + }, + { + "text": "and compare and contrast them\nby way of a wonderful animation", + "start": 3354.92, + "duration": 3.28 + }, + { + "text": "that a fellow educator\nmade and posted online", + "start": 3358.2, + "duration": 2.1 + }, + { + "text": "that we've abbreviated here to give us\na sense of the difference between stacks", + "start": 3360.3, + "duration": 3.99 + }, + { + "text": "and queues.", + "start": 3364.29, + "duration": 0.709 + }, + { + "text": "[AUDIO PLAYBACK]", + "start": 3364.999, + "duration": 0.666 + }, + { + "text": "[MUSIC PLAYING]", + "start": 3365.665, + "duration": 4.655 + }, + { + "text": "-Once upon a time, there\nwas a guy named Jack.", + "start": 3370.32, + "duration": 2.91 + }, + { + "text": "When it came to making friends,\nJack did not have the knack.", + "start": 3373.23, + "duration": 3.36 + }, + { + "text": "So, Jack went to talk to the\nmost popular guy he knew.", + "start": 3376.59, + "duration": 2.98 + }, + { + "text": "He went to Lou and asked what do I do?", + "start": 3379.57, + "duration": 2.6 + }, + { + "text": "Lou saw that his friend\nwas really distressed.", + "start": 3382.17, + "duration": 2.65 + }, + { + "text": "Well, Lou, began just\nlook how you're dressed.", + "start": 3384.82, + "duration": 2.46 + }, + { + "text": "Don't you have any clothes\nwith a different look?", + "start": 3387.28, + "duration": 2.73 + }, + { + "text": "Yes, said, Jack.", + "start": 3390.01, + "duration": 0.97 + }, + { + "text": "I sure do.", + "start": 3390.98, + "duration": 1.19 + }, + { + "text": "Come to my house and\nI'll show them to you.", + "start": 3392.17, + "duration": 2.46 + }, + { + "text": "So, they went off to Jack's,\nand Jack showed Lou the box", + "start": 3394.63, + "duration": 2.96 + }, + { + "text": "where he kept all his shirts,\nand his pants, and his socks Lou", + "start": 3397.59, + "duration": 3.22 + }, + { + "text": "said I see you have all\nyour clothes in a pile.", + "start": 3400.81, + "duration": 2.82 + }, + { + "text": "Why don't you wear some\nothers once in a while?", + "start": 3403.63, + "duration": 2.53 + }, + { + "text": "Jack said, well, when I\nremove clothes and socks,", + "start": 3406.16, + "duration": 3.17 + }, + { + "text": "I wash them and put them away in\nthe box, then comes the next morning", + "start": 3409.33, + "duration": 4.0 + }, + { + "text": "and up I hop.", + "start": 3413.33, + "duration": 1.2 + }, + { + "text": "I go to the box and get\nmy clothes off the top.", + "start": 3414.53, + "duration": 3.18 + }, + { + "text": "Lou quickly realized\nthe problem with Jack.", + "start": 3417.71, + "duration": 2.73 + }, + { + "text": "He kept clothes, CDs,\nand books in a stack.", + "start": 3420.44, + "duration": 2.9 + }, + { + "text": "When he reached something\nto read or to wear", + "start": 3423.34, + "duration": 2.45 + }, + { + "text": "he chose [? the top ?]\nbook or underwear.", + "start": 3425.79, + "duration": 2.62 + }, + { + "text": "Then when he was done he\nwould put it right back,", + "start": 3428.41, + "duration": 2.41 + }, + { + "text": "back it would go on top of the stack.", + "start": 3430.82, + "duration": 2.49 + }, + { + "text": "I know the solution,\nsaid a triumphant Lou.", + "start": 3433.31, + "duration": 2.49 + }, + { + "text": "You need to learn to\nstart using a queue.", + "start": 3435.8, + "duration": 2.59 + }, + { + "text": "Lou took Jack's clothes\nand hung them in a closet,", + "start": 3438.39, + "duration": 2.81 + }, + { + "text": "and when he had emptied\nthe box he just tossed it.", + "start": 3441.2, + "duration": 2.84 + }, + { + "text": "Then he said, now, Jack, at the\nend of the day put your clothes", + "start": 3444.04, + "duration": 3.25 + }, + { + "text": "on the left when you put them away.", + "start": 3447.29, + "duration": 2.01 + }, + { + "text": "Then tomorrow morning\nwhen you see the sunshine,", + "start": 3449.3, + "duration": 2.51 + }, + { + "text": "get your clothes from right\nfrom the end of the line.", + "start": 3451.81, + "duration": 2.96 + }, + { + "text": "Don't you see, said Lou.", + "start": 3454.77, + "duration": 1.44 + }, + { + "text": "It will be so nice.", + "start": 3456.21, + "duration": 1.49 + }, + { + "text": "You'll wear everything once\nbefore you wear something twice.", + "start": 3457.7, + "duration": 3.4 + }, + { + "text": "And with everything in queues\nin his closet and shelf,", + "start": 3461.1, + "duration": 2.85 + }, + { + "text": "Jack started to feel quite\nsure of himself all thanks", + "start": 3463.95, + "duration": 3.06 + }, + { + "text": "to Lou and his wonderful queue.", + "start": 3467.01, + "duration": 4.576 + }, + { + "text": "[END PLAYBACK]", + "start": 3471.586, + "duration": 0.982 + }, + { + "text": "SPEAKER 1: All right, so let's\ntake a look at another data type,", + "start": 3472.568, + "duration": 3.712 + }, + { + "text": "this one known as a tree.", + "start": 3476.28, + "duration": 1.94 + }, + { + "text": "Because now that we have the ability\nto stitch data structures together much", + "start": 3478.22, + "duration": 4.16 + }, + { + "text": "like a linked list, we\nnow have the ability", + "start": 3482.38, + "duration": 1.89 + }, + { + "text": "to stitch things together not just left\nto right or top to bottom conceptually,", + "start": 3484.27, + "duration": 5.78 + }, + { + "text": "but in any number of directions.", + "start": 3490.05, + "duration": 1.345 + }, + { + "text": "And indeed, there's nothing\nstopping us from having", + "start": 3491.395, + "duration": 2.125 + }, + { + "text": "one node linked to by way of\nmultiple pointers, multiple nodes.", + "start": 3493.52, + "duration": 4.41 + }, + { + "text": "So, for instance, this picture here\nfrom a textbook is a tree structure.", + "start": 3497.93, + "duration": 4.34 + }, + { + "text": "And it's very much like the\nfamily trees that you might", + "start": 3502.27, + "duration": 2.406 + }, + { + "text": "have drawn in grade school or the like.", + "start": 3504.676, + "duration": 1.624 + }, + { + "text": "But in this case, you\nhave just one root node,", + "start": 3506.3, + "duration": 2.91 + }, + { + "text": "the node at the top of the\ndata structure, so to speak,", + "start": 3509.21, + "duration": 2.53 + }, + { + "text": "from which everything else descends.", + "start": 3511.74, + "duration": 2.01 + }, + { + "text": "And that node is said to have children.", + "start": 3513.75, + "duration": 2.26 + }, + { + "text": "For instance, 2 and 3 are children\nof the node number 1 here.", + "start": 3516.01, + "duration": 4.06 + }, + { + "text": "And then there's other semantics in\nthis world of trees in computer science.", + "start": 3520.07, + "duration": 3.52 + }, + { + "text": "Much like family trees,\nanything that does not", + "start": 3523.59, + "duration": 2.53 + }, + { + "text": "have children-- like 5,\n6, and 7, or 8 and 9--", + "start": 3526.12, + "duration": 2.7 + }, + { + "text": "would be called leaves of the\ntree, because like the leaves", + "start": 3528.82, + "duration": 2.995 + }, + { + "text": "at the end of the branches,\nthere is nothing beyond them.", + "start": 3531.815, + "duration": 2.375 + }, + { + "text": "So, nicely enough we borrow\na lot of the language", + "start": 3534.19, + "duration": 2.53 + }, + { + "text": "from family trees and\nactual trees in order", + "start": 3536.72, + "duration": 2.75 + }, + { + "text": "to discuss this data\nstructure known as a tree.", + "start": 3539.47, + "duration": 3.14 + }, + { + "text": "But why in the world would we want\nto lay out data in a tree structure?", + "start": 3542.61, + "duration": 5.05 + }, + { + "text": "Now we just seem to be\ndoing things because we can,", + "start": 3547.66, + "duration": 3.06 + }, + { + "text": "it would seem at first glance.", + "start": 3550.72, + "duration": 1.57 + }, + { + "text": "Because, for instance, suppose we had\nthese numbers-- 22, 33, 44, 55, 66, 77,", + "start": 3552.29, + "duration": 5.14 + }, + { + "text": "and 88.", + "start": 3557.43, + "duration": 1.1 + }, + { + "text": "They're clearly sorted.", + "start": 3558.53, + "duration": 1.1 + }, + { + "text": "And suppose that I wanted to lay\nthese out in a data structure", + "start": 3559.63, + "duration": 3.27 + }, + { + "text": "and be able to search them\nefficiently, assuming the whole time", + "start": 3562.9, + "duration": 4.19 + }, + { + "text": "that they are indeed sorted.", + "start": 3567.09, + "duration": 1.19 + }, + { + "text": "Well, if we wanted to do that, we have\nour old friend arrays from weeks ago.", + "start": 3568.28, + "duration": 4.26 + }, + { + "text": "And we also have our old algorithm\nfrom Mike Smith, our binary search", + "start": 3572.54, + "duration": 4.12 + }, + { + "text": "algorithm, divide and conquer.", + "start": 3576.66, + "duration": 1.53 + }, + { + "text": "And we can find nodes in\nthis data structure super,", + "start": 3578.19, + "duration": 2.52 + }, + { + "text": "super fast in logarithmic\ntime, big O of log n.", + "start": 3580.71, + "duration": 4.39 + }, + { + "text": "So, we've solved that problem.", + "start": 3585.1, + "duration": 1.67 + }, + { + "text": "But it turns out we don't necessarily\nhave to use an array laying out data", + "start": 3586.77, + "duration": 5.08 + }, + { + "text": "from left to right because, again, one\nof the prices we pay of using arrays", + "start": 3591.85, + "duration": 5.97 + }, + { + "text": "where as we've realized\ntoday is this finiteness.", + "start": 3597.82, + "duration": 3.03 + }, + { + "text": "At the end of the day, the\nsize of an array is fixed.", + "start": 3600.85, + "duration": 2.56 + }, + { + "text": "You have to decide in advance how\nbig your array is going to be.", + "start": 3603.41, + "duration": 3.35 + }, + { + "text": "So, what if you want to\nadd more numbers to it?", + "start": 3606.76, + "duration": 1.999 + }, + { + "text": "What if you want to remove\nnumbers for efficiency", + "start": 3608.759, + "duration": 2.041 + }, + { + "text": "and not waste so much memory?", + "start": 3610.8, + "duration": 1.46 + }, + { + "text": "You can't really do that with an array.", + "start": 3612.26, + "duration": 1.67 + }, + { + "text": "You can, but have to\njump through some hoops.", + "start": 3613.93, + "duration": 2.54 + }, + { + "text": "You have to reallocate the array, as\nwith a function like [? re-alloc ?]", + "start": 3616.47, + "duration": 3.47 + }, + { + "text": "if you indeed used malloc in\nthe first place to allocate it.", + "start": 3619.94, + "duration": 2.93 + }, + { + "text": "But then you have to copy the\nold array into the new array,", + "start": 3622.87, + "duration": 2.65 + }, + { + "text": "so it's all possible.", + "start": 3625.52, + "duration": 1.29 + }, + { + "text": "Nothing's impossible once you\nhave a keyboard at your disposal,", + "start": 3626.81, + "duration": 3.96 + }, + { + "text": "but it's a lot of work,\nand it's more time,", + "start": 3630.77, + "duration": 1.96 + }, + { + "text": "and it's expensive there for\nboth in terms of your time", + "start": 3632.73, + "duration": 2.3 + }, + { + "text": "and the computer's time.", + "start": 3635.03, + "duration": 1.7 + }, + { + "text": "But could we achieve\nthe beauty of divide", + "start": 3636.73, + "duration": 2.91 + }, + { + "text": "and conquer and binary search from\nweek zero without the constraints", + "start": 3639.64, + "duration": 4.28 + }, + { + "text": "that arrays impose?", + "start": 3643.92, + "duration": 1.31 + }, + { + "text": "And today, the solution to\nall of our array problems", + "start": 3645.23, + "duration": 2.61 + }, + { + "text": "seems to be linked lists or\nmore generally pointers so", + "start": 3647.84, + "duration": 3.33 + }, + { + "text": "that, one, we can dynamically allocate\nmore memory with malloc when we need it", + "start": 3651.17, + "duration": 3.25 + }, + { + "text": "and then use pointers to\nthread or stitch together", + "start": 3654.42, + "duration": 2.88 + }, + { + "text": "that node with any existing nodes.", + "start": 3657.3, + "duration": 2.52 + }, + { + "text": "So, indeed let me propose this\nvariant on a tree structure", + "start": 3659.82, + "duration": 3.92 + }, + { + "text": "that the world calls binary\nsearch trees or BSTs.", + "start": 3663.74, + "duration": 2.98 + }, + { + "text": "Binary in this case means two, and this\njust means that every node in this tree", + "start": 3666.72, + "duration": 4.59 + }, + { + "text": "is going to have 0, 1,\nor 2 maximally children.", + "start": 3671.31, + "duration": 4.7 + }, + { + "text": "And now, in this case binary search tree\nmeans that for every node in the tree", + "start": 3676.01, + "duration": 7.35 + }, + { + "text": "it's left child is less than it and\nits right child is greater than it.", + "start": 3683.36, + "duration": 5.36 + }, + { + "text": "And that's a recursive definition.", + "start": 3688.72, + "duration": 1.67 + }, + { + "text": "You can look at the root of this\ntree and ask that same question.", + "start": 3690.39, + "duration": 3.48 + }, + { + "text": "55?", + "start": 3693.87, + "duration": 0.7 + }, + { + "text": "Is it greater than its left child?", + "start": 3694.57, + "duration": 1.5 + }, + { + "text": "Yep.", + "start": 3696.07, + "duration": 0.54 + }, + { + "text": "Is it less than its right child?", + "start": 3696.61, + "duration": 1.38 + }, + { + "text": "Yep.", + "start": 3697.99, + "duration": 0.83 + }, + { + "text": "That is the beginning, it would\nseem, of a binary search tree.", + "start": 3698.82, + "duration": 2.67 + }, + { + "text": "But it's recursive in so far as\nthis is indeed a binary search", + "start": 3701.49, + "duration": 2.92 + }, + { + "text": "tree if that statement is true.", + "start": 3704.41, + "duration": 2.08 + }, + { + "text": "Those answers are the same for\nevery other node in the tree.", + "start": 3706.49, + "duration": 2.88 + }, + { + "text": "33, is its left child smaller?", + "start": 3709.37, + "duration": 2.16 + }, + { + "text": "Yep.", + "start": 3711.53, + "duration": 0.5 + }, + { + "text": "Is its right child bigger?", + "start": 3712.03, + "duration": 1.2 + }, + { + "text": "Yep.", + "start": 3713.23, + "duration": 0.53 + }, + { + "text": "How about over here, 77?", + "start": 3713.76, + "duration": 1.16 + }, + { + "text": "Left child smaller?", + "start": 3714.92, + "duration": 0.95 + }, + { + "text": "Yep.", + "start": 3715.87, + "duration": 0.5 + }, + { + "text": "Right child bigger?", + "start": 3716.37, + "duration": 1.16 + }, + { + "text": "Yep, indeed.", + "start": 3717.53, + "duration": 0.95 + }, + { + "text": "How about the leaves of the tree?", + "start": 3718.48, + "duration": 2.0 + }, + { + "text": "Is 22 greater than its left child?", + "start": 3720.48, + "duration": 3.93 + }, + { + "text": "I mean, yeah, there is no child,\nso yes, that's a fair statement.", + "start": 3724.41, + "duration": 3.4 + }, + { + "text": "It certainly doesn't violate\nour guiding principle.", + "start": 3727.81, + "duration": 2.66 + }, + { + "text": "Is it less than its right child, if any?", + "start": 3730.47, + "duration": 2.05 + }, + { + "text": "Yes, there just isn't any.", + "start": 3732.52, + "duration": 1.82 + }, + { + "text": "And so this is a binary search tree.", + "start": 3734.34, + "duration": 1.96 + }, + { + "text": "And indeed, if you took a scissors and\nsnipped off any branch of this tree,", + "start": 3736.3, + "duration": 4.54 + }, + { + "text": "you would have another binary\nsearch tree, albeit smaller.", + "start": 3740.84, + "duration": 3.98 + }, + { + "text": "But it's recursive and that definition\napplies to every one of the nodes.", + "start": 3744.82, + "duration": 3.09 + }, + { + "text": "But what's beautiful here now is that\nif we implement this binary search", + "start": 3747.91, + "duration": 3.88 + }, + { + "text": "tree, similar in spirit to how\nwe implemented linked lists", + "start": 3751.79, + "duration": 2.89 + }, + { + "text": "using not arrays but using pointers\nand not one pointer but two pointers", + "start": 3754.68, + "duration": 4.34 + }, + { + "text": "whereby every node in this tree\napparently has up to two pointers--", + "start": 3759.02, + "duration": 4.42 + }, + { + "text": "let's call them not next but how about\nleft and right just to be intuitive.", + "start": 3763.44, + "duration": 5.03 + }, + { + "text": "Well, if every node has a\nleft and a right pointer,", + "start": 3768.47, + "duration": 2.83 + }, + { + "text": "now you can conceptually attach\nyourself to another node over there", + "start": 3771.3, + "duration": 3.59 + }, + { + "text": "and another node over there,\nand they too can do the same.", + "start": 3774.89, + "duration": 3.29 + }, + { + "text": "So, we have the syntax already with our\npointers with which to implement this.", + "start": 3778.18, + "duration": 4.22 + }, + { + "text": "But why would we?", + "start": 3782.4, + "duration": 1.03 + }, + { + "text": "Well, one, if we're using\npointers now and not an array,", + "start": 3783.43, + "duration": 2.8 + }, + { + "text": "I can very, very easily allocate\nmore nodes for this tree.", + "start": 3786.23, + "duration": 3.97 + }, + { + "text": "I can insert 99 or 11 really\neasily, because I just", + "start": 3790.2, + "duration": 4.26 + }, + { + "text": "called malloc like I did before.", + "start": 3794.46, + "duration": 1.82 + }, + { + "text": "I put the number 99 or\n11 inside of that node,", + "start": 3796.28, + "duration": 2.76 + }, + { + "text": "and then I start from\nthe root of the tree,", + "start": 3799.04, + "duration": 1.88 + }, + { + "text": "much like I start from the first\nelement in the linked list,", + "start": 3800.92, + "duration": 2.78 + }, + { + "text": "and I just search for its destined\nlocation going left or right", + "start": 3803.7, + "duration": 3.81 + }, + { + "text": "based on the size of that value.", + "start": 3807.51, + "duration": 1.62 + }, + { + "text": "And what's nice, too, here is\nnotice how short the tree is.", + "start": 3809.13, + "duration": 3.85 + }, + { + "text": "This is not a linked list.", + "start": 3812.98, + "duration": 1.17 + }, + { + "text": "It's not a long list, whether\nvertically or horizontally.", + "start": 3814.15, + "duration": 3.5 + }, + { + "text": "This is very shallow this tree.", + "start": 3817.65, + "duration": 2.93 + }, + { + "text": "And indeed I claim that if we've\ngot n elements in this list,", + "start": 3820.58, + "duration": 4.33 + }, + { + "text": "the height of this tree\nit turns out is log of n.", + "start": 3824.91, + "duration": 4.04 + }, + { + "text": "So, the height of this tree is\nlog of n, give or take one or so.", + "start": 3828.95, + "duration": 4.86 + }, + { + "text": "But that's compelling, because\nhow do I search this tree?", + "start": 3833.81, + "duration": 3.14 + }, + { + "text": "Suppose I am asked-- I'm trying to\nanswer the question is 44 on my list?", + "start": 3836.95, + "duration": 3.855 + }, + { + "text": "How do I answer that?", + "start": 3840.805, + "duration": 0.875 + }, + { + "text": "Well, we humans can obviously just look\nback and it's like, yes, 44 is in it.", + "start": 3841.68, + "duration": 2.97 + }, + { + "text": "It's not how a computer works.", + "start": 3844.65, + "duration": 1.17 + }, + { + "text": "We have to start from what\nwe're given, which in this case", + "start": 3845.82, + "duration": 2.416 + }, + { + "text": "is going to be as the arrow\nsuggests a pointer to the tree", + "start": 3848.236, + "duration": 2.864 + }, + { + "text": "itself, a pointer towards first node.", + "start": 3851.1, + "duration": 1.77 + }, + { + "text": "And I look is this the number 44?", + "start": 3852.87, + "duration": 2.36 + }, + { + "text": "Obviously not.", + "start": 3855.23, + "duration": 1.36 + }, + { + "text": "55 is greater than 44, so I'm\ngoing to go down to the left child", + "start": 3856.59, + "duration": 3.835 + }, + { + "text": "and ask that same question.", + "start": 3860.425, + "duration": 1.125 + }, + { + "text": "33, is this 44?", + "start": 3861.55, + "duration": 1.19 + }, + { + "text": "Obviously not, but it's\nless than it so I'm", + "start": 3862.74, + "duration": 2.45 + }, + { + "text": "going to go down to the right child.", + "start": 3865.19, + "duration": 1.56 + }, + { + "text": "Is this 44?", + "start": 3866.75, + "duration": 0.98 + }, + { + "text": "Yes, and simply by\nlooking at three nodes", + "start": 3867.73, + "duration": 4.88 + }, + { + "text": "have I whittled this problem\ndown to my yes no answer.", + "start": 3872.61, + "duration": 3.96 + }, + { + "text": "And indeed, you can think\nof it again with scissors.", + "start": 3876.57, + "duration": 2.49 + }, + { + "text": "I'm looking at 55 at the\nbeginning of this story.", + "start": 3879.06, + "duration": 2.61 + }, + { + "text": "Is 44 55?", + "start": 3881.67, + "duration": 1.07 + }, + { + "text": "No, 44 is less.", + "start": 3882.74, + "duration": 1.12 + }, + { + "text": "Well, you know what?", + "start": 3883.86, + "duration": 1.21 + }, + { + "text": "I can effectively snip off\nthe right half of that tree,", + "start": 3885.07, + "duration": 4.29 + }, + { + "text": "much like I tore that phone book in\nweek zero, throwing half of the problem", + "start": 3889.36, + "duration": 3.55 + }, + { + "text": "away.", + "start": 3892.91, + "duration": 0.5 + }, + { + "text": "Here I can throw essentially half of the\ntree away and search only what remains", + "start": 3893.41, + "duration": 4.41 + }, + { + "text": "and then repeat that process again,\nand again, and again, whittling", + "start": 3897.82, + "duration": 3.2 + }, + { + "text": "the tree down by half every time.", + "start": 3901.02, + "duration": 2.3 + }, + { + "text": "So therein lies our\nlogarithmic running time.", + "start": 3903.32, + "duration": 3.14 + }, + { + "text": "Therein lies the height\nof the tree, so long", + "start": 3906.46, + "duration": 3.43 + }, + { + "text": "as I am good about\nkeeping the tree balanced.", + "start": 3909.89, + "duration": 5.88 + }, + { + "text": "There's a danger.", + "start": 3915.77, + "duration": 1.25 + }, + { + "text": "Suppose that I go ahead and start\nbuilding this tree myself in code", + "start": 3917.02, + "duration": 6.42 + }, + { + "text": "and I'm a little sloppy\nabout doing that.", + "start": 3923.44, + "duration": 2.59 + }, + { + "text": "And I go ahead and I insert, for\ninstance, let's say the number 33.", + "start": 3926.03, + "duration": 7.88 + }, + { + "text": "And it's the first\nnode in my tree, so I'm", + "start": 3933.91, + "duration": 2.28 + }, + { + "text": "going to put it right\nup here at the top.", + "start": 3936.19, + "duration": 2.69 + }, + { + "text": "And now suppose that the\nnext number that just happens", + "start": 3938.88, + "duration": 2.45 + }, + { + "text": "to get inserted into this tree is 44.", + "start": 3941.33, + "duration": 2.225 + }, + { + "text": "Well, where does it go?", + "start": 3943.555, + "duration": 1.485 + }, + { + "text": "Well, it has no children\nyet, but it is bigger,", + "start": 3945.04, + "duration": 2.57 + }, + { + "text": "so it should probably go over here.", + "start": 3947.61, + "duration": 1.5 + }, + { + "text": "So, yeah, I'll draw 44 there.", + "start": 3949.11, + "duration": 1.79 + }, + { + "text": "Now, suppose that the\ninputs to this problem", + "start": 3950.9, + "duration": 2.36 + }, + { + "text": "are such that 55 is inserted next.", + "start": 3953.26, + "duration": 1.79 + }, + { + "text": "Where does it go?", + "start": 3955.05, + "duration": 1.19 + }, + { + "text": "All right, 55, it's bigger,\nso it should go over here.", + "start": 3956.24, + "duration": 4.09 + }, + { + "text": "And then 66 is inserted next.", + "start": 3960.33, + "duration": 2.2 + }, + { + "text": "All right, it goes over\nhere-- never mind that.", + "start": 3962.53, + "duration": 6.14 + }, + { + "text": "So, what's happening to\nmy binary search tree?", + "start": 3968.67, + "duration": 3.342 + }, + { + "text": "Well, first of all, is\nit a binary search tree?", + "start": 3972.012, + "duration": 1.958 + }, + { + "text": "It is because this node is\nbigger than its left child,", + "start": 3973.97, + "duration": 4.51 + }, + { + "text": "if any-- there just isn't any--\nand it's less than its right child.", + "start": 3978.48, + "duration": 3.69 + }, + { + "text": "How about here, 44?", + "start": 3982.17, + "duration": 1.02 + }, + { + "text": "It's bigger than its left child,\nif any-- because there is none--", + "start": 3983.19, + "duration": 2.81 + }, + { + "text": "and it's smaller than its right child.", + "start": 3986.0, + "duration": 1.94 + }, + { + "text": "The same thing is true for 55,\nthe same thing is true for 66.", + "start": 3987.94, + "duration": 2.71 + }, + { + "text": "So, this is a binary search tree and\nyet somehow what does it look like?", + "start": 3990.65, + "duration": 5.41 + }, + { + "text": "It looks like a linked list, right?", + "start": 3996.06, + "duration": 2.27 + }, + { + "text": "It's at a weird angle.", + "start": 3998.33, + "duration": 1.09 + }, + { + "text": "I've been drawing\neverything horizontally,", + "start": 3999.42, + "duration": 1.75 + }, + { + "text": "but that's a meaningless\nartistic detail.", + "start": 4001.17, + "duration": 2.12 + }, + { + "text": "It devolves potentially\ninto a linked list.", + "start": 4003.29, + "duration": 2.67 + }, + { + "text": "And so, binary search trees if\nthey are balanced, so to speak,", + "start": 4005.96, + "duration": 3.58 + }, + { + "text": "if they are built in the right order\nor built with the right insertion", + "start": 4009.54, + "duration": 3.8 + }, + { + "text": "algorithm such that they do\nhave this balanced height,", + "start": 4013.34, + "duration": 4.0 + }, + { + "text": "this logarithmic height, do afford\nus the same logarithmic running time", + "start": 4017.34, + "duration": 4.49 + }, + { + "text": "that the phone book example did and\nour binary search of an array did.", + "start": 4021.83, + "duration": 4.04 + }, + { + "text": "But we have to do a little\nbit more work in order", + "start": 4025.87, + "duration": 2.47 + }, + { + "text": "to make sure that these\ntrees are balanced.", + "start": 4028.34, + "duration": 2.05 + }, + { + "text": "And we won't go into detail\nas to the algorithmics", + "start": 4030.39, + "duration": 2.21 + }, + { + "text": "of keeping the tree balanced.", + "start": 4032.6, + "duration": 2.07 + }, + { + "text": "But realize, again, there's\ngoing to be this trade-off.", + "start": 4034.67, + "duration": 2.44 + }, + { + "text": "Yes, you can use a binary search tree or\ntrees more generally to store numbers.", + "start": 4037.11, + "duration": 4.03 + }, + { + "text": "Yes, they can allow you to achieve that\nsame binary or logarithmic running time", + "start": 4041.14, + "duration": 4.78 + }, + { + "text": "that we've gotten so\nused to with arrays,", + "start": 4045.92, + "duration": 1.94 + }, + { + "text": "but they also give us\ndynamism such that we", + "start": 4047.86, + "duration": 2.34 + }, + { + "text": "can keep adding or even removing nodes.", + "start": 4050.2, + "duration": 2.39 + }, + { + "text": "But, but, but, but it\nturns out we're going", + "start": 4052.59, + "duration": 2.58 + }, + { + "text": "to have to think a lot harder about\nhow to keep these things balanced.", + "start": 4055.17, + "duration": 4.02 + }, + { + "text": "And indeed, in higher\nlevel CS courses, courses", + "start": 4059.19, + "duration": 2.35 + }, + { + "text": "on data structures and\nalgorithms will you", + "start": 4061.54, + "duration": 1.75 + }, + { + "text": "explore concepts along\nexactly those lines.", + "start": 4063.29, + "duration": 2.96 + }, + { + "text": "How would you go about implementing\ninsert and delete into a tree", + "start": 4066.25, + "duration": 4.34 + }, + { + "text": "so that you do maintain this balance?", + "start": 4070.59, + "duration": 2.01 + }, + { + "text": "And there is yet more variance\non these kinds of trees", + "start": 4072.6, + "duration": 2.3 + }, + { + "text": "that you'll encounter accordingly.", + "start": 4074.9, + "duration": 1.55 + }, + { + "text": "But for our purposes, let's consider\nhow you would implement the tree itself", + "start": 4076.45, + "duration": 3.59 + }, + { + "text": "independent of how you might\nimplement those actual algorithms.", + "start": 4080.04, + "duration": 4.27 + }, + { + "text": "Let me propose this type of node.", + "start": 4084.31, + "duration": 1.74 + }, + { + "text": "Again, notice just the very\ngeneric term in programming", + "start": 4086.05, + "duration": 2.62 + }, + { + "text": "where it's usually like a container for\none or more other things, and this time", + "start": 4088.67, + "duration": 4.436 + }, + { + "text": "those things are an\ninteger-- we'll call it n", + "start": 4093.106, + "duration": 1.874 + }, + { + "text": "but it could be called\nanything-- and two pointers.", + "start": 4094.98, + "duration": 2.87 + }, + { + "text": "And instead of next, I'm going to just\nby convention call them left and right.", + "start": 4097.85, + "duration": 4.78 + }, + { + "text": "And as before, notice that I do\nneed to declare struct node up", + "start": 4102.63, + "duration": 5.13 + }, + { + "text": "here or some word up here.", + "start": 4107.76, + "duration": 1.769 + }, + { + "text": "But by convention I'm just going to do\ntypedef struct node, because C reads", + "start": 4109.529, + "duration": 4.431 + }, + { + "text": "things top to bottom, left to right.", + "start": 4113.96, + "duration": 1.5 + }, + { + "text": "So if I want to refer to\na node inside of a node,", + "start": 4115.46, + "duration": 3.069 + }, + { + "text": "I need to have that vocabulary, per\nthis first line, even though later on I", + "start": 4118.529, + "duration": 4.381 + }, + { + "text": "just want to call this\nwhole darn thing a node.", + "start": 4122.91, + "duration": 3.019 + }, + { + "text": "And so, that's the distinction.", + "start": 4125.929, + "duration": 1.291 + }, + { + "text": "This actually has the side\neffect of creating a data", + "start": 4127.22, + "duration": 2.219 + }, + { + "text": "type by two different names.", + "start": 4129.439, + "duration": 1.166 + }, + { + "text": "One is called struct node, and\nyou can literally in your code", + "start": 4130.605, + "duration": 2.805 + }, + { + "text": "write struct node something,\nstruct node something.", + "start": 4133.41, + "duration": 2.44 + }, + { + "text": "It just feels unnecessarily\nverbose, so typedef", + "start": 4135.85, + "duration": 3.179 + }, + { + "text": "allows you to simplify\nthis as just node, which", + "start": 4139.029, + "duration": 2.62 + }, + { + "text": "refers to the same structure.", + "start": 4141.649, + "duration": 1.371 + }, + { + "text": "But this is necessary for this\ninnermost implementation detail.", + "start": 4143.02, + "duration": 4.459 + }, + { + "text": "So, now that we have the\nability with a structure", + "start": 4147.479, + "duration": 2.101 + }, + { + "text": "to represent this thing, what\ncan we actually do with it?", + "start": 4149.58, + "duration": 3.29 + }, + { + "text": "Well, here is where recursion\nfrom a few weeks ago", + "start": 4152.87, + "duration": 3.88 + }, + { + "text": "actually gets really compelling.", + "start": 4156.75, + "duration": 1.75 + }, + { + "text": "When we introduced that sigma example\na while ago and talked in the abstract", + "start": 4158.5, + "duration": 4.41 + }, + { + "text": "about recursion, frankly, it's kind of\nhard to justify it early on, unless you", + "start": 4162.91, + "duration": 4.35 + }, + { + "text": "actually have a problem that lends\nitself to recursion in a way that", + "start": 4167.26, + "duration": 3.41 + }, + { + "text": "makes sense to use recursion\nand not just iteration,", + "start": 4170.67, + "duration": 2.559 + }, + { + "text": "loops-- for loops, while\nloops, do while, and the like.", + "start": 4173.229, + "duration": 2.811 + }, + { + "text": "And here we actually have a\nperfect incarnation of that.", + "start": 4176.04, + "duration": 2.739 + }, + { + "text": "What does it mean to search\na binary search tree?", + "start": 4178.779, + "duration": 2.45 + }, + { + "text": "Well, suppose I'm\nsearching for a number n", + "start": 4181.229, + "duration": 2.781 + }, + { + "text": "and I'm being given a pointer\nto the root of the tree,", + "start": 4184.01, + "duration": 2.75 + }, + { + "text": "and I'll call it tree.", + "start": 4186.76, + "duration": 1.04 + }, + { + "text": "So, just like when I was\nsearching a linked list,", + "start": 4187.8, + "duration": 1.63 + }, + { + "text": "I'm given two things, the\nnumber I'm looking for", + "start": 4189.43, + "duration": 1.82 + }, + { + "text": "and a pointer to the first thing in\nthe data structure-- the first thing", + "start": 4191.25, + "duration": 2.779 + }, + { + "text": "in a linked list or the\nfirst thing in a tree.", + "start": 4194.029, + "duration": 1.901 + }, + { + "text": "And in this case, we would\ncall that first thing", + "start": 4195.93, + "duration": 1.999 + }, + { + "text": "in a tree a root, generally speaking.", + "start": 4197.929, + "duration": 2.521 + }, + { + "text": "So, the first thing I had\nbetter do in my search function", + "start": 4200.45, + "duration": 2.78 + }, + { + "text": "is check, wait a minute.", + "start": 4203.23, + "duration": 1.16 + }, + { + "text": "If tree equals equals\nnull, don't do anything.", + "start": 4204.39, + "duration": 3.88 + }, + { + "text": "Do not risk touching any pointers,\nbecause as you may have gleaned already", + "start": 4208.27, + "duration": 3.95 + }, + { + "text": "or soon will with some\nof CS50's problems,", + "start": 4212.22, + "duration": 2.5 + }, + { + "text": "you will cause quite probably\na segmentation fault,", + "start": 4214.72, + "duration": 4.63 + }, + { + "text": "a memory-related problem in your\nprogram such that it just crashes.", + "start": 4219.35, + "duration": 3.28 + }, + { + "text": "It literally says segmentation\nfault on this screen", + "start": 4222.63, + "duration": 2.88 + }, + { + "text": "if you touch memory that you should not.", + "start": 4225.51, + "duration": 1.71 + }, + { + "text": "And you should not touch null values.", + "start": 4227.22, + "duration": 2.22 + }, + { + "text": "You should not go to null values.", + "start": 4229.44, + "duration": 1.76 + }, + { + "text": "You should not do star of any\nvalue that itself might be null.", + "start": 4231.2, + "duration": 3.89 + }, + { + "text": "And so, if tree equals equals null\nis super, super important here,", + "start": 4235.09, + "duration": 3.74 + }, + { + "text": "because I want to make\nsure to immediately", + "start": 4238.83, + "duration": 1.75 + }, + { + "text": "say, well, if you hand me null, that's\nlike handing me no tree whatsoever.", + "start": 4240.58, + "duration": 3.53 + }, + { + "text": "So, my answer is obviously false.", + "start": 4244.11, + "duration": 1.72 + }, + { + "text": "N can't be in a non-existent tree.", + "start": 4245.83, + "duration": 2.84 + }, + { + "text": "But we need that condition\nup top, because the next case", + "start": 4248.67, + "duration": 3.135 + }, + { + "text": "is [? noticed through ?] the following.", + "start": 4251.805, + "duration": 1.625 + }, + { + "text": "Else if n-- the value\nwe're looking for-- is less", + "start": 4253.43, + "duration": 3.95 + }, + { + "text": "than the value of n in\nthis node-- tree, recall,", + "start": 4257.38, + "duration": 4.39 + }, + { + "text": "doesn't refer to the whole\nthing, per se, in this context.", + "start": 4261.77, + "duration": 2.54 + }, + { + "text": "It refers to the current\nnode that we've been", + "start": 4264.31, + "duration": 1.89 + }, + { + "text": "past, which at the beginning of\nthe story is the root of the tree.", + "start": 4266.2, + "duration": 3.11 + }, + { + "text": "So, if the number n in the root of\nthe tree is greater than the number", + "start": 4269.31, + "duration": 4.43 + }, + { + "text": "we're looking for, we\nwant to go to the left.", + "start": 4273.74, + "duration": 3.77 + }, + { + "text": "Else we want to go to the right\nand search the right subtree.", + "start": 4277.51, + "duration": 5.81 + }, + { + "text": "So, what's the syntax here?", + "start": 4283.32, + "duration": 1.5 + }, + { + "text": "If the n we're looking\nfor, like 44, is less", + "start": 4284.82, + "duration": 3.21 + }, + { + "text": "than the value at the current node,\n55, then what do we want to do?", + "start": 4288.03, + "duration": 5.18 + }, + { + "text": "We want to call search, still\nsearching for the same number n", + "start": 4293.21, + "duration": 4.06 + }, + { + "text": "but searching on the left subtree.", + "start": 4297.27, + "duration": 2.85 + }, + { + "text": "And how do you pass in a\npointer to the left tree?", + "start": 4300.12, + "duration": 3.86 + }, + { + "text": "Well, you have in tree a\npointer to the root node.", + "start": 4303.98, + "duration": 3.44 + }, + { + "text": "Tree arrow left just means go to my left\nchild and past that value in instead,", + "start": 4307.42, + "duration": 4.83 + }, + { + "text": "pass its address in instead.", + "start": 4312.25, + "duration": 1.23 + }, + { + "text": "Meanwhile, if the number\nyou're looking for", + "start": 4313.48, + "duration": 2.43 + }, + { + "text": "is actually greater than the\nvalue in the current node, search", + "start": 4315.91, + "duration": 2.75 + }, + { + "text": "the right subtree, else return true.", + "start": 4318.66, + "duration": 5.12 + }, + { + "text": "Because if the list is not null-- if\nthere is actually a list and the number", + "start": 4323.78, + "duration": 4.56 + }, + { + "text": "you're looking for is not\nless than the current node", + "start": 4328.34, + "duration": 2.27 + }, + { + "text": "and it's not greater than the current\nnode, it must be the current node,", + "start": 4330.61, + "duration": 4.17 + }, + { + "text": "so you can return true.", + "start": 4334.78, + "duration": 2.39 + }, + { + "text": "But there's one important detail here.", + "start": 4337.17, + "duration": 2.09 + }, + { + "text": "I didn't just call search.", + "start": 4339.26, + "duration": 1.96 + }, + { + "text": "I called return search in each\nof these two middle cases.", + "start": 4341.22, + "duration": 3.75 + }, + { + "text": "Why is that?", + "start": 4344.97, + "duration": 0.786 + }, + { + "text": "Well, this is where recursion gets\npotentially a little mind bending.", + "start": 4345.756, + "duration": 2.874 + }, + { + "text": "Recursion is the act of a\nfunction calling itself.", + "start": 4348.63, + "duration": 3.53 + }, + { + "text": "Now, in and of itself, that sounds bad,\nbecause if a function calls itself,", + "start": 4352.16, + "duration": 3.63 + }, + { + "text": "why wouldn't it call itself again, and\nagain, and again, and again, and again,", + "start": 4355.79, + "duration": 4.27 + }, + { + "text": "and just do this\ninfinitely many times such", + "start": 4360.06, + "duration": 2.06 + }, + { + "text": "that now you get a stack overflow\nwhere all of those frames on the stack", + "start": 4362.12, + "duration": 3.06 + }, + { + "text": "hit the heap and bad things happen.", + "start": 4365.18, + "duration": 1.89 + }, + { + "text": "But no, recursion works beautifully\nso long as every time you recurse,", + "start": 4367.07, + "duration": 5.58 + }, + { + "text": "every time a function calls itself it\ntakes a smaller byte of the problem.", + "start": 4372.65, + "duration": 6.01 + }, + { + "text": "Or rather, put another\nway, it throws away", + "start": 4378.66, + "duration": 2.31 + }, + { + "text": "half of the problem, as in this case,\nand looks only at a remaining half.", + "start": 4380.97, + "duration": 3.042 + }, + { + "text": "Because if you keep shrinking,\nshrinking, shrinking, shrinking", + "start": 4384.012, + "duration": 2.583 + }, + { + "text": "the problem, you will\neventually hit this base case", + "start": 4386.595, + "duration": 2.475 + }, + { + "text": "where either there is no more tree\nor you're looking right at the node", + "start": 4389.07, + "duration": 4.16 + }, + { + "text": "that you want to find.", + "start": 4393.23, + "duration": 1.27 + }, + { + "text": "And so, by returning\nsearch and tree left,", + "start": 4394.5, + "duration": 3.52 + }, + { + "text": "or returning search and tree\nright, you're deferring the answer.", + "start": 4398.02, + "duration": 4.72 + }, + { + "text": "When you, the search\nfunction, are called and asked", + "start": 4402.74, + "duration": 3.22 + }, + { + "text": "is the number 44 in\nthis tree, you might not", + "start": 4405.96, + "duration": 2.875 + }, + { + "text": "know because the node you're looking\nat at the beginning of the story", + "start": 4408.835, + "duration": 2.875 + }, + { + "text": "was again 55.", + "start": 4411.71, + "duration": 1.57 + }, + { + "text": "But you know who does know?", + "start": 4413.28, + "duration": 1.21 + }, + { + "text": "I bet my left child will know\nthe answer to that if I just", + "start": 4414.49, + "duration": 3.05 + }, + { + "text": "ask it by passing it-- passing to\nsearch a pointer to it, my left child,", + "start": 4417.54, + "duration": 6.98 + }, + { + "text": "and passing in that same number 44.", + "start": 4424.52, + "duration": 2.31 + }, + { + "text": "So, saying return search is\nlike saying I don't know.", + "start": 4426.83, + "duration": 3.5 + }, + { + "text": "Ask my left child.", + "start": 4430.33, + "duration": 1.0 + }, + { + "text": "Or I don't know, ask my right child\nand let me return as my answer", + "start": 4431.33, + "duration": 4.39 + }, + { + "text": "whatever my child's answer is instead.", + "start": 4435.72, + "duration": 3.52 + }, + { + "text": "So, you could do this same\nfunction using iteration.", + "start": 4439.24, + "duration": 4.4 + }, + { + "text": "But you could solve it arguably much\nmore elegantly here using recursion,", + "start": 4443.64, + "duration": 5.475 + }, + { + "text": "because a data structure like\nthis-- like a binary search tree,", + "start": 4449.115, + "duration": 2.625 + }, + { + "text": "which again is recursively\ndefined-- each node is conceptually", + "start": 4451.74, + "duration": 4.15 + }, + { + "text": "identical, if numerically\ndifferent from the others,", + "start": 4455.89, + "duration": 3.14 + }, + { + "text": "allows us to apply this algorithm,\nthis recursive algorithm", + "start": 4459.03, + "duration": 4.69 + }, + { + "text": "to that particular data structure.", + "start": 4463.72, + "duration": 3.264 + }, + { + "text": "Now, let's look at a\nmore concrete incarnation", + "start": 4466.984, + "duration": 1.916 + }, + { + "text": "of trees that allows us to do something\npretty neat and pretty real world.", + "start": 4468.9, + "duration": 4.23 + }, + { + "text": "Indeed, this is another problem borne\nof a real world domain of compression.", + "start": 4473.13, + "duration": 5.02 + }, + { + "text": "We talked a couple weeks\nago about encryption,", + "start": 4478.15, + "duration": 2.07 + }, + { + "text": "the art of concealing or\nscrambling information.", + "start": 4480.22, + "duration": 2.33 + }, + { + "text": "Compression, meanwhile, is the art\nof taking something that's this big", + "start": 4482.55, + "duration": 3.54 + }, + { + "text": "and compressing it to make it smaller,\nideally without losing any information.", + "start": 4486.09, + "duration": 5.24 + }, + { + "text": "It's pretty easy to take\na 10 page essay that's", + "start": 4491.33, + "duration": 3.01 + }, + { + "text": "maybe-- that was supposed\nto be a five page essay", + "start": 4494.34, + "duration": 2.63 + }, + { + "text": "and just remove paragraphs from\nit or remove sentences from it.", + "start": 4496.97, + "duration": 3.85 + }, + { + "text": "But that changes the meaning of\nthe paper, makes it a worse paper,", + "start": 4500.82, + "duration": 3.45 + }, + { + "text": "even though you're compressing\nit by making it smaller.", + "start": 4504.27, + "duration": 2.33 + }, + { + "text": "No, what most students would typically\ndo, if you've written 10 pages", + "start": 4506.6, + "duration": 2.82 + }, + { + "text": "and it needs to fit into five,\nyou really, really, really", + "start": 4509.42, + "duration": 2.3 + }, + { + "text": "shrink the font size or\nincrease the margins.", + "start": 4511.72, + "duration": 1.95 + }, + { + "text": "Or maybe more realistically you\nwrite a five page paper that's", + "start": 4513.67, + "duration": 2.732 + }, + { + "text": "supposed to be a 10 page paper,\nand so you increase the font size", + "start": 4516.402, + "duration": 2.708 + }, + { + "text": "or increase the margins so as to\nexpand or decompress the essay.", + "start": 4519.11, + "duration": 5.86 + }, + { + "text": "So, similarly here, what if\nwe wanted to compress text,", + "start": 4524.97, + "duration": 4.57 + }, + { + "text": "but we want to do it\nlosslessly in a way that we", + "start": 4529.54, + "duration": 2.9 + }, + { + "text": "don't lose any information\nby just throwing away", + "start": 4532.44, + "duration": 2.21 + }, + { + "text": "characters, or paragraphs,\nor pages, but we", + "start": 4534.65, + "duration": 4.214 + }, + { + "text": "want to use the system with which\nwe're familiar from week zero.", + "start": 4538.864, + "duration": 2.666 + }, + { + "text": "So ASCII, again, is just this code,\nthis mapping of letters to numbers.", + "start": 4541.53, + "duration": 3.38 + }, + { + "text": "And so, A is-- capital A is 65\nand that's some pattern of bits,", + "start": 4544.91, + "duration": 4.07 + }, + { + "text": "but it's some pattern of\n8 bits-- 7 historically,", + "start": 4548.98, + "duration": 3.13 + }, + { + "text": "but really 8 bits in\npractice So every one", + "start": 4552.11, + "duration": 2.94 + }, + { + "text": "of the characters in the\nEnglish alphabet, at least here,", + "start": 4555.05, + "duration": 3.68 + }, + { + "text": "takes up 8 bits.", + "start": 4558.73, + "duration": 2.16 + }, + { + "text": "Now, that sounds fine.", + "start": 4560.89, + "duration": 1.1 + }, + { + "text": "That allows us to express as many\nas 256 possible characters, which", + "start": 4561.99, + "duration": 3.25 + }, + { + "text": "is more than enough for English\ncharacters, plus some punctuation", + "start": 4565.24, + "duration": 2.74 + }, + { + "text": "and so forth.", + "start": 4567.98, + "duration": 1.18 + }, + { + "text": "But it seems wasteful.", + "start": 4569.16, + "duration": 2.23 + }, + { + "text": "I type A, E, and I, maybe\nO and U pretty often.", + "start": 4571.39, + "duration": 3.24 + }, + { + "text": "I use the values often--\nthe vowels often.", + "start": 4574.63, + "duration": 3.778 + }, + { + "text": "B and D, I feel like I use those a lot.", + "start": 4578.408, + "duration": 2.852 + }, + { + "text": "I don't really type Q all\nthat much, Z all that much.", + "start": 4581.26, + "duration": 4.31 + }, + { + "text": "So, there are certain\nletters that I just", + "start": 4585.57, + "duration": 1.735 + }, + { + "text": "feel like I don't type them\nthat often, and indeed,", + "start": 4587.305, + "duration": 2.125 + }, + { + "text": "probably if we analyzed a dictionary,\nwe wouldn't see them as frequently", + "start": 4589.43, + "duration": 3.24 + }, + { + "text": "as other letters.", + "start": 4592.67, + "duration": 0.82 + }, + { + "text": "Indeed, if you've ever played\nor watched Wheel of Fortune,", + "start": 4593.49, + "duration": 2.5 + }, + { + "text": "certainly all the\ncontestants on that show", + "start": 4595.99, + "duration": 2.04 + }, + { + "text": "know which are the most popular\nletters in English words.", + "start": 4598.03, + "duration": 3.48 + }, + { + "text": "And it seems silly and\nperhaps inefficient--", + "start": 4601.51, + "duration": 3.33 + }, + { + "text": "certainly for a computer\nscientist-- that we are not somehow", + "start": 4604.84, + "duration": 2.65 + }, + { + "text": "embracing the fact that some letters\nare more commonly used than others,", + "start": 4607.49, + "duration": 4.37 + }, + { + "text": "and yet we are just blindly using\n8 bits, the same amount of memory,", + "start": 4611.86, + "duration": 3.92 + }, + { + "text": "for every darn letter in our alphabet.", + "start": 4615.78, + "duration": 1.71 + }, + { + "text": "Why?", + "start": 4617.49, + "duration": 0.9 + }, + { + "text": "If you keep writing a certain\nletter again and again,", + "start": 4618.39, + "duration": 2.29 + }, + { + "text": "why not use fewer bits for\nthe more popular letters,", + "start": 4620.68, + "duration": 3.12 + }, + { + "text": "and more bits for the\nless popular letters", + "start": 4623.8, + "duration": 2.24 + }, + { + "text": "so that at least you're optimizing\nfor the common case, so to speak?", + "start": 4626.04, + "duration": 4.61 + }, + { + "text": "Well, it turns out that someone\nnamed Huffman years ago did", + "start": 4630.65, + "duration": 3.31 + }, + { + "text": "figure this out and introduced what's\ngenerally known as Huffman coding.", + "start": 4633.96, + "duration": 3.61 + }, + { + "text": "And, at first glance, it's a little\nsimilar in spirit to something", + "start": 4637.57, + "duration": 2.84 + }, + { + "text": "some of you might have grown up learning\na little something about called Morse", + "start": 4640.41, + "duration": 3.249 + }, + { + "text": "code, but it's better\nin a couple of ways.", + "start": 4643.659, + "duration": 2.141 + }, + { + "text": "Morse code typically transmitted with\nelectrical signals or audible signals.", + "start": 4645.8, + "duration": 5.52 + }, + { + "text": "It has dots and dashes\nwhere a dot is a quick beep", + "start": 4651.32, + "duration": 3.09 + }, + { + "text": "and a dash is a slightly\nlonger beep, and you", + "start": 4654.41, + "duration": 2.43 + }, + { + "text": "can use those series of dots and\ndashes, as per this chart here,", + "start": 4656.84, + "duration": 4.13 + }, + { + "text": "to represent letters of the\nalphabet and some numbers.", + "start": 4660.97, + "duration": 3.18 + }, + { + "text": "The one problem, though, as efficient\nas this seems-- and then by efficient", + "start": 4664.15, + "duration": 4.4 + }, + { + "text": "I mean look at E. Mr. Morse realized\nthat is super popular, so he", + "start": 4668.55, + "duration": 4.14 + }, + { + "text": "used literally the shortest symbol\nfor it, just a dot, a simple blip,", + "start": 4672.69, + "duration": 3.41 + }, + { + "text": "to represent an E. And,\nmeanwhile, as I kind of imagined,", + "start": 4676.1, + "duration": 2.99 + }, + { + "text": "Z is not that common,\nso dash, dash, dot,", + "start": 4679.09, + "duration": 3.47 + }, + { + "text": "dot is longer than just a single dot.", + "start": 4682.56, + "duration": 2.33 + }, + { + "text": "So Z is probably less popular,\nand that's why we did this.", + "start": 4684.89, + "duration": 2.59 + }, + { + "text": "And Y may be even less\npopular-- dash, dot, dash--", + "start": 4687.48, + "duration": 3.437 + }, + { + "text": "I don't know why I'm using this voice.", + "start": 4690.917, + "duration": 1.583 + }, + { + "text": "But it's longer than E, so we\noptimized for the shorter characters.", + "start": 4692.5, + "duration": 5.056 + }, + { + "text": "Unfortunately, suppose that you receive\nthe message dot, dot, dot, dot, dot,", + "start": 4697.556, + "duration": 10.064 + }, + { + "text": "dot, so six dots in a row, and I\ntechnically paused in between them.", + "start": 4707.62, + "duration": 4.82 + }, + { + "text": "Six dots, what message\ndid I just send you?", + "start": 4712.44, + "duration": 2.052 + }, + { + "text": " ", + "start": 4714.492, + "duration": 3.698 + }, + { + "text": "Six dots.", + "start": 4718.19, + "duration": 0.76 + }, + { + "text": " ", + "start": 4718.95, + "duration": 5.232 + }, + { + "text": "So, I wanted to say hi, so I said\ndot, dot, dot, dot, which is H,", + "start": 4724.182, + "duration": 4.068 + }, + { + "text": "and then dot, dot which is I. I\nshould not have paused between them,", + "start": 4728.25, + "duration": 3.23 + }, + { + "text": "because the whole point of Morse code\nis to do this as quickly as possible,", + "start": 4731.48, + "duration": 3.125 + }, + { + "text": "even though you probably do want\nto pause to resolve ambiguity,", + "start": 4734.605, + "duration": 3.045 + }, + { + "text": "and indeed, that's the problem.", + "start": 4737.65, + "duration": 1.53 + }, + { + "text": "I wanted to send you\nhi, H-I, but maybe I", + "start": 4739.18, + "duration": 4.03 + }, + { + "text": "just sent you E, E, E,\nE, E, E, six Es in a row,", + "start": 4743.21, + "duration": 4.59 + }, + { + "text": "because those two were just dots.", + "start": 4747.8, + "duration": 1.69 + }, + { + "text": "So, in other words, Morse code\nis not immediately decodable", + "start": 4749.49, + "duration": 2.87 + }, + { + "text": "when you're reading, or hearing,\nor seeing the dots and dashes come", + "start": 4752.36, + "duration": 3.097 + }, + { + "text": "over the wire, so to speak,\nbecause there's these ambiguities,", + "start": 4755.457, + "duration": 2.583 + }, + { + "text": "unless this transmitter\ndoes indeed pause,", + "start": 4758.04, + "duration": 3.47 + }, + { + "text": "as I accidentally did there, to give\nyou a moment to take your breath", + "start": 4761.51, + "duration": 3.54 + }, + { + "text": "and realize, oh, that was an H. That's\nan I. As opposed to E, E, E, E, E, E.", + "start": 4765.05, + "duration": 4.95 + }, + { + "text": "So, it's not necessarily the best\nsystem in so far as some letters", + "start": 4770.0, + "duration": 4.02 + }, + { + "text": "share prefixes with other letters.", + "start": 4774.02, + "duration": 3.03 + }, + { + "text": "In other words, I, dot dot, has a\ncommon prefix with E. Both of them", + "start": 4777.05, + "duration": 4.93 + }, + { + "text": "start with a single dot.", + "start": 4781.98, + "duration": 1.485 + }, + { + "text": "It just so happens that\nI is a little longer,", + "start": 4783.465, + "duration": 1.875 + }, + { + "text": "and that can lead\npotentially to ambiguity,", + "start": 4785.34, + "duration": 1.91 + }, + { + "text": "and it certainly means that the\ntransmitter should probably slow down.", + "start": 4787.25, + "duration": 4.86 + }, + { + "text": "So, the whole system is meant to\nbe super fast, super efficient,", + "start": 4792.11, + "duration": 2.71 + }, + { + "text": "but you probably should\npause between certain letters", + "start": 4794.82, + "duration": 3.04 + }, + { + "text": "so that the recipient\ndoesn't get confused as", + "start": 4797.86, + "duration": 1.98 + }, + { + "text": "to the message you're actually sending.", + "start": 4799.84, + "duration": 2.11 + }, + { + "text": "Well, thankfully Huffman coding--\nwhich as we'll see in a moment", + "start": 4801.95, + "duration": 3.25 + }, + { + "text": "is based on trees-- does\nnot have that ambiguity.", + "start": 4805.2, + "duration": 2.6 + }, + { + "text": "It is a immediately decodable.", + "start": 4807.8, + "duration": 1.76 + }, + { + "text": "And suppose for the sake of\ndiscussion, as per this example here,", + "start": 4809.56, + "duration": 3.06 + }, + { + "text": "you just have a whole bunch of\ntext that you want to transmit.", + "start": 4812.62, + "duration": 1.87 + }, + { + "text": "This is meaningless.", + "start": 4814.49, + "duration": 0.833 + }, + { + "text": "There's no pattern in these\nAs, and E, B, C, Ds, and Es,", + "start": 4815.323, + "duration": 2.787 + }, + { + "text": "but if you go through and count them\nup, each these letters-- A, B, C, D, E--", + "start": 4818.11, + "duration": 4.343 + }, + { + "text": "occur with some frequency in this text.", + "start": 4822.453, + "duration": 1.734 + }, + { + "text": "So, it's meant to be representative\nof an essay, or a message,", + "start": 4824.187, + "duration": 2.583 + }, + { + "text": "or whatever that you\nwant to send to someone.", + "start": 4826.77, + "duration": 1.874 + }, + { + "text": "Indeed, if you count up all of the\nAs, Bs, Cs, Ds, and Es, and divide", + "start": 4828.644, + "duration": 3.876 + }, + { + "text": "by the total number of\nletters, it turns out", + "start": 4832.52, + "duration": 1.97 + }, + { + "text": "that 20% of the characters in that\nrandom string are As, 10% are Bs,", + "start": 4834.49, + "duration": 5.39 + }, + { + "text": "10% are Cs, 15% are\nDs, and 45% are Es, so", + "start": 4839.88, + "duration": 3.95 + }, + { + "text": "it's roughly consistent\nwith what I'm claiming,", + "start": 4843.83, + "duration": 2.17 + }, + { + "text": "which is that it E is pretty popular.", + "start": 4846.0, + "duration": 1.83 + }, + { + "text": "So, intuitively, [? it ?]\nwould be really nice", + "start": 4847.83, + "duration": 2.95 + }, + { + "text": "if I had an algorithm that came up\nwith some representation of bits", + "start": 4850.78, + "duration": 5.83 + }, + { + "text": "that's not just 8 bits\nfor every darn letter", + "start": 4856.61, + "duration": 2.73 + }, + { + "text": "but that is a few bits\nfor the popular letters", + "start": 4859.34, + "duration": 3.24 + }, + { + "text": "and more bits for the\nless popular letters,", + "start": 4862.58, + "duration": 1.9 + }, + { + "text": "so I optimize, again, so to\nspeak, for the common case.", + "start": 4864.48, + "duration": 2.77 + }, + { + "text": "So, by this logic E, hopefully,\nshould have a pretty short encoding", + "start": 4867.25, + "duration": 4.49 + }, + { + "text": "in binary, and A, and B, and C, and D\nshould have slightly longer encoding,", + "start": 4871.74, + "duration": 5.69 + }, + { + "text": "so that again if I'm using E a lot I\nwant to send as few bits as possible.", + "start": 4877.43, + "duration": 3.48 + }, + { + "text": "But I need this algorithm\nto be repeatable.", + "start": 4880.91, + "duration": 1.829 + }, + { + "text": "I don't want to just arbitrarily\ncome up with something", + "start": 4882.739, + "duration": 2.291 + }, + { + "text": "and then have to tell you in advance\nthat, hey, we're using this David Malan", + "start": 4885.03, + "duration": 4.1 + }, + { + "text": "system for binary.", + "start": 4889.13, + "duration": 1.06 + }, + { + "text": "We want an algorithmic process here.", + "start": 4890.19, + "duration": 2.11 + }, + { + "text": "And what's nice about trees is that\nit's one way of seeing and solving", + "start": 4892.3, + "duration": 4.2 + }, + { + "text": "exactly that.", + "start": 4896.5, + "duration": 1.04 + }, + { + "text": "So, Huffman proposed this.", + "start": 4897.54, + "duration": 1.67 + }, + { + "text": "If you have a forest of nodes, so to\nspeak, a whole bunch of trees-- each", + "start": 4899.21, + "duration": 4.48 + }, + { + "text": "of size one, no children-- think of them\nas each having a weight or a frequency.", + "start": 4903.69, + "duration": 3.9 + }, + { + "text": "So, I've drawn five circles\nhere, per this snippet", + "start": 4907.59, + "duration": 2.79 + }, + { + "text": "from a popular textbook that has 10%,\n10%, 15%, 20%, 45% equivalently in each", + "start": 4910.38, + "duration": 7.286 + }, + { + "text": "of those nodes.", + "start": 4917.666, + "duration": 0.624 + }, + { + "text": "And I've just labeled the\nleaves as B, C, D, A, E,", + "start": 4918.29, + "duration": 3.225 + }, + { + "text": "deliberately from left to right because\nit will make my tree look prettier,", + "start": 4921.515, + "duration": 3.125 + }, + { + "text": "but technically the lines could cross\nand it's not a big deal in reality.", + "start": 4924.64, + "duration": 3.041 + }, + { + "text": "We just need to be consistent.", + "start": 4927.681, + "duration": 1.419 + }, + { + "text": "So, Huffman proposed this.", + "start": 4929.1, + "duration": 1.82 + }, + { + "text": "In order to figure out the so-called\nHuffman tree for this particular text,", + "start": 4930.92, + "duration": 7.39 + }, + { + "text": "in order to figure out what to encode\nit's letters as with zeros and ones,", + "start": 4938.31, + "duration": 4.05 + }, + { + "text": "go ahead and take the two smallest nodes\nand combine them with a new root node.", + "start": 4942.36, + "duration": 5.27 + }, + { + "text": "So in other words, B\nand C were both 10%.", + "start": 4947.63, + "duration": 2.52 + }, + { + "text": "Those are the smallest nodes.", + "start": 4950.15, + "duration": 1.35 + }, + { + "text": "Let's go ahead and combine\nthem with a new root node", + "start": 4951.5, + "duration": 2.166 + }, + { + "text": "and add together their weights,\nso 10% plus 10% is 20%.", + "start": 4953.666, + "duration": 3.384 + }, + { + "text": "And then arbitrarily,\nbut consistently, label", + "start": 4957.05, + "duration": 3.42 + }, + { + "text": "the left child's edge or arrow as a\n0 and the right arrow's edge as a 1.", + "start": 4960.47, + "duration": 7.53 + }, + { + "text": "Meanwhile, repeat.", + "start": 4968.0, + "duration": 1.61 + }, + { + "text": "So, now look for the two smallest nodes.", + "start": 4969.61, + "duration": 1.99 + }, + { + "text": "And I see a 20%-- so\nignore the children now.", + "start": 4971.6, + "duration": 3.31 + }, + { + "text": "Only look at the roots of these trees.", + "start": 4974.91, + "duration": 1.8 + }, + { + "text": "And there's now four trees, one of which\nhas children, three of which don't.", + "start": 4976.71, + "duration": 5.14 + }, + { + "text": "So, now look at the smallest roots\nnow and you can go left to right here.", + "start": 4981.85, + "duration": 4.59 + }, + { + "text": "There's a 20%, there's a 15%,\nthere's a 20%, and a 45%.", + "start": 4986.44, + "duration": 5.3 + }, + { + "text": "So, I'm not sure which one\nto go with, so you just", + "start": 4991.74, + "duration": 2.395 + }, + { + "text": "have to come up with some\nrule to be consistent.", + "start": 4994.135, + "duration": 2.0 + }, + { + "text": "I'm going to go with\nthe ones on the left,", + "start": 4996.135, + "duration": 1.765 + }, + { + "text": "and so I'm going to combine the 20%\nwith the 15%, the 20% on the left.", + "start": 4997.9, + "duration": 4.38 + }, + { + "text": "Combine their weights.", + "start": 5002.28, + "duration": 1.14 + }, + { + "text": "That gives me 35% in a new root,\nand again label the left branch 0", + "start": 5003.42, + "duration": 4.05 + }, + { + "text": "and the right branch a 1.", + "start": 5007.47, + "duration": 1.78 + }, + { + "text": "Now, it's not ambiguous.", + "start": 5009.25, + "duration": 1.42 + }, + { + "text": "Let's combine 35% and 20%\nwith a new root that's 55%.", + "start": 5010.67, + "duration": 4.51 + }, + { + "text": "Call its left branch\n0, its right branch 1.", + "start": 5015.18, + "duration": 3.93 + }, + { + "text": "And now 55% and 45%, combine\nthose and give us a 1.", + "start": 5019.11, + "duration": 7.1 + }, + { + "text": "So why did I just do this?", + "start": 5026.21, + "duration": 2.03 + }, + { + "text": "Well now I have built up the so-called\nHuffman tree for this input text", + "start": 5028.24, + "duration": 4.45 + }, + { + "text": "and Huffman proposed the following.", + "start": 5032.69, + "duration": 2.34 + }, + { + "text": "To figure out what\npatterns of zeros and ones", + "start": 5035.03, + "duration": 2.15 + }, + { + "text": "to use to represent\nA, B, C, D, E, simply", + "start": 5037.18, + "duration": 3.28 + }, + { + "text": "follow the paths from the\nroot to each of those leaves.", + "start": 5040.46, + "duration": 4.19 + }, + { + "text": "So what is the encoding for A?", + "start": 5044.65, + "duration": 2.21 + }, + { + "text": "Start at the root and then\nlook for A-- 0, 1, so 0,", + "start": 5046.86, + "duration": 4.3 + }, + { + "text": "1 shall be my binary\nencoding for A in this world.", + "start": 5051.16, + "duration": 3.13 + }, + { + "text": "How about B?", + "start": 5054.29, + "duration": 1.19 + }, + { + "text": "0, 0, 0, 0 shall be my binary\nencoding for B. How about C?", + "start": 5055.48, + "duration": 5.762 + }, + { + "text": "0, 0, 0, 1 shall be my\nencoding for C. How about D?", + "start": 5061.242, + "duration": 6.218 + }, + { + "text": "0, 0, 1.", + "start": 5067.46, + "duration": 1.46 + }, + { + "text": "And beautifully, how about E?", + "start": 5068.92, + "duration": 2.292 + }, + { + "text": "1.", + "start": 5071.212, + "duration": 2.658 + }, + { + "text": "So, to summarize, what\nhas just happened?", + "start": 5073.87, + "duration": 2.99 + }, + { + "text": "E was the most popular letter, B and\nC, were the least popular letters.", + "start": 5076.86, + "duration": 3.44 + }, + { + "text": "And if we summarize these,\nyou'll see that, indeed,", + "start": 5080.3, + "duration": 3.54 + }, + { + "text": "B and C got pretty long encodings,\nbut E got the shortest encoding.", + "start": 5083.84, + "duration": 5.21 + }, + { + "text": "And it turns out\nmathematically you will now", + "start": 5089.05, + "duration": 2.88 + }, + { + "text": "have a system for encoding letters\nof the alphabet that is optimal,", + "start": 5091.93, + "duration": 4.82 + }, + { + "text": "that is you will use\nas few bits as possible", + "start": 5096.75, + "duration": 3.26 + }, + { + "text": "because you are biasing things\ntoward short representations", + "start": 5100.01, + "duration": 2.98 + }, + { + "text": "for popular letters, longer\nrepresentations for less", + "start": 5102.99, + "duration": 2.77 + }, + { + "text": "popular letters.", + "start": 5105.76, + "duration": 0.87 + }, + { + "text": "And mathematically this gives\nyou the most efficient encoding", + "start": 5106.63, + "duration": 3.11 + }, + { + "text": "for the original text without\nlosing any information.", + "start": 5109.74, + "duration": 5.39 + }, + { + "text": "In other words, now if Huffman\nwanted to send a secret message", + "start": 5115.13, + "duration": 3.17 + }, + { + "text": "to someone in class or over the\ninternet, he and that recipient", + "start": 5118.3, + "duration": 3.69 + }, + { + "text": "simply have to agree on\nthis scheme in advance", + "start": 5121.99, + "duration": 2.9 + }, + { + "text": "and then use these encoding\nto transmit those messages.", + "start": 5124.89, + "duration": 3.58 + }, + { + "text": "Because when someone receives 0, 1 or 0,\n0, 0, 0 or 0, 0, 0, 1 from Mr. Huffman,", + "start": 5128.47, + "duration": 8.86 + }, + { + "text": "they can use that same\nlook-up table, if you will,", + "start": 5137.33, + "duration": 2.45 + }, + { + "text": "and say, oh, he just sent me an A\nor, oh, he just sent me a B or C. So,", + "start": 5139.78, + "duration": 4.0 + }, + { + "text": "you have to know what\ntree Huffman built up.", + "start": 5143.78, + "duration": 2.49 + }, + { + "text": "And, indeed, what typically\nhappens in actual computers is", + "start": 5146.27, + "duration": 3.66 + }, + { + "text": "when you use Huffman coding\nto compress some body of text", + "start": 5149.93, + "duration": 3.51 + }, + { + "text": "like we just have here, you\nstore the compressed text", + "start": 5153.44, + "duration": 4.59 + }, + { + "text": "by storing your As, Bs, Cs,\nDs, and Es and other letters", + "start": 5158.03, + "duration": 2.69 + }, + { + "text": "using these new\nencoding, but you somehow", + "start": 5160.72, + "duration": 2.06 + }, + { + "text": "have to embed in that file in the\ncompressed file the tree itself", + "start": 5162.78, + "duration": 4.45 + }, + { + "text": "or this cheat sheet of encodings.", + "start": 5167.23, + "duration": 3.66 + }, + { + "text": "So, with compression-- maybe\nyou're compressing a Microsoft Word", + "start": 5170.89, + "duration": 3.28 + }, + { + "text": "file, or a dot TXT file,\nor any other type of file,", + "start": 5174.17, + "duration": 4.03 + }, + { + "text": "you have to store not just the\ncompressed text using these shorter", + "start": 5178.2, + "duration": 3.88 + }, + { + "text": "representation-- not 8-bit ASCII, but\nthese shorter representations-- but you", + "start": 5182.08, + "duration": 3.452 + }, + { + "text": "also somewhere, maybe at the beginning\nof the file or at the end of the file,", + "start": 5185.532, + "duration": 3.208 + }, + { + "text": "somewhere where someone else can find\nit, you need to store this mapping", + "start": 5188.74, + "duration": 3.0 + }, + { + "text": "or you need to store the tree\nitself in some digital form.", + "start": 5191.74, + "duration": 4.85 + }, + { + "text": "And so, it's possible\nby this logic that you", + "start": 5196.59, + "duration": 3.65 + }, + { + "text": "might try to compress\na really small file,", + "start": 5200.24, + "duration": 3.09 + }, + { + "text": "and that file could\nactually become bigger", + "start": 5203.33, + "duration": 2.76 + }, + { + "text": "because you're storing a\ntree inside the file to--", + "start": 5206.09, + "duration": 3.382 + }, + { + "text": "with which to recover\nthe original information.", + "start": 5209.472, + "duration": 1.958 + }, + { + "text": "Or better yet, most\nalgorithms or most actual", + "start": 5211.43, + "duration": 2.077 + }, + { + "text": "compression programs will realize,\nwait a minute, if compressing this file", + "start": 5213.507, + "duration": 3.083 + }, + { + "text": "is actually going to make it bigger,\nlet's just not compress it at all", + "start": 5216.59, + "duration": 2.916 + }, + { + "text": "and leave it alone untouched.", + "start": 5219.506, + "duration": 2.444 + }, + { + "text": "So, what if you take a compressed file\nand compress it again, and compress it", + "start": 5221.95, + "duration": 5.42 + }, + { + "text": "again, and compress it again?", + "start": 5227.37, + "duration": 2.89 + }, + { + "text": "A dangerous assumption to get into\nis, well, I could just maybe keep", + "start": 5230.26, + "duration": 3.59 + }, + { + "text": "compressing that video file again,\nand again, and again, and again,", + "start": 5233.85, + "duration": 3.55 + }, + { + "text": "and I can maybe compress my big\nessay, or my big video file,", + "start": 5237.4, + "duration": 3.21 + }, + { + "text": "or big music file to just maybe one bit.", + "start": 5240.61, + "duration": 2.38 + }, + { + "text": "Right?", + "start": 5242.99, + "duration": 0.5 + }, + { + "text": "That's the logical extreme,\njust keep compressing,", + "start": 5243.49, + "duration": 1.81 + }, + { + "text": "compressing, compressing, compressing.", + "start": 5245.3, + "duration": 1.583 + }, + { + "text": "But, of course, that\ncan't possibly make sense,", + "start": 5246.883, + "duration": 2.587 + }, + { + "text": "because if you compress some file\ndown to just a single bit, 0 or 1,", + "start": 5249.47, + "duration": 3.39 + }, + { + "text": "you've clearly thrown away information\nand can't possibly recover it all.", + "start": 5252.86, + "duration": 4.09 + }, + { + "text": "So, at some point, too, you've hit this\nlower bound on the size of the file", + "start": 5256.95, + "duration": 5.1 + }, + { + "text": "until you need to start throwing\nactual information away.", + "start": 5262.05, + "duration": 2.69 + }, + { + "text": "At some point, the file just has so\nmuch entropy, appears to be so random,", + "start": 5264.74, + "duration": 4.55 + }, + { + "text": "there really is no pattern to start\nto leverage to compress it further.", + "start": 5269.29, + "duration": 3.72 + }, + { + "text": "And so, there generally is some\nmaximum amount of compression", + "start": 5273.01, + "duration": 3.95 + }, + { + "text": "you can apply to something.", + "start": 5276.96, + "duration": 1.837 + }, + { + "text": "So, how would we represent this?", + "start": 5278.797, + "duration": 1.333 + }, + { + "text": "Let's whip out a C struct here.", + "start": 5280.13, + "duration": 1.42 + }, + { + "text": "So, this time each of the\nnodes in a Huffman tree", + "start": 5281.55, + "duration": 2.694 + }, + { + "text": "need a little something different.", + "start": 5284.244, + "duration": 1.416 + }, + { + "text": "They need, at least in the\nleaves, some kind of character", + "start": 5285.66, + "duration": 2.69 + }, + { + "text": "to remember the symbol.", + "start": 5288.35, + "duration": 0.96 + }, + { + "text": "Now, technically only the leaves\nneed to know what symbols they are,", + "start": 5289.31, + "duration": 2.64 + }, + { + "text": "so it's a little redundant\nto have this in every node,", + "start": 5291.95, + "duration": 2.25 + }, + { + "text": "but we can keep things simple and use\nthe same type of node for everything.", + "start": 5294.2, + "duration": 3.44 + }, + { + "text": "Float frequency, I could use an integer\nand treat it exactly as a percentage,", + "start": 5297.64, + "duration": 4.41 + }, + { + "text": "or I can use a float as the nodes\nwere with 0.1 and 0.45 and so forth,", + "start": 5302.05, + "duration": 4.29 + }, + { + "text": "and I'll call that frequency.", + "start": 5306.34, + "duration": 1.23 + }, + { + "text": "And then each of those nodes\nneeds a left child potentially", + "start": 5307.57, + "duration": 2.458 + }, + { + "text": "and a right child potentially.", + "start": 5310.028, + "duration": 1.292 + }, + { + "text": "And, again, I'll call\nthese things a node.", + "start": 5311.32, + "duration": 2.58 + }, + { + "text": "So, again, it's getting a little more\ninvolved this node, but it still allows", + "start": 5313.9, + "duration": 3.37 + }, + { + "text": "me to represent it ultimately in C.", + "start": 5317.27, + "duration": 6.29 + }, + { + "text": "And now, it's time to pursue lastly\nthe holy grail of data structures,", + "start": 5323.56, + "duration": 4.51 + }, + { + "text": "if you will.", + "start": 5328.07, + "duration": 0.91 + }, + { + "text": "Thus far, we've been solving\nproblems, creating new problems,", + "start": 5328.98, + "duration": 4.9 + }, + { + "text": "trying to solve those again.", + "start": 5333.88, + "duration": 1.17 + }, + { + "text": "And the problems we've been exploring\nthis week are things like dynamism,", + "start": 5335.05, + "duration": 3.222 + }, + { + "text": "if we want to be able to grow\nor shrink our data structure.", + "start": 5338.272, + "duration": 2.458 + }, + { + "text": "Malloc and pointers\ngive us that flexibility", + "start": 5340.73, + "duration": 2.22 + }, + { + "text": "but might cost us a bit\nmore time, because we", + "start": 5342.95, + "duration": 2.15 + }, + { + "text": "have to keep things\nsorted differently or we", + "start": 5345.1, + "duration": 2.53 + }, + { + "text": "have to follow all of those pointers.", + "start": 5347.63, + "duration": 2.06 + }, + { + "text": "And so, a lot of the algorithms\nwe've been discussing today", + "start": 5349.69, + "duration": 2.89 + }, + { + "text": "at least have-- like linear time,\nsearching, or inserting, or deleting", + "start": 5352.58, + "duration": 4.14 + }, + { + "text": "potentially like in a linked list.", + "start": 5356.72, + "duration": 1.96 + }, + { + "text": "Better still would be\nsomething logarithmic", + "start": 5358.68, + "duration": 1.87 + }, + { + "text": "like a balanced binary search tree,\nso still preserving that nice binary", + "start": 5360.55, + "duration": 5.31 + }, + { + "text": "aspect from week zero.", + "start": 5365.86, + "duration": 1.84 + }, + { + "text": "But the holy grail of a data\nstructure for its operations", + "start": 5367.7, + "duration": 2.77 + }, + { + "text": "is Big O of 1 so to\nspeak, constant time.", + "start": 5370.47, + "duration": 3.44 + }, + { + "text": "If you are searching, or inserting,\nor deleting, and somehow changing", + "start": 5373.91, + "duration": 5.33 + }, + { + "text": "a data structure, wouldn't it be\namazing if every darn operation", + "start": 5379.24, + "duration": 3.52 + }, + { + "text": "takes just one step, or\nmaybe two steps, or three", + "start": 5382.76, + "duration": 2.36 + }, + { + "text": "steps but a constant number of steps?", + "start": 5385.12, + "duration": 2.82 + }, + { + "text": "Now, it might be a little\nnaive for us to expect", + "start": 5387.94, + "duration": 2.0 + }, + { + "text": "that we can store an arbitrary\namount of data in some fancy way", + "start": 5389.94, + "duration": 3.47 + }, + { + "text": "that we get constant time,\nbut maybe just maybe if we're", + "start": 5393.41, + "duration": 3.2 + }, + { + "text": "clever we can get close to that.", + "start": 5396.61, + "duration": 2.18 + }, + { + "text": "So, let's introduce a step toward that.", + "start": 5398.79, + "duration": 2.81 + }, + { + "text": "It turns out there exists in this\nworld things called hash tables.", + "start": 5401.6, + "duration": 3.66 + }, + { + "text": "And a hash table can be\nimplemented in any number of ways,", + "start": 5405.26, + "duration": 2.75 + }, + { + "text": "but you can think of it\nreally as just an array.", + "start": 5408.01, + "duration": 2.08 + }, + { + "text": "So, for instance, this might be a way of\nrepresenting a hash table called table,", + "start": 5410.09, + "duration": 5.442 + }, + { + "text": "whose first location is bracket zero\nand whose last location is bracket", + "start": 5415.532, + "duration": 2.958 + }, + { + "text": "n minus 1 for however long this is.", + "start": 5418.49, + "duration": 1.742 + }, + { + "text": "And I just left it as blanks.", + "start": 5420.232, + "duration": 1.208 + }, + { + "text": "I don't even know what this\nhash table might want to store.", + "start": 5421.44, + "duration": 1.77 + }, + { + "text": "It could be numbers, it could\nbe names, it could be letters,", + "start": 5423.21, + "duration": 1.63 + }, + { + "text": "it could be anything we want.", + "start": 5424.84, + "duration": 1.91 + }, + { + "text": "But hash table has this\nnice theoretical property", + "start": 5426.75, + "duration": 3.92 + }, + { + "text": "that if well-designed\nand thought through,", + "start": 5430.67, + "duration": 2.64 + }, + { + "text": "you can maybe just maybe get\nconstant look up time in it.", + "start": 5433.31, + "duration": 4.52 + }, + { + "text": "And let's do a simple\nexample of a hash table.", + "start": 5437.83, + "duration": 2.22 + }, + { + "text": "Hash tables are often nicely\nthought of as buckets,", + "start": 5440.05, + "duration": 2.79 + }, + { + "text": "so we borrowed these from the loading\ndock outside just a little moment ago,", + "start": 5442.84, + "duration": 3.36 + }, + { + "text": "and we've attached thanks to\nArturo some of these signs to them.", + "start": 5446.2, + "duration": 5.27 + }, + { + "text": "This is going to be Z, so\nI'll just put this over here.", + "start": 5451.47, + "duration": 3.97 + }, + { + "text": "This is going to be C, so I'll put\nthis over here, and B here, and A.", + "start": 5455.44, + "duration": 5.925 + }, + { + "text": "And we thought we might get chased\naway by the folks on the loading dock,", + "start": 5461.365, + "duration": 4.025 + }, + { + "text": "so we didn't bother getting D\nthrough Y, So we'll just pretend", + "start": 5465.39, + "duration": 2.98 + }, + { + "text": "that we have 26 such buckets here.", + "start": 5468.37, + "duration": 2.01 + }, + { + "text": "And suppose that the goal\nat hand is-- I don't know,", + "start": 5470.38, + "duration": 3.482 + }, + { + "text": "it's like at the end\nof an exam, so we've", + "start": 5473.862, + "duration": 1.708 + }, + { + "text": "got our old blue books that a\nclass might use for students", + "start": 5475.57, + "duration": 3.23 + }, + { + "text": "writing essays in some class.", + "start": 5478.8, + "duration": 1.67 + }, + { + "text": "And it's time for the students\nto come submit their blue books.", + "start": 5480.47, + "duration": 3.16 + }, + { + "text": "Now, we could just collect them all\nand make a big mess as would generally", + "start": 5483.63, + "duration": 3.28 + }, + { + "text": "be the case, or we can be a little\nmore methodical to at least make", + "start": 5486.91, + "duration": 3.24 + }, + { + "text": "our jobs easier.", + "start": 5490.15, + "duration": 1.384 + }, + { + "text": "Now, at the end of the day, what's going\nto be interesting about hash tables", + "start": 5491.534, + "duration": 3.166 + }, + { + "text": "is that there's going\nto be this distinction", + "start": 5494.7, + "duration": 1.833 + }, + { + "text": "between actual benefits and\ntheoretical benefit, or lack thereof.", + "start": 5496.533, + "duration": 3.317 + }, + { + "text": "So, we'll come to that in just a\nmoment, but here's A, B, C, D, and Z.", + "start": 5499.85, + "duration": 4.181 + }, + { + "text": "And you know what?", + "start": 5504.031, + "duration": 0.749 + }, + { + "text": "I just am going to ask the students\nin this class-- there are so", + "start": 5504.78, + "duration": 1.99 + }, + { + "text": "many people in the room\nafter an exam, I just", + "start": 5506.77, + "duration": 2.27 + }, + { + "text": "want them to at least make\nmy life 1/26 as difficult", + "start": 5509.04, + "duration": 4.96 + }, + { + "text": "by putting all the As over there,\nall the Bs here, all the Cs here,", + "start": 5514.0, + "duration": 3.0 + }, + { + "text": "all the Zs here, so that I don't have\na massive mountain of As through Zs", + "start": 5517.0, + "duration": 4.66 + }, + { + "text": "that I have to sift\nthrough individually.", + "start": 5521.66, + "duration": 2.12 + }, + { + "text": "It would just be nice if\nthey do the first pass", + "start": 5523.78, + "duration": 2.22 + }, + { + "text": "of bucketizing the values based on\nthe first letter in their last name.", + "start": 5526.0, + "duration": 4.13 + }, + { + "text": "In other words, my hash\nfunction, my algorithm,", + "start": 5530.13, + "duration": 3.48 + }, + { + "text": "is going to be for each student\nto consider his or her last name,", + "start": 5533.61, + "duration": 4.09 + }, + { + "text": "look at the first letter they're\nin, and put his or her exam", + "start": 5537.7, + "duration": 3.22 + }, + { + "text": "in the appropriate bucket.", + "start": 5540.92, + "duration": 1.38 + }, + { + "text": "So, here is, for instance,\nsomeone with the letter", + "start": 5542.3, + "duration": 3.34 + }, + { + "text": "C. I'm going to put\nthat blue book in here.", + "start": 5545.64, + "duration": 2.63 + }, + { + "text": "Here's someone with the letter\nA. That one's going to go here.", + "start": 5548.27, + "duration": 2.62 + }, + { + "text": "Letter Z?", + "start": 5550.89, + "duration": 0.746 + }, + { + "text": "This one's going to go over here.", + "start": 5551.636, + "duration": 1.374 + }, + { + "text": "Letter B?", + "start": 5553.01, + "duration": 1.11 + }, + { + "text": "This is going to go over here.", + "start": 5554.12, + "duration": 1.25 + }, + { + "text": "C, and B, and F-- Z, I mean, and all of\n[? the ?] [? letters ?] of the alphabet", + "start": 5555.37, + "duration": 6.8 + }, + { + "text": "in between.", + "start": 5562.17, + "duration": 0.78 + }, + { + "text": "So, hashing really has this\nvisual and conceptual equivalence", + "start": 5562.95, + "duration": 3.774 + }, + { + "text": "of putting something in this bucket,\nputting something in that bucket,", + "start": 5566.724, + "duration": 2.916 + }, + { + "text": "putting something in this\nother bucket, ultimately", + "start": 5569.64, + "duration": 2.083 + }, + { + "text": "bucketizing all of your elements.", + "start": 5571.723, + "duration": 2.147 + }, + { + "text": "And you can think of this,\nfrankly, as just an array,", + "start": 5573.87, + "duration": 2.21 + }, + { + "text": "but it's not just an\narray with one spot.", + "start": 5576.08, + "duration": 1.72 + }, + { + "text": "It looks I can stack multiple\nnumbers or multiple blue books inside", + "start": 5577.8, + "duration": 5.04 + }, + { + "text": "of that array.", + "start": 5582.84, + "duration": 0.71 + }, + { + "text": "So, we're going to have to come\nback to that, because this clearly", + "start": 5583.55, + "duration": 1.55 + }, + { + "text": "can't be an array.", + "start": 5585.1, + "duration": 0.75 + }, + { + "text": "Normally, the array would be filled\nthe moment you put one value in it.", + "start": 5585.85, + "duration": 3.2 + }, + { + "text": "But this hashing is\nthe interesting part.", + "start": 5589.05, + "duration": 2.93 + }, + { + "text": "The juicy ingredient today is if I take\ninto account as input what it is I'm", + "start": 5591.98, + "duration": 4.87 + }, + { + "text": "trying to store, use some piece of that\ninformation to decide where to put it,", + "start": 5596.85, + "duration": 4.66 + }, + { + "text": "that's an algorithm, because\nI can repeat that process,", + "start": 5601.51, + "duration": 2.85 + }, + { + "text": "so long as it's not random.", + "start": 5604.36, + "duration": 1.27 + }, + { + "text": "You go over here, you go over here.", + "start": 5605.63, + "duration": 1.51 + }, + { + "text": "That's amazing.", + "start": 5607.14, + "duration": 1.04 + }, + { + "text": "Wow, OK, pushing my luck.", + "start": 5608.18, + "duration": 2.84 + }, + { + "text": "OK, so I'm not just randomly\nputting things here.", + "start": 5611.02, + "duration": 2.644 + }, + { + "text": "I'm actually giving some thought\nas to where I'm putting things,", + "start": 5613.664, + "duration": 2.666 + }, + { + "text": "and that makes the algorithm\ndeterministic, repeatable, predictable", + "start": 5616.33, + "duration": 4.54 + }, + { + "text": "so that if you insert something\nnow, you can absolutely", + "start": 5620.87, + "duration": 3.38 + }, + { + "text": "find it if present later.", + "start": 5624.25, + "duration": 2.37 + }, + { + "text": "Unfortunately, if our\nhash table does look", + "start": 5626.62, + "duration": 2.03 + }, + { + "text": "like this, just a simple array from\nbracket 0 to bracket n minus 1 dot,", + "start": 5628.65, + "duration": 4.12 + }, + { + "text": "dot, dot in between,\nand it's just an array", + "start": 5632.77, + "duration": 2.33 + }, + { + "text": "for integers or an array for strings or\nwhatever, once you put something here,", + "start": 5635.1, + "duration": 5.59 + }, + { + "text": "or here, or here, that's it.", + "start": 5640.69, + "duration": 3.14 + }, + { + "text": "There is no more room to\nput another element there", + "start": 5643.83, + "duration": 2.64 + }, + { + "text": "wide as I might have drawn this table.", + "start": 5646.47, + "duration": 1.94 + }, + { + "text": "If there's an int there, that's it.", + "start": 5648.41, + "duration": 1.98 + }, + { + "text": "So, what could you do?", + "start": 5650.39, + "duration": 2.12 + }, + { + "text": "Suppose that you do have an\narray structure like this,", + "start": 5652.51, + "duration": 4.06 + }, + { + "text": "and that is unacceptable.", + "start": 5656.57, + "duration": 3.47 + }, + { + "text": "You have a whole bunch of elements\nhere and this table looks like this,", + "start": 5660.04, + "duration": 6.96 + }, + { + "text": "and you consider this table like this.", + "start": 5667.0, + "duration": 3.62 + }, + { + "text": "And maybe it's just where you're\nsupposed to take attendance or put", + "start": 5670.62, + "duration": 3.04 + }, + { + "text": "people's names.", + "start": 5673.66, + "duration": 0.914 + }, + { + "text": "So, if you say, oh, Alice is here today.", + "start": 5674.574, + "duration": 1.666 + }, + { + "text": "Let me go ahead and hash on Alice's\nname and put her where the As should go.", + "start": 5676.24, + "duration": 4.225 + }, + { + "text": "Oh, Zoe is here, Z-O-E, so\nwe'll put her down there.", + "start": 5680.465, + "duration": 5.685 + }, + { + "text": "And then who else?", + "start": 5686.15, + "duration": 1.83 + }, + { + "text": "Alex is here.", + "start": 5687.98, + "duration": 0.77 + }, + { + "text": "Dammit, Alex, no room for\nyou in our hash table,", + "start": 5688.75, + "duration": 3.34 + }, + { + "text": "because Alice is already there.", + "start": 5692.09, + "duration": 1.38 + }, + { + "text": "This is stupid.", + "start": 5693.47, + "duration": 0.78 + }, + { + "text": "If we have data we want to\ninsert into this data structure,", + "start": 5694.25, + "duration": 2.47 + }, + { + "text": "it would seem that I have 24 available\nspots into which I could put Alex", + "start": 5696.72, + "duration": 6.22 + }, + { + "text": "and yet I'm just stubbornly trying\nto put him where only the As belong.", + "start": 5702.94, + "duration": 3.58 + }, + { + "text": "So, why don't I, in this kind of\nscenario, I need to put Alex in here.", + "start": 5706.52, + "duration": 3.85 + }, + { + "text": "I clearly have space.", + "start": 5710.37, + "duration": 0.997 + }, + { + "text": "You know what?", + "start": 5711.367, + "duration": 0.583 + }, + { + "text": "Let me just probe the array looking\nfor the first available spot.", + "start": 5711.95, + "duration": 2.91 + }, + { + "text": "OK, Alex, you're just going to go here,\nand if someone else like Erin appears,", + "start": 5714.86, + "duration": 5.43 + }, + { + "text": "fine.", + "start": 5720.29, + "duration": 0.5 + }, + { + "text": "You just are going to go over here.", + "start": 5720.79, + "duration": 2.29 + }, + { + "text": "So, you try to put the letter\nAs where you want them to go,", + "start": 5723.08, + "duration": 3.77 + }, + { + "text": "but if there's already\nsomeone there, just", + "start": 5726.85, + "duration": 1.77 + }, + { + "text": "probe deeper into the data structure\nlooking for the first available slot.", + "start": 5728.62, + "duration": 4.07 + }, + { + "text": "So, this is a general technique in\nprogramming called linear probing", + "start": 5732.69, + "duration": 3.35 + }, + { + "text": "whereby you have a data structure.", + "start": 5736.04, + "duration": 1.68 + }, + { + "text": "If you hash to some location like\nthe letter A there's a collision,", + "start": 5737.72, + "duration": 3.82 + }, + { + "text": "something is there, you probe\nfurther in the data structure just", + "start": 5741.54, + "duration": 3.0 + }, + { + "text": "looking for some place you can put it.", + "start": 5744.54, + "duration": 2.0 + }, + { + "text": "So, you get close to constant\ntime decision-making.", + "start": 5746.54, + "duration": 3.04 + }, + { + "text": "Put A here, put Z here.", + "start": 5749.58, + "duration": 1.382 + }, + { + "text": "And because this is an array, you have\nrandom access with your square bracket", + "start": 5750.962, + "duration": 3.208 + }, + { + "text": "notation, but if you have lots of As\nand not too many Zs, or Bs, or Ds,", + "start": 5754.17, + "duration": 5.02 + }, + { + "text": "it's possible this approach could\ndevolve back into linear time.", + "start": 5759.19, + "duration": 5.43 + }, + { + "text": "So, in the ideal we have one\nA, one B, one Z, and everything", + "start": 5764.62, + "duration": 3.45 + }, + { + "text": "in between, that's constant time.", + "start": 5768.07, + "duration": 1.66 + }, + { + "text": "We have our holy grail, constant\ntime operations for a data structure,", + "start": 5769.73, + "duration": 4.91 + }, + { + "text": "but not if we want to support\ninsertion of other elements,", + "start": 5774.64, + "duration": 3.11 + }, + { + "text": "even those that hash\nto the same location.", + "start": 5777.75, + "duration": 3.0 + }, + { + "text": "So, what's the fix?", + "start": 5780.75, + "duration": 1.09 + }, + { + "text": "Well, if the problem\nis that we've already", + "start": 5781.84, + "duration": 1.96 + }, + { + "text": "made room-- we already have used\nthis space for Alice, you know what?", + "start": 5783.8, + "duration": 3.56 + }, + { + "text": "If we need to put someone else\nhere, why don't we just create", + "start": 5787.36, + "duration": 3.83 + }, + { + "text": "dynamically some more space?", + "start": 5791.19, + "duration": 2.89 + }, + { + "text": "We have malloc now.", + "start": 5794.08, + "duration": 1.13 + }, + { + "text": "We have dynamic memory allocation.", + "start": 5795.21, + "duration": 1.66 + }, + { + "text": "Why don't we just extend our data\nstructure laterally, horizontally--", + "start": 5796.87, + "duration": 5.44 + }, + { + "text": "artistically here-- so that, yes,\nyou try to go to that first location.", + "start": 5802.31, + "duration": 3.86 + }, + { + "text": "But if there's multiple people\nthat are meant to go there,", + "start": 5806.17, + "duration": 2.79 + }, + { + "text": "multiple values, go ahead\nand just link them together,", + "start": 5808.96, + "duration": 3.09 + }, + { + "text": "thereby merging the idea of a hash table\nand a linked list with a data structure", + "start": 5812.05, + "duration": 4.4 + }, + { + "text": "that might look like this.", + "start": 5816.45, + "duration": 1.43 + }, + { + "text": "So, this is an example, somewhat\narbitrary, of 31 days out of a month.", + "start": 5817.88, + "duration": 3.659 + }, + { + "text": "And if you actually hash\non people's birth dates,", + "start": 5821.539, + "duration": 2.041 + }, + { + "text": "as I think this author did, you\ncan think of your hash table", + "start": 5823.58, + "duration": 4.41 + }, + { + "text": "still as an array.", + "start": 5827.99, + "duration": 1.51 + }, + { + "text": "But that array does not store\nstrings, it does not store integers.", + "start": 5829.5, + "duration": 3.13 + }, + { + "text": "It only stores pointers, 31 total\nin this case-- some of which", + "start": 5832.63, + "duration": 4.15 + }, + { + "text": "might be null, per the\nvertical diagonal slash--", + "start": 5836.78, + "duration": 3.14 + }, + { + "text": "but those pointers in turn point\nto the beginning of linked lists.", + "start": 5839.92, + "duration": 4.02 + }, + { + "text": "So, if multiple people were born\non the fourth of some month,", + "start": 5843.94, + "duration": 2.78 + }, + { + "text": "you would put J. Adams and W. Floyd\nin a linked list at that location.", + "start": 5846.72, + "duration": 4.22 + }, + { + "text": "If both Aaron, and Alex, and Alice,\nand other students with the names A", + "start": 5850.94, + "duration": 4.89 + }, + { + "text": "all belong at that first location\nin my previous table, that's fine.", + "start": 5855.83, + "duration": 4.51 + }, + { + "text": "Just string them together\nwith a linked list.", + "start": 5860.34, + "duration": 2.79 + }, + { + "text": "Much like with these buckets, at the end\nof the day, I'm still creating piles.", + "start": 5863.13, + "duration": 4.865 + }, + { + "text": "And at the end of the day, I still have\nto go through them all, ultimately.", + "start": 5867.995, + "duration": 3.125 + }, + { + "text": "But each of these piles\nis 1/26 the size of it", + "start": 5871.12, + "duration": 3.63 + }, + { + "text": "would have been if everyone just\ncame up at the end of the exam", + "start": 5874.75, + "duration": 3.2 + }, + { + "text": "and just piled all their\nbooks in the same pile.", + "start": 5877.95, + "duration": 2.23 + }, + { + "text": "So, whereas, these algorithms\nat the end of the day", + "start": 5880.18, + "duration": 2.32 + }, + { + "text": "are still devolving, if you\nwill-- or these data structures", + "start": 5882.5, + "duration": 3.22 + }, + { + "text": "are devolving, if you will,\ninto linear time operations,", + "start": 5885.72, + "duration": 2.98 + }, + { + "text": "in the worst case if these things\njust get really long and stringy,", + "start": 5888.7, + "duration": 3.12 + }, + { + "text": "at least in actuality they might be as\ngood as 1/31 as long or 1/26 as tall.", + "start": 5891.82, + "duration": 8.32 + }, + { + "text": "And so, now there's this\ndichotomy in this week five", + "start": 5900.14, + "duration": 3.47 + }, + { + "text": "of asymptotic running time,\nthe theoretical running", + "start": 5903.61, + "duration": 2.8 + }, + { + "text": "time that we've really been belaboring\nand the actual running time.", + "start": 5906.41, + "duration": 3.45 + }, + { + "text": "Just because something is n\nsquared does not mean it's bad.", + "start": 5909.86, + "duration": 2.49 + }, + { + "text": "If there's only a few\nelements, n squared is great.", + "start": 5912.35, + "duration": 2.124 + }, + { + "text": "It's going to happen super fast\nif your computer is 1 gigahertz,", + "start": 5914.474, + "duration": 2.836 + }, + { + "text": "or 2 gigahertz, or faster these days.", + "start": 5917.31, + "duration": 1.799 + }, + { + "text": "N squared in and of itself isn't bad.", + "start": 5919.109, + "duration": 1.541 + }, + { + "text": "It just gets really bad\nwhen your data gets large.", + "start": 5920.65, + "duration": 3.1 + }, + { + "text": "But in practice, even n squared divided\nby 2 is actually better than n squared.", + "start": 5923.75, + "duration": 6.82 + }, + { + "text": "So, a couple weeks ago when I was\nsaying don't worry about the lower order", + "start": 5930.57, + "duration": 3.85 + }, + { + "text": "terms, the constant terms,\nfocus only on n squared", + "start": 5934.42, + "duration": 3.53 + }, + { + "text": "and not n or anything you're dividing\nby, that's fine theoretically,", + "start": 5937.95, + "duration": 3.66 + }, + { + "text": "but in actuality you're going\nto feel that kind of difference.", + "start": 5941.61, + "duration": 4.27 + }, + { + "text": "So, here's one last data structure\nthat we'll call a trie-- so trie,", + "start": 5945.88, + "duration": 5.06 + }, + { + "text": "short for retrieval somehow,\nT-R-I-E, but pronounced try.", + "start": 5950.94, + "duration": 4.39 + }, + { + "text": "And this one is cool\nbecause this now is really", + "start": 5955.33, + "duration": 4.22 + }, + { + "text": "like a weird offspring of these\ndata structures from today.", + "start": 5959.55, + "duration": 2.97 + }, + { + "text": "But it's a tree each of\nwhose nodes is in an array.", + "start": 5962.52, + "duration": 5.09 + }, + { + "text": "And a trie is really good for storing\nwords like words in a dictionary.", + "start": 5967.61, + "duration": 4.1 + }, + { + "text": "Indeed, one of the problem\nI had for you in CS50", + "start": 5971.71, + "duration": 2.48 + }, + { + "text": "is going to be to implement a spell\nchecker, which effectively means build", + "start": 5974.19, + "duration": 3.38 + }, + { + "text": "a dictionary in memory,\nand you'll be challenged", + "start": 5977.57, + "duration": 2.29 + }, + { + "text": "to spell check words as\nfast as you can, storing", + "start": 5979.86, + "duration": 2.62 + }, + { + "text": "as many as 100,000 English words\nsomehow in your computer's memory", + "start": 5982.48, + "duration": 3.009 + }, + { + "text": "and answering questions of the form\nis this a word, is this a word,", + "start": 5985.489, + "duration": 2.791 + }, + { + "text": "is this a word.", + "start": 5988.28, + "duration": 1.2 + }, + { + "text": "That's, after all,\nwhat spell checking is.", + "start": 5989.48, + "duration": 1.98 + }, + { + "text": "So, a trie is kind of interesting in\nthat-- and this is an excerpt of an,", + "start": 5991.46, + "duration": 5.56 + }, + { + "text": "artist's rendition\nthere of-- the root node", + "start": 5997.02, + "duration": 2.56 + }, + { + "text": "here represents this-- is this\nrectangle here, and that of course", + "start": 5999.58, + "duration": 5.11 + }, + { + "text": "looks like an array.", + "start": 6004.69, + "duration": 1.28 + }, + { + "text": "And notice what's implicit in this.", + "start": 6005.97, + "duration": 2.91 + }, + { + "text": "If this is location A\nand this is location Z,", + "start": 6008.88, + "duration": 2.79 + }, + { + "text": "the author here has just\ndecided to only show you", + "start": 6011.67, + "duration": 2.05 + }, + { + "text": "those letters that matter\nfor the sake of discussion.", + "start": 6013.72, + "duration": 2.22 + }, + { + "text": "But the fact that the M\nlocation here is not blank", + "start": 6015.94, + "duration": 4.57 + }, + { + "text": "means there's a pointer there.", + "start": 6020.51, + "duration": 1.28 + }, + { + "text": "Indeed, what are these arrays?", + "start": 6021.79, + "duration": 1.249 + }, + { + "text": "They are arrays of\npointers to other nodes.", + "start": 6023.039, + "duration": 2.711 + }, + { + "text": "So, the fact that M is not null and it\nleads to this node, and notice that A", + "start": 6025.75, + "duration": 4.52 + }, + { + "text": "is not null and it leads to this node,\nand then this node, and then this node.", + "start": 6030.27, + "duration": 3.26 + }, + { + "text": "And this is where the artist\nis just taking some liberties.", + "start": 6033.53, + "duration": 2.04 + }, + { + "text": "This tree would be monstrously\nwide, because all of these arrays", + "start": 6035.57, + "duration": 2.666 + }, + { + "text": "are so darn wide, so he or she is just\nshowing you the width-- or the element", + "start": 6038.236, + "duration": 4.734 + }, + { + "text": "that we care about, M, A, X, W, E, L,\nL, and then some special sentinel symbol", + "start": 6042.97, + "duration": 6.94 + }, + { + "text": "delta, but it could be anything.", + "start": 6049.91, + "duration": 1.47 + }, + { + "text": "This is null, really.", + "start": 6051.38, + "duration": 1.57 + }, + { + "text": "This is how using a trie a programmer\ncould store the name Maxwell,", + "start": 6052.95, + "duration": 6.11 + }, + { + "text": "M-A-X-W-E-L-L, by simply leaving\nlittle bread crumbs, if you will,", + "start": 6059.06, + "duration": 5.34 + }, + { + "text": "from one node to another such that\neach of those elements in the array is", + "start": 6064.4, + "duration": 5.08 + }, + { + "text": "a pointer to another array.", + "start": 6069.48, + "duration": 1.75 + }, + { + "text": "And if you keep following these\npointers, following the bread crumbs", + "start": 6071.23, + "duration": 3.05 + }, + { + "text": "and you eventually find yourself\nat this special sentinel value--", + "start": 6074.28, + "duration": 3.61 + }, + { + "text": "and actually, it wouldn't be null, it\nwould be like a Boolean saying true.", + "start": 6077.89, + "duration": 3.74 + }, + { + "text": "This is a word you can just by storing\na single yes or no at this location way", + "start": 6081.63, + "duration": 5.76 + }, + { + "text": "down here, implicitly reveal that\nM-A-X-W-E-L was in fact a word.", + "start": 6087.39, + "duration": 7.995 + }, + { + "text": "Let's follow another.", + "start": 6095.385, + "duration": 0.875 + }, + { + "text": "So, let's say Turing,\nT-U-R-I-N-G, check, Boolean true.", + "start": 6096.26, + "duration": 10.88 + }, + { + "text": "Turing is in this dictionary as well.", + "start": 6107.14, + "duration": 2.42 + }, + { + "text": "So, if there are bread crumbs that\nlead to null, that word is not in here.", + "start": 6109.56, + "duration": 3.9 + }, + { + "text": "So, apparently there is no\nnames starting with A through L,", + "start": 6113.46, + "duration": 4.3 + }, + { + "text": "and there is no one after U through\nZ or some of the letters in between,", + "start": 6117.76, + "duration": 3.99 + }, + { + "text": "because those pointers are\nimplicitly and pictorially null.", + "start": 6121.75, + "duration": 3.23 + }, + { + "text": "But let's consider, then, what is the\nrunning time of inserting or looking up", + "start": 6124.98, + "duration": 4.92 + }, + { + "text": "a name and [? in a trie? ?] Thus\nfar, pretty much all of the data", + "start": 6129.9, + "duration": 4.22 + }, + { + "text": "structures we've talked about\nhave pretty slow running times,", + "start": 6134.12, + "duration": 3.86 + }, + { + "text": "linear in the worst case.", + "start": 6137.98, + "duration": 1.84 + }, + { + "text": "So, if we used an array\nto store people's names", + "start": 6139.82, + "duration": 2.55 + }, + { + "text": "or we used to linked list to store\npeople's names, in the worst case", + "start": 6142.37, + "duration": 3.152 + }, + { + "text": "we had linear running time, unless\nmaybe we sort things, but even", + "start": 6145.522, + "duration": 2.708 + }, + { + "text": "then that costs us some time.", + "start": 6148.23, + "duration": 1.208 + }, + { + "text": "So, linear may be logarithmic\nwas the best we could do.", + "start": 6149.438, + "duration": 3.192 + }, + { + "text": "And even with a hash\ntable, whereby, maybe we", + "start": 6152.63, + "duration": 2.75 + }, + { + "text": "store Maxwell at the M\nlocation in our table,", + "start": 6155.38, + "duration": 2.65 + }, + { + "text": "he might still have a link list of\na whole bunch of other M people.", + "start": 6158.03, + "duration": 3.49 + }, + { + "text": "That, again, can devolve into\nsomething linear, a linear linked list.", + "start": 6161.52, + "duration": 3.99 + }, + { + "text": "But what about a hash table?", + "start": 6165.51, + "duration": 2.13 + }, + { + "text": "To answer the question is Maxwell in\na trie-- sorry, what about to trie?", + "start": 6167.64, + "duration": 5.14 + }, + { + "text": "To answer the question is\nMaxwell in a trie, what do we do?", + "start": 6172.78, + "duration": 3.6 + }, + { + "text": "We start at the root and we follow\nthe pointer that represents m,", + "start": 6176.38, + "duration": 3.96 + }, + { + "text": "and then we follow the pointer there\nthat represents A, then X, W, E, L, L,", + "start": 6180.34, + "duration": 4.31 + }, + { + "text": "and we look for at the end of that\nseries of steps a true false value.", + "start": 6184.65, + "duration": 3.73 + }, + { + "text": "And if it's true, yes, Maxwell is here.", + "start": 6188.38, + "duration": 3.15 + }, + { + "text": "What about Turing?", + "start": 6191.53, + "duration": 0.89 + }, + { + "text": "Well, we start at the\npointer that represents", + "start": 6192.42, + "duration": 1.875 + }, + { + "text": "T, then U, R, I, N G, then check.", + "start": 6194.295, + "duration": 1.865 + }, + { + "text": "Oh, true.", + "start": 6196.16, + "duration": 1.43 + }, + { + "text": "Turing is in there.", + "start": 6197.59, + "duration": 1.27 + }, + { + "text": "Let's look for David.", + "start": 6198.86, + "duration": 1.22 + }, + { + "text": "No, false.", + "start": 6200.08, + "duration": 1.27 + }, + { + "text": "There's not even a pointer there.", + "start": 6201.35, + "duration": 1.52 + }, + { + "text": "David is not in this dictionary.", + "start": 6202.87, + "duration": 2.08 + }, + { + "text": "So, how many steps did that each take?", + "start": 6204.95, + "duration": 1.95 + }, + { + "text": "To tell whether Maxwell\nwas in the dictionary,", + "start": 6206.9, + "duration": 2.2 + }, + { + "text": "was M-A-X-W-E-L-L and then look at\nthe Boolean, so that was eight steps.", + "start": 6209.1, + "duration": 5.51 + }, + { + "text": "And to look up Turing was\nT-U-R-I-N-G. And then that Boolean,", + "start": 6214.61, + "duration": 4.84 + }, + { + "text": "that was seven steps.", + "start": 6219.45, + "duration": 2.91 + }, + { + "text": "Those numbers have nothing to do with\nhow many words are already in the trie.", + "start": 6222.36, + "duration": 5.66 + }, + { + "text": "There might be-- and there's\nonly a couple dozen here--", + "start": 6228.02, + "duration": 2.94 + }, + { + "text": "there are a dozen or so here-- there\nmight be thousands of actual words", + "start": 6230.96, + "duration": 3.48 + }, + { + "text": "in this dictionary, but we're still\ngoing to find Alan Turing by way", + "start": 6234.44, + "duration": 4.15 + }, + { + "text": "of T-U-R-I-N-G Boolean seven steps,\nand M-A-X-W-E-L-L Boolean, eight steps.", + "start": 6238.59, + "duration": 7.74 + }, + { + "text": "It doesn't matter how many other\ndata elements are in this trie.", + "start": 6246.33, + "duration": 4.21 + }, + { + "text": "And that's what's\npowerful, because if there", + "start": 6250.54, + "duration": 2.48 + }, + { + "text": "is an upper bound on the\nnumber of letters in an English", + "start": 6253.02, + "duration": 2.56 + }, + { + "text": "word-- which is kind of true.", + "start": 6255.58, + "duration": 2.14 + }, + { + "text": "I've rarely typed words\nthat are longer than I don't", + "start": 6257.72, + "duration": 2.62 + }, + { + "text": "know 10 characters, 15 characters.", + "start": 6260.34, + "duration": 1.81 + }, + { + "text": "At some point there\nmight exist these words,", + "start": 6262.15, + "duration": 2.5 + }, + { + "text": "but no one actually says\nor types these words.", + "start": 6264.65, + "duration": 2.63 + }, + { + "text": "Those are effectively constants.", + "start": 6267.28, + "duration": 1.63 + }, + { + "text": "The maximum length of a word in\nEnglish is surely some constant,", + "start": 6268.91, + "duration": 3.096 + }, + { + "text": "because there is one\nword that's the longest.", + "start": 6272.006, + "duration": 1.874 + }, + { + "text": "That's a constant value,\nwhich means inserting a name,", + "start": 6273.88, + "duration": 3.18 + }, + { + "text": "or searching for a name, or\nremoving a name from a trie", + "start": 6277.06, + "duration": 4.26 + }, + { + "text": "does depend on the length\nof the name, but it does not", + "start": 6281.32, + "duration": 2.7 + }, + { + "text": "depend on how many pieces of data\nare already in the data structure.", + "start": 6284.02, + "duration": 3.95 + }, + { + "text": "And as such, it is constant time.", + "start": 6287.97, + "duration": 4.05 + }, + { + "text": "So, now in C, we have a\nwhole bunch of new syntax", + "start": 6292.02, + "duration": 2.3 + }, + { + "text": "with which to represent data\nstructures, namely actual structs in C,", + "start": 6294.32, + "duration": 3.315 + }, + { + "text": "and we have pointers, and\nwe have malloc with which", + "start": 6297.635, + "duration": 2.125 + }, + { + "text": "we can build more interesting\nshapes, if you will, in memory.", + "start": 6299.76, + "duration": 2.99 + }, + { + "text": "And we now have a number of abstract\ndata types and actual data structures", + "start": 6302.75, + "duration": 4.1 + }, + { + "text": "we can build using these ingredients\nwith which we can now solve problems", + "start": 6306.85, + "duration": 4.142 + }, + { + "text": "that are going to demand all the more\nresources, all the more time, all", + "start": 6310.992, + "duration": 2.958 + }, + { + "text": "the more space, in which case\nefficiency and good design", + "start": 6313.95, + "duration": 3.24 + }, + { + "text": "is going to be ever more important.", + "start": 6317.19, + "duration": 2.3 + }, + { + "text": "All this and more next time.", + "start": 6319.49, + "duration": 2.34 + }, + { + "text": " ", + "start": 6321.83, + "duration": 4.394 + }, + { + "text": "AUDIENCE: She thought she\nwas doing the right thing.", + "start": 6326.224, + "duration": 2.166 + }, + { + "text": " ", + "start": 6328.39, + "duration": 4.975 + }, + { + "text": "[AUDIO PLAYBACK]", + "start": 6333.365, + "duration": 2.85 + }, + { + "text": "-Tell me more.", + "start": 6336.215, + "duration": 2.375 + }, + { + "text": "-David was sure it had to be the\nmuppet, something called muppet mode,", + "start": 6338.59, + "duration": 6.7 + }, + { + "text": "but the pressure was too much.", + "start": 6345.29, + "duration": 2.86 + }, + { + "text": "-This is Mario in muppet mode.", + "start": 6348.15, + "duration": 1.37 + }, + { + "text": "Take 23.", + "start": 6349.52, + "duration": 0.71 + }, + { + "text": " ", + "start": 6350.23, + "duration": 4.99 + }, + { + "text": "[HONKING]", + "start": 6355.22, + "duration": 2.45 + }, + { + "text": " ", + "start": 6357.67, + "duration": 14.71 + }, + { + "text": "-What's happening?", + "start": 6372.38, + "duration": 1.048 + }, + { + "text": "I thought this is what\nyou always wanted,", + "start": 6373.428, + "duration": 2.302 + }, + { + "text": "to star in the walkthrough videos,\nto have all of YouTube's eyes", + "start": 6375.73, + "duration": 3.52 + }, + { + "text": "watching you.", + "start": 6379.25, + "duration": 2.5 + }, + { + "text": "[HONKING]", + "start": 6381.75, + "duration": 0.5 + }, + { + "text": " ", + "start": 6382.25, + "duration": 5.74 + }, + { + "text": "-Yes, you are.", + "start": 6387.99, + "duration": 1.96 + }, + { + "text": "You have to be.", + "start": 6389.95, + "duration": 1.53 + }, + { + "text": "Now stand up straight, tuck in\nyour shirt, look into the camera!", + "start": 6391.48, + "duration": 3.662 + }, + { + "text": "Take it again from the top.", + "start": 6395.142, + "duration": 2.238 + }, + { + "text": " ", + "start": 6397.38, + "duration": 6.178 + } +] \ No newline at end of file