[frontendmasters.com] Four Semesters of Computer Science in 5 Hours, Part 2 [2018, ENG]

Содержание

Table of Contents
Introduction
Introduction
00:00:00 - 00:07:08
Introduction
Brian Holt introduces the course, his background, and why computer science knowledge is important. Computer science will make you a better developer, make your apps better and allow you to pass difficult interview questions. - https://btholt.github.io/four-semesters-of-cs-part-two/
Bloom Filters
Bloom Filters Setup
00:07:09 - 00:11:39
Bloom Filters Setup
Brian introduces bloom filters and how they give you a very fast way to make sure something isn't in a set. - https://btholt.github.io/four-semesters-of-cs-part-two/bloom-filters
Bloom Filters Diagramed
00:11:40 - 00:17:54
Bloom Filters Diagramed
Using arrays and hashing functions, Brian diagrams how the bloom filter works internally to quickly identify if something isn't in a set.
Bloom Filter Caveats
00:17:55 - 00:21:45
Bloom Filter Caveats
You can never remove anything from a Bloom Filter. You can't expand a Bloom Filter. Trade offs can be made with how many hashing functions you use.
Hashing Functions Explained
00:21:46 - 00:23:46
Hashing Functions Explained
How a string gets transformed from a string to a number which corresponds to the index in an array.
Bloom Filters Exercise
00:23:47 - 00:30:13
Bloom Filters Exercise
Setup for the Bloom Filters exercise in CodePen and how to run the tests. In the exercise you'll implement the add and contains methods. - https://codepen.io/btholt/pen/JMebQd?editors=0010
Bloom Filter Solution
00:30:14 - 00:39:28
Bloom Filter Solution
Brian shows you how to code the adds and contains functions to implement a Bloom filter. - https://codepen.io/btholt/pen/LeXRwq?editors=0010
Tree Traversals
Tree Traversals Introduction
00:39:29 - 00:42:27
Tree Traversals Introduction
Trees are an essential part of storing data as data structures optimized to be searchable. - https://btholt.github.io/four-semesters-of-cs-part-two/tree-traversals
Depth-first Traversal
00:42:28 - 00:48:57
Depth-first Traversal
Depth-first traversal is a way to process the tree into a data structure. Brian shows different ways to process the tree data structure into an array.
Depth-first Traversal Exercise
00:48:58 - 00:51:49
Depth-first Traversal Exercise
In the exercise you'll write a function that takes in a tree array and processes the tree into a flat array. - https://codepen.io/btholt/pen/jYpwQV?editors=0010
Depth-first Traversal Solution
00:51:50 - 00:56:20
Depth-first Traversal Solution
Brian codes the preorder, inorder and postorder traversal methods to process the tree data structure into a flat array - https://codepen.io/btholt/pen/rprwwm?editors=0010
Breadth-first Traversal
00:56:21 - 01:01:54
Breadth-first Traversal
Breadth-first is a way to traverse in order to stay closer to the root node vs going deep in the tree like depth-first does. With breadth-first, you use a queue to maintain the correct order to process the tree
Breadth-first Traversal Exercise
01:01:55 - 01:03:11
Breadth-first Traversal Exercise
In the exercise you'll code the breadth-first traversal method to process the tree data structure into a flat array.
Breadth-first Traversal Solution
01:03:12 - 01:11:31
Breadth-first Traversal Solution
Brian implements the recursive and iterative versions of breadth-first traversal. - https://codepen.io/btholt/pen/wpEgdb?editors=0010
Tree Queue Diagram
01:11:32 - 01:25:02
Tree Queue Diagram
How does a tree becomes a queue? Brian explains using a diagram and walks through how queues work. - https://codepen.io/btholt/pen/WdgRrB?editors=0010
Pathfinding
Pathfinding & Demonstration
01:25:03 - 01:38:35
Pathfinding & Demonstration
Pathfinding is a way to find the shortest path between two points. He shows different search algorithms using the pathfinder visualizer. - https://btholt.github.io/four-semesters-of-cs-part-two/pathfinding
Pathfinding Exercise
01:38:36 - 01:44:14
Pathfinding Exercise
Brian sets up the exercise to find the amount of steps to find a path between two points. - https://codepen.io/btholt/pen/BJMxVM?editors=0010
Pathfinding Solution
01:44:15 - 02:21:40
Pathfinding Solution
Solution to the pathfinding challenge to crawl the graph and find the path between to points. - https://codepen.io/btholt/pen/LeqeoQ?editors=0010
Graphs
Graphs
02:21:41 - 02:30:20
Graphs
Graphs are a central concept to computer science. Social networks use graphs famously. There are bi-directional and uni-directional graphs. - https://btholt.github.io/four-semesters-of-cs-part-two/graphs/
Graphs Exercise
02:30:21 - 02:33:28
Graphs Exercise
Find the most common job in your social graph. - https://codepen.io/btholt/pen/KZYdKW?editors=0010
Graphs Solution
02:33:29 - 02:52:42
Graphs Solution
Coding a graph search in order to find the most common job title. - https://codepen.io/btholt/pen/qpvdJJ?editors=0010
Generating a Maze
Generating a Maze
02:52:43 - 03:02:46
Generating a Maze
Visual demonstration of generating randomized mazes with various generation algorithms. - https://btholt.github.io/four-semesters-of-cs-part-two/maze-generation/
Generating a Maze Exercise
03:02:47 - 03:08:02
Generating a Maze Exercise
Generate a maze. - https://codepen.io/btholt/pen/YeWjNO?editors=0010
Generating a Maze Solution
03:08:03 - 03:18:52
Generating a Maze Solution
Brian codes the solution to generating a maze. - https://codepen.io/btholt/pen/rJxOyK?editors=0010
Tries
Tries
03:18:53 - 03:25:47
Tries
Trie is a type of tree data structure that makes it easy to search and retrieve data. - https://btholt.github.io/four-semesters-of-cs-part-two/tries/
Tries Exercise
03:25:48 - 03:28:06
Tries Exercise
Create a trie to autocomplete search the list of city names in the United States. - https://codepen.io/btholt/pen/RQobyV?editors=0010
Tries Solution
03:28:07 - 03:42:57
Tries Solution
Create the trie structure to return the auto complete search results of city names. - https://codepen.io/btholt/pen/PQGVxR?editors=0010
Searching for an Element in an Array
Searching for an Element in an Array
03:42:58 - 03:45:17
Searching for an Element in an Array
Looking at a few different strategies for finding a particular element in an array using linear and binary strategies. In binary you are splitting the sorted array in half in order to not have to iterate through every element in the array. - https://btholt.github.io/four-semesters-of-cs-part-two/search/
Searching for an Element in an Array Solution
03:45:18 - 03:49:11
Searching for an Element in an Array Solution
Code out linear and binary searching on an array to find a particular element. - https://codepen.io/btholt/pen/ZrKzea?editors=0010
Heap Sort
Heap Sort
03:49:12 - 04:03:49
Heap Sort
Heap is a tree that you can represent as an array that comes with the guarantee of the first index of a max heap is the largest number. - https://btholt.github.io/four-semesters-of-cs-part-two/heap-sort/
Heap Sort Solution
04:03:50 - 04:15:01
Heap Sort Solution
Code out heapify which creates a heap data structure and can be dequeued until everything is sorted. - https://codepen.io/btholt/pen/eVWRNP?editors=0010
Radix Sort
Radix Sort
04:15:02 - 04:22:05
Radix Sort
Radix sort allows you to sort without actually comparing two indexes of the array. It is a "non comparative" sort. - https://btholt.github.io/four-semesters-of-cs-part-two/radix-sort/
Radix Sort Solution
04:22:06 - 04:31:47
Radix Sort Solution
Code out the radix sort. - https://codepen.io/btholt/pen/VQbMGJ?editors=0010
Conclusion
Conclusion and Goodbye
04:31:48 - 04:32:24
Conclusion and Goodbye
Brian says goodbye and invites you to give him a shout on twitter @holbt. - https://twitter.com/holtbt

Скриншоты