2:02:12CS50x 2024 - Lecture 3 - Algorithms
CS50Intro460K views
CS50x 2024 lecture 3: algorithms — searching, sorting, running time and recursion.
267,244 videos · Algorithms, systems, security, machine learning and building software.
2:02:12Intro460K views
CS50x 2024 lecture 3: algorithms — searching, sorting, running time and recursion.

Intro629K views
Lecture 1 of MIT 18.404 Theory of Computation by Michael Sipser: finite automata, regular languages and regular expressions.

65.7K views
Jim Weirich derives the Y combinator live, step by step, using nothing but Ruby lambdas, and along the way teaches the refactorings of lambda calculus.
2:02:49Intro582K views
CS50x 2024 lecture 5: data structures — linked lists, trees, hash tables and tries.

Advanced143K views
Philip Wadler explains the Curry–Howard correspondence: how logic and programming languages were discovered independently to be the same thing.
51:5794.6K views
MIT 6.006, lecture 5: How direct-access arrays, counting sort and radix sort break the n log n comparison barrier.
57:4036.9K views
MIT 6.006, lecture 12: Bellman-Ford on graphs with negative weights and how it detects negative cycles via graph duplication.
57:3340.7K views
MIT 6.006, lecture 11: Weighted shortest paths, the relaxation framework and DAG shortest paths.
51:26256K views
MIT 6.0001, lecture 10: Measuring program efficiency and an introduction to big-O.
1:03:4538.4K views
MIT 6.006, lecture 18: Rod cutting, subset sum and what pseudopolynomial running time means.
52:5377.1K views
MIT 6.006, lecture 9: Graph representations and breadth-first search for unweighted shortest paths.
47:30696K views
How cyclic redundancy checks (CRCs) detect transmission errors, from polynomial division to hardware.
59:0940.4K views
MIT 6.006, lecture 19: Complexity classes P, NP, EXP, reductions and NP-completeness at an introductory level.
54:09101K views
MIT 6.006, lecture 7: AVL balancing: rotations, height augmentation and why balanced trees give O(log n) operations.
45:392.12M views
MIT 6.006, lecture 1: The course's model of computation, what correctness and efficiency mean, and asymptotic notation.
52:2350.8K views
MIT 6.006, lecture 10: Depth-first search, reachability, topological sort and cycle detection.
50:59221K views
MIT 6.006, lecture 6: Binary trees as a sequence and set data structure: traversal order, subtree operations and insertion/deletion.
57:18154K views
MIT 6.006, lecture 15: The SRTBOT framework for designing dynamic programs, worked through Fibonacci, DAG paths and the bowling problem.
49:13127K views
MIT 6.0001, lecture 11: Common complexity classes from constant to exponential.
50:18717K views
MIT 6.006, lecture 2: The difference between interfaces and data structures, linked lists, and how dynamic arrays get amortized constant-time appends.
52:55416K views
MIT 6.006, lecture 4: The comparison-model lower bound for search and why hashing beats it, including hash functions, chaining and universal hashing.
56:5322.8K views
MIT 6.006, lecture 14: All-pairs shortest paths and Johnson's algorithm's reweighting trick.
1:03:4537.2K views
MIT 6.006, lecture 17: DP with expanded subproblems: all-pairs shortest paths via Floyd-Warshall, optimal parenthesization and piano fingering.

2.9M views
Erik Demaine's MIT 6.006 lecture introducing dynamic programming through Fibonacci and shortest paths: memoization, subproblems and guessing.
48:32197K views
MIT 6.0001, lecture 12: Search and sorting algorithms, from bisection search to merge sort.
50:5278.3K views
MIT 6.006, lecture 8: Priority queues, the array-based binary heap, heapify and in-place heap sort.
52:56230K views
MIT 6.006, lecture 3: The set interface, sorted arrays, and selection, insertion and merge sort with recurrence analysis.
57:2243.3K views
MIT 6.006, lecture 13: Dijkstra's algorithm, why it needs non-negative weights, and its running time with different priority queues.
58:4481.8K views
MIT 6.006, lecture 16: Dynamic programming on subsequences: longest common subsequence, longest increasing subsequence and coin games.

86.6K views
Diego Ongaro's lecture explaining the Raft consensus algorithm: leader election, log replication and safety.

137K views
Matt Kulukundis presents Google's SwissTable, explaining the SIMD-friendly open-addressing design that made it faster than std::unordered_map.
29:224.29M views
Writing a chess engine: board representation, move generation, minimax search and alpha-beta pruning.
21:13679K views
Towers of Hanoi solved recursively, with a full visualisation of the recursion.
20:52548K views
Depth-first search: the algorithm, its recursion, examples and code, including cycle detection and topological sort.

95.6K views
Gerald Sussman argues our programs are brittle compared with biological systems and shows propagator networks as an alternative.
11:011.43M views
Minimax and alpha-beta pruning, explained with game trees.