A binary search tree (BST) organizes data so that, at every node, all keys in the left subtree are smaller and all keys in the right subtree are larger. That single ordering invariant is what makes search, insertion, and deletion feel fast: at each step you discard half of the remaining possibilities, much like binary search on a sorted array. Before moving on to AVL trees, heaps, and tries, we need to be precise about what a BST guarantees and, just as importantly, what it does not.
The catch is that BST performance depends on shape, not just on size. Operations cost O(h), where h is the height of the tree. A well-proportioned tree over n keys has height around log n, but a tree built by inserting already-sorted (or reverse-sorted) data degenerates into a path essentially a linked list and height becomes n. This is the gap between the average case and the worst case that motivates every structure in this module: if we can force the tree to stay shallow, we get logarithmic behavior regardless of input order.
As you watch, keep three questions in mind. First, how is each operation (search, insert, delete) expressed recursively in terms of the ordering invariant? Second, where exactly does the cost of an operation come from, and how does it relate to height? Third, which insertion sequences produce balanced versus degenerate trees? Try sketching a few insertion orders on paper and comparing the resulting shapes before you reach the AVL material.
An introductory lecture on binary search trees that defines the BST ordering property and walks through the structural rules that distinguish a BST from an arbitrary binary tree. Based on its title and description, it covers the core vocabulary (root, subtree, ordered/sorted binary tree) and the basic properties you rely on when searching. Expect worked examples that show how the ordering invariant guides traversal down the tree.
This is the right starting point for the Binary Search Tree Fundamentals subtopic: it builds the vocabulary and the invariant that everything else in the module depends on, from a widely watched channel known for slow, example-driven explanations.
A code-focused treatment that explains BST concepts and then implements them in Java, with examples and a linked GitHub repository. It is likely to walk through node structure and the insert, search, and delete routines, including the trickier delete cases such as removing a node with two children. The implementation view connects the abstract ordering rule to concrete recursive code.
Seeing the operations as actual code reinforces why each operation follows a single root-to-leaf path, which is exactly the observation that makes the height-dependence argument click; Geekific's implementation walkthroughs pair well with the more conceptual video above.
A short lecture devoted specifically to the asymptotic (big-O) efficiency of BST operations, presented with slides by a university instructor. It should establish that search, insert, and delete all cost O(h) and then analyze what h can be, contrasting the balanced case with the degenerate case. This is the analytical complement to the two implementation-oriented videos.
It directly serves the Time Complexity, Tree Imbalance, and Worst-Case Degenerate Trees subtopics, and because it comes from a course lecture it uses the same formal big-O framing we expect in your written analyses.
Together these three videos establish the baseline that the rest of the module builds on. The first two give you the structural definition and a concrete implementation of BST search, insert, and delete, so you can reason about operations as traversals along a single path; the third converts that observation into an explicit O(h) analysis and shows how h collapses to n in a degenerate tree. That is precisely the argument MO1 asks you to be able to make, and it supplies the baseline complexity figures you will compare against when evaluating AVL trees, heaps, and tries under MO5. The balance problem identified here is also the direct motivation for the rotation-based repair operations you will trace in MO2 and for the shape invariants that make heap and trie operations predictable in MO3 and MO4.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.