46:"/_next/static/chunks/33yus346z0l_n.js" 47:"/_next/static/chunks/1r8ezocsukqp8.js" 48:"/_next/static/chunks/0iv56yrji_20j.js" 49:"/_next/static/chunks/0wa9m1-tphf9u.js" 4a:"/_next/static/chunks/08cuqqn_f60pp.js" 4b:"/_next/static/chunks/3zdsl3f9b0--r.js" 4c:"/_next/static/chunks/2j22cxchii_xx.js" 4d:"/_next/static/chunks/3bgoyiso1rhn7.js" 4e:"/_next/static/chunks/01a-3hvnqu8wl.js" 4f:"/_next/static/chunks/3m1xjj5kw5fie.js" 50:"/_next/static/chunks/0om3fkgfnicab.js" 51:"/_next/static/chunks/0gafyzg9j9yqj.js" 52:"/_next/static/chunks/20w4eaqlekefm.js" 53:"/_next/static/chunks/449--h5z1s6nq.js" 54:"/_next/static/chunks/3k2gyg36fnag_.js" 55:"/_next/static/chunks/18ggtgz2yf759.js" 56:"/_next/static/chunks/0hlb44ca7-4a2.js" 57:"/_next/static/chunks/253gnmj0-cj17.js" 58:"/_next/static/chunks/09nq57stwzkgf.js" 59:"/_next/static/chunks/082jo-0ajazgr.js" 5a:"/_next/static/chunks/2ozcrjb_hh74t.js" 5b:"/_next/static/chunks/05i8en-x14ibi.js" 5c:"/_next/static/chunks/32izpn90gvm22.js" 5d:"/_next/static/chunks/0jbzid2v9xv3h.js" 5e:"/_next/static/chunks/0i3-eynrkvqi7.js" 5f:"/_next/static/chunks/1tn-0fivsxsv1.js" 60:"/_next/static/chunks/34h36hyf_ggow.js" 61:"/_next/static/chunks/20329i6m_04t6.js" 62:"/_next/static/chunks/161uxd62cjny2.js" 63:"/_next/static/chunks/2k8pepwc4pxns.js" 64:I[593304,["$2b","$2c","$2d","$2e","$2f","$30","$46","$47","$48","$49","$4a","$4b","$4c","$4d","$4e","$4f","$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63"],"OwnedHydration"] 65:T42d,In our journey through data structures, we've encountered two remarkably powerful ideas. First, we explored **binary trees**—hierarchical structures where each node has at most two children, enabling us to model parent-child relationships and organize data in layers. Second, we mastered **binary search**—an algorithm that achieves O(log n) lookup by repeatedly halving a sorted collection. Now, we arrive at one of computer science's most elegant achievements: the **Binary Search Tree (BST)**. A BST is not merely a binary tree, nor is it simply binary search in disguise. It is the *fusion* of both concepts—a data structure that maintains elements in a sorted order *within* a tree structure, enabling efficient search, insertion, and deletion operations. Understanding BSTs is a watershed moment in your algorithmic education. BSTs unlock a new category of problems, serve as the foundation for more advanced structures like AVL trees and Red-Black trees, and appear in countless real-world applications from database indexing to file system organization.66:T41a,What if we could organize a binary tree so that searching doesn't require examining every node? What if, at each node, the tree's structure could *tell us* which direction to go? This is the fundamental insight behind Binary Search Trees: **impose a strict ordering on values such that at every node, all values in the left subtree are less than the node, and all values in the right subtree are greater.** This constraint transforms a generic container into a *searchable* structure. Just as binary search on a sorted array eliminates half the possibilities with each comparison, a BST eliminates an entire subtree with each comparison. Consider the mental model of making a decision at every node: - If the value we seek is **less** than the current node, it *must* be in the left subtree (if it exists at all) - If the value we seek is **greater**, it *must* be in the right subtree - If it **equals** the current node, we've found it! This is exactly how binary search works—but instead of indices in an array, we navigate edges in a tree.67:T49a,class TreeNode: """ A node in a Binary Search Tree. The structure is identical to a binary tree node. The BST property is maintained by how we insert/organize values, not by this class definition. """ def __init__(self, val: int, left: 'TreeNode' = None, right: 'TreeNode' = None): self.val = val # The key/value stored at this node self.left = left # Reference to left child (values < self.val) self.right = right # Reference to right child (values > self.val) def __repr__(self): return f"TreeNode({self.val})" # Example: Building the BST from our visualization # 50 # / \ # 30 70 # / \ / \ # 20 40 60 80 root = TreeNode(50) root.left = TreeNode(30) root.right = TreeNode(70) root.left.left = TreeNode(20) root.left.right = TreeNode(40) root.right.left = TreeNode(60) root.right.right = TreeNode(80) # Verify in-order traversal yields sorted order def inorder(node: TreeNode) -> list: if node is None: return [] return inorder(node.left) + [node.val] + inorder(node.right) print(inorder(root)) # Output: [20, 30, 40, 50, 60, 70, 80]68:T573,class TreeNode { /** * A node in a Binary Search Tree. * * The structure is identical to a binary tree node. * The BST property is maintained by how we insert/organize values, * not by this class definition. */ val: T; left: TreeNode | null; right: TreeNode | null; constructor(val: T, left: TreeNode | null = null, right: TreeNode | null = null) { this.val = val; // The key/value stored at this node this.left = left; // Reference to left child (values < this.val) this.right = right; // Reference to right child (values > this.val) } toString(): string { return `TreeNode(${this.val})`; } } // Example: Building the BST from our visualization // 50 // / \ // 30 70 // / \ / \ // 20 40 60 80 const root = new TreeNode(50); root.left = new TreeNode(30); root.right = new TreeNode(70); root.left.left = new TreeNode(20); root.left.right = new TreeNode(40); root.right.left = new TreeNode(60); root.right.right = new TreeNode(80); // Verify in-order traversal yields sorted order function inorder(node: TreeNode | null): T[] { if (node === null) { return []; } return [...inorder(node.left), node.val, ...inorder(node.right)]; } console.log(inorder(root)); // Output: [20, 30, 40, 50, 60, 70, 80]69:T73c,import java.util.ArrayList; import java.util.List; /** * A node in a Binary Search Tree. * * The structure is identical to a binary tree node. * The BST property is maintained by how we insert/organize values, * not by this class definition. */ class TreeNode { int val; // The key/value stored at this node TreeNode left; // Reference to left child (values < this.val) TreeNode right; // Reference to right child (values > this.val) TreeNode(int val) { this.val = val; this.left = null; this.right = null; } TreeNode(int val, TreeNode left, TreeNode right) { this.val = val; this.left = left; this.right = right; } @Override public String toString() { return "TreeNode(" + val + ")"; } } public class BSTExample { // Verify in-order traversal yields sorted order static List inorder(TreeNode node) { List result = new ArrayList<>(); if (node == null) { return result; } result.addAll(inorder(node.left)); result.add(node.val); result.addAll(inorder(node.right)); return result; } public static void main(String[] args) { // Example: Building the BST from our visualization // 50 // / \ // 30 70 // / \ / \ // 20 40 60 80 TreeNode root = new TreeNode(50); root.left = new TreeNode(30); root.right = new TreeNode(70); root.left.left = new TreeNode(20); root.left.right = new TreeNode(40); root.right.left = new TreeNode(60); root.right.right = new TreeNode(80); System.out.println(inorder(root)); // Output: [20, 30, 40, 50, 60, 70, 80] } }45:["$","$L64",null,{"owner":"anonymous","state":{"mutations":[],"queries":[{"dehydratedAt":1792316145366,"state":{"data":{"json":{"id":"seed_942129469c6d0e1cff0de03181eb340f","slug":"what-is-bst","category":"Data Structures & Algorithms","topic":"Binary Search Trees","title":"What Is a Binary Search Tree (BST)?","description":"Master the foundational concept of Binary Search Trees—a data structure that elegantly combines the hierarchical nature of trees with the power of binary search. Understand the BST property, why ordering matters, and how BSTs differ from ordinary binary trees.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_1c79baa8c71d7832cfea47e55ea4fdc1","title":"Definition of a BST","order":0,"content":[{"id":"opening-hook","title":"The Search for Order in Hierarchy","content":[{"data":{"content":"$65"},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand what makes a Binary Search Tree fundamentally different from an ordinary binary tree. You'll grasp the formal definition of a BST, recognize the critical ordering invariant, and appreciate why this simple constraint enables logarithmic-time operations that would otherwise require linear time.","variant":"info"},"type":"callout"}]},{"id":"recalling-binary-trees","title":"Recalling Binary Trees: The Foundation","content":[{"data":{"content":"Before we can understand what makes a BST *special*, we must clearly recall what a binary tree *is*. A binary tree is a hierarchical data structure with the following properties:\n\n1. **Root Node**: There is exactly one distinguished node called the root, which has no parent.\n2. **At Most Two Children**: Every node has at most two children, conventionally called the *left child* and *right child*.\n3. **Subtree Recursion**: Each child is itself the root of a binary tree (or is null/empty), making binary trees inherently recursive structures.\n\nBinary trees give us *structure*—they organize data hierarchically. However, a generic binary tree makes **no guarantees about ordering**. Consider the following binary tree:"},"type":"text"},{"data":{"height":"320px","mermaidSyntax":"graph TD\n A((50)) --> B((30))\n A --> C((70))\n B --> D((20))\n B --> E((40))\n C --> F((60))\n C --> G((80))\n \n style A fill:#4F46E5,stroke:#3730A3,color:#ffffff\n style B fill:#4F46E5,stroke:#3730A3,color:#ffffff\n style C fill:#4F46E5,stroke:#3730A3,color:#ffffff\n style D fill:#4F46E5,stroke:#3730A3,color:#ffffff\n style E fill:#4F46E5,stroke:#3730A3,color:#ffffff\n style F fill:#4F46E5,stroke:#3730A3,color:#ffffff\n style G fill:#4F46E5,stroke:#3730A3,color:#ffffff"},"type":"mermaid-excalidraw"},{"data":{"content":"This tree happens to be organized in a particular way (you might already notice the pattern), but as far as the *definition* of a binary tree is concerned, the values at each node could be arranged in any order. We could swap 70 and 30, or place 80 at the root—it would still be a valid binary tree.\n\nThis flexibility is both a strength and a limitation. Binary trees can represent any hierarchical relationship—family trees, organizational charts, file system directories. But if we want to *search* for a specific value in a generic binary tree, we may need to examine every single node."},"type":"text"},{"data":{"icon":"AlertCircle","title":"The Search Problem in Generic Binary Trees","content":"To find a value in an unordered binary tree of n nodes, we might need to visit all n nodes—making search an O(n) operation. This is no better than searching a linked list or an unordered array. We need something more.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":1},{"id":"imposing-order","title":"The Key Insight: Imposing Order","content":[{"data":{"content":"$66"},"type":"text"},{"data":{"items":["**Binary Search on Array**: Use mid-point to divide array; if target < mid, search left half; if target > mid, search right half","**Binary Search Tree**: The root divides values; if target < root, search left subtree; if target > root, search right subtree","**Both**: At each step, eliminate roughly half the remaining possibilities (assuming balance)","**Key Difference**: Arrays are static and pre-sorted; BSTs maintain order dynamically during insertion/deletion"],"title":{"icon":"Lightbulb","text":"The Binary Search Parallel","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"titleType":"number","titleNumber":2},{"id":"formal-definition","title":"Formal Definition of a Binary Search Tree","content":[{"data":{"content":"Now we can state the formal definition precisely. A **Binary Search Tree (BST)** is a binary tree that satisfies the following **BST Property** (also called the **BST Invariant**):"},"type":"text"},{"data":{"icon":"Info","title":"The BST Property — Formal Definition","content":"For every node N in the tree:\n\n1. All keys in the **left subtree** of N are **strictly less than** the key of N\n2. All keys in the **right subtree** of N are **strictly greater than** the key of N\n3. Both the left subtree and right subtree are themselves Binary Search Trees\n\nThis is a recursive definition—the property must hold not just at the root, but at every node throughout the entire tree.","variant":"note"},"type":"callout"},{"data":{"content":"Let's unpack the critical details of this definition:\n\n**\"Strictly less than\" and \"strictly greater than\"**: The standard BST definition assumes all keys are unique. Each key appears exactly once in the tree. We'll discuss handling duplicates later, but for now, assume distinct keys.\n\n**\"All keys in the left subtree\"**: This is crucially different from saying \"the left child is less than the parent.\" The constraint applies to the *entire* left subtree—every single node in it. A common mistake is checking only immediate children, which is insufficient.\n\n**\"Both subtrees are BSTs\"**: This recursive property is what makes BSTs elegant and amenable to recursive algorithms. If you trust that both subtrees are valid BSTs, and you verify the root satisfies the ordering constraint, then the entire tree is a valid BST."},"type":"text"},{"data":{"rows":[["Left Subtree","All keys < node's key","Every descendant on the left must be smaller"],["Right Subtree","All keys > node's key","Every descendant on the right must be larger"],["Subtrees","Must also be valid BSTs","Property must hold recursively at every level"],["Root","Arbitrary value","The root can hold any key; it divides the value space"],["Null Subtrees","Trivially satisfy BST property","Empty trees are valid BSTs by definition"]],"caption":"The BST Property Breakdown","headers":["Component","Requirement","What It Means"]},"type":"table"}],"titleType":"number","titleNumber":3},{"id":"visualizing-bst","title":"Visualizing the BST Property","content":[{"data":{"content":"Let's visualize a properly formed BST to cement our understanding. Consider this tree containing the values {20, 30, 40, 50, 60, 70, 80}:"},"type":"text"},{"data":{"height":"340px","mermaidSyntax":"graph TD\n A((50)) --> B((30))\n A --> C((70))\n B --> D((20))\n B --> E((40))\n C --> F((60))\n C --> G((80))\n \n style A fill:#059669,stroke:#047857,color:#ffffff\n style B fill:#3B82F6,stroke:#2563EB,color:#ffffff\n style C fill:#EF4444,stroke:#DC2626,color:#ffffff\n style D fill:#3B82F6,stroke:#2563EB,color:#ffffff\n style E fill:#3B82F6,stroke:#2563EB,color:#ffffff\n style F fill:#EF4444,stroke:#DC2626,color:#ffffff\n style G fill:#EF4444,stroke:#DC2626,color:#ffffff"},"type":"mermaid-excalidraw"},{"data":{"content":"In this visualization:\n- **Green (50)**: The root node, dividing all values into two groups\n- **Blue (30, 20, 40)**: The left subtree—all values strictly less than 50\n- **Red (70, 60, 80)**: The right subtree—all values strictly greater than 50\n\nNow, let's verify the BST property holds at *every* node:\n\n**At node 50 (root)**:\n- Left subtree contains {20, 30, 40}—all < 50 ✓\n- Right subtree contains {60, 70, 80}—all > 50 ✓\n\n**At node 30**:\n- Left subtree contains {20}—all < 30 ✓\n- Right subtree contains {40}—all > 30 ✓\n\n**At node 70**:\n- Left subtree contains {60}—all < 70 ✓\n- Right subtree contains {80}—all > 70 ✓\n\n**At leaf nodes (20, 40, 60, 80)**:\n- Both subtrees are empty (null)—trivially valid ✓\n\nThe BST property is satisfied everywhere, making this a valid Binary Search Tree."},"type":"text"},{"data":{"icon":"Lightbulb","title":"Visual Pattern Recognition","content":"In a valid BST, imagine drawing a vertical line through each node. All values in the left half must be smaller, and all in the right half must be larger. This mental model helps you quickly spot invalid BSTs at a glance.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"invalid-bst-examples","title":"Recognizing Invalid BSTs","content":[{"data":{"content":"Understanding what *breaks* the BST property is as important as understanding what satisfies it. Let's examine common violations:\n\n**Violation 1: Left child greater than parent (immediate violation)**"},"type":"text"},{"data":{"height":"280px","mermaidSyntax":"graph TD\n A((50)) --> B((60))\n A --> C((70))\n B --> D((20))\n B --> E((40))\n \n style A fill:#059669,stroke:#047857,color:#ffffff\n style B fill:#EF4444,stroke:#DC2626,color:#ffffff\n style C fill:#3B82F6,stroke:#2563EB,color:#ffffff\n style D fill:#3B82F6,stroke:#2563EB,color:#ffffff\n style E fill:#3B82F6,stroke:#2563EB,color:#ffffff"},"type":"mermaid-excalidraw"},{"data":{"content":"Here, 60 is the left child of 50, but 60 > 50. This immediately violates the BST property. The left child must be less than the parent.\n\n**Violation 2: Subtree value violates ancestor constraint (subtle violation)**"},"type":"text"},{"data":{"height":"280px","mermaidSyntax":"graph TD\n A((50)) --> B((30))\n A --> C((70))\n B --> D((20))\n B --> E((55))\n \n style A fill:#059669,stroke:#047857,color:#ffffff\n style B fill:#3B82F6,stroke:#2563EB,color:#ffffff\n style C fill:#3B82F6,stroke:#2563EB,color:#ffffff\n style D fill:#3B82F6,stroke:#2563EB,color:#ffffff\n style E fill:#EF4444,stroke:#DC2626,color:#ffffff"},"type":"mermaid-excalidraw"},{"data":{"content":"This violation is more subtle and a common source of bugs. At first glance:\n- 55 is the right child of 30, and 55 > 30 ✓\n\nBut wait—55 is in the *left subtree* of 50, and 55 > 50. This violates the BST property at node 50. Every value in the left subtree of 50 must be less than 50, but 55 is not.\n\n**This is why checking only parent-child relationships is insufficient.** We must ensure that every descendant satisfies constraints imposed by all its ancestors."},"type":"text"},{"data":{"icon":"AlertCircle","title":"The Ancestor Constraint Trap","content":"A node in a BST doesn't just need to satisfy its parent's constraint—it must satisfy the constraints of all ancestors. Being the right child of 30 means you must be > 30. But being in the left subtree of 50 means you must also be < 50. The value 55 fails the second constraint.","variant":"error"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"bst-as-contract","title":"The BST Property as a Contract","content":[{"data":{"content":"It's useful to think of the BST property as a **contract** or **invariant** that must be maintained at all times. This perspective is essential when you implement BST operations:\n\n**The Contract States**: At any point during the tree's lifetime, for every node N, all keys in N's left subtree are strictly less than N's key, and all keys in N's right subtree are strictly greater than N's key.\n\n**What This Means for Operations**:"},"type":"text"},{"data":{"rows":[["**Search**","We can trust the ordering to navigate efficiently"],["**Insert**","We must place new values in the correct position to preserve ordering"],["**Delete**","We must remove values while restructuring to preserve ordering"]],"headers":["Operation","Contract Implication"]},"type":"table"},{"data":{"content":"Every operation you implement must either *rely on* this contract (search) or *maintain* this contract (insert, delete). If any operation violates the BST property, all subsequent searches may fail."},"type":"text"},{"data":{"items":["**Before any operation**: Assume the BST property holds for the entire tree","**During the operation**: Make local changes that don't violate the property","**After the operation**: The BST property must still hold for the entire tree","**Key discipline**: Never insert a value in the wrong position; never restructure in a way that breaks ordering"],"title":{"icon":"CheckCircle","text":"Invariant Thinking","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"icon":"Sparkles","title":"Why Invariant Thinking Matters","content":"Invariant-based reasoning is a hallmark of mature algorithmic thinking. Instead of tracing through every possible case, you trust that the invariant holds before your operation, make targeted changes, and verify the invariant still holds after. This simplifies both implementation and correctness proofs.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":6},{"id":"inorder-formulation","title":"Alternative Formulation: The In-Order Sequence","content":[{"data":{"content":"There's an elegant alternative way to think about the BST property using **in-order traversal**:\n\n> A binary tree is a BST if and only if its **in-order traversal** produces a **strictly increasing sequence**.\n\nIn-order traversal visits nodes in the order: left subtree, then root, then right subtree. For the BST we visualized earlier with root 50:\n\n**In-order traversal**: 20 → 30 → 40 → 50 → 60 → 70 → 80\n\nNotice this is a strictly increasing sequence! This isn't a coincidence—it's a direct consequence of the BST property. At every node, all left descendants (visited before the node) are smaller, and all right descendants (visited after) are larger.\n\nThis formulation is powerful for several reasons:"},"type":"text"},{"data":{"items":["**Validation**: To check if a tree is a valid BST, perform in-order traversal and verify the sequence is strictly increasing—O(n) time, O(h) space","**Sorted Access**: In-order traversal of a BST yields elements in sorted order—a BST is essentially a dynamically-maintained sorted collection","**Range Queries**: Finding all elements in a range [lo, hi] is efficient—traverse to find lo, then continue in-order until exceeding hi","**k-th Smallest**: Finding the k-th smallest element is natural—in-order traverse until you've visited k nodes"],"title":{"icon":"Zap","text":"Benefits of the In-Order Formulation","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"icon":"Lightbulb","title":"Two Perspectives, One Property","content":"You now have two equivalent ways to think about BSTs:\n\n1. **Recursive constraint**: At every node, left < node < right for all descendants\n2. **Sequential constraint**: In-order traversal is strictly increasing\n\nUse whichever is more intuitive for the problem at hand. They're mathematically equivalent.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":7},{"id":"node-structure","title":"Node Structure in Code","content":[{"data":{"content":"Let's ground our abstract understanding in concrete code. A BST node is structurally identical to a binary tree node—the difference lies in how we *use* it, not how we *define* it:\n\n**The key insight**: The BST property is a *semantic* constraint, not a *structural* one. The node structure is the same; we impose different rules on how values are organized."},"type":"text"},{"data":{"fileName":"bst_node.py","languages":[{"code":"$67","label":"Python","value":"python"},{"code":"$68","label":"TypeScript","value":"typescript"},{"code":"$69","label":"Java","value":"java"}],"showLineNumbers":true},"type":"code"},{"data":{"content":"Notice that the `TreeNode` class itself contains no logic to enforce the BST property. It's simply a container with three fields: a value and two child pointers. The BST property is maintained by:\n\n1. **Insertion logic**: Placing new values in the correct position based on comparisons\n2. **Deletion logic**: Restructuring the tree while preserving order\n3. **Validation logic**: Verifying the property holds (for debugging/testing)\n\nThis separation is important—the data structure is simple, and the intelligence lies in the algorithms that operate on it."},"type":"text"}],"titleType":"number","titleNumber":8},{"id":"summary","title":"Summary: Understanding BST Definition","content":[{"data":{"content":"We've established the foundational definition of a Binary Search Tree. Before moving forward, let's consolidate the key insights:"},"type":"text"},{"data":{"type":"ordered","items":["**A BST is a binary tree with a strict ordering property** — For every node, left subtree values are strictly less, right subtree values are strictly greater","**The property must hold at every node, not just root-child relationships** — Descendants must satisfy constraints from all ancestors","**Empty subtrees trivially satisfy the BST property** — This provides the base case for recursive reasoning","**The BST property is a semantic constraint, not structural** — The node structure is identical to binary trees; the difference is how values are organized","**In-order traversal of a BST yields a strictly increasing sequence** — This provides an alternative definition and enables sorted access","**The BST property is a contract/invariant** — Operations must either rely on it (search) or maintain it (insert, delete)"],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's Next:**\n\nNow that we understand *what* a BST is, we'll dive deeper into the BST property itself. The next page explores exactly how this ordering principle—left < root < right—enables efficient operations, why it forms the theoretical foundation for logarithmic-time search, and the mathematical reasoning behind its power."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand the formal definition of a Binary Search Tree. You can identify valid and invalid BSTs, understand the recursive nature of the BST property, and appreciate both the constraint-based and traversal-based formulations. Next, we'll explore why this property is so powerful.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":9}],"isLocked":false},{"id":"seed_bbeba7f48303ea71fe942873a62d74dd","title":"The BST Property: left < root < right","order":1,"content":null,"isLocked":true},{"id":"seed_b9bc4b8c9d8821bb42e65ee57d819339","title":"Why This Ordering Enables Efficient Operations","order":2,"content":null,"isLocked":true},{"id":"seed_beafe3d5bba8ca10d8605cda76e05794","title":"BST vs Binary Tree","order":3,"content":null,"isLocked":true}]}},"dataUpdateCount":1,"dataUpdatedAt":1792316145360,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["learningContent","getModule"],{"input":{"slug":"what-is-bst"},"type":"query"}],"queryHash":"[[\"learningContent\",\"getModule\"],{\"input\":{\"slug\":\"what-is-bst\"},\"type\":\"query\"}]"},{"dehydratedAt":1792316145367,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792316145364,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["learningContent","getProgress"],{"input":{"moduleId":"seed_942129469c6d0e1cff0de03181eb340f"},"type":"query"}],"queryHash":"[[\"learningContent\",\"getProgress\"],{\"input\":{\"moduleId\":\"seed_942129469c6d0e1cff0de03181eb340f\"},\"type\":\"query\"}]"},{"dehydratedAt":1792316145367,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792316145365,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["feedback","get"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_bbeba7f48303ea71fe942873a62d74dd"},"type":"query"}],"queryHash":"[[\"feedback\",\"get\"],{\"input\":{\"contentId\":\"seed_bbeba7f48303ea71fe942873a62d74dd\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792316145367,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792316145365,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["feedback","getUserLike"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_bbeba7f48303ea71fe942873a62d74dd"},"type":"query"}],"queryHash":"[[\"feedback\",\"getUserLike\"],{\"input\":{\"contentId\":\"seed_bbeba7f48303ea71fe942873a62d74dd\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792316145367,"state":{"data":{"json":[]},"dataUpdateCount":1,"dataUpdatedAt":1792316145365,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["highlights","getHighlights"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_bbeba7f48303ea71fe942873a62d74dd"},"type":"query"}],"queryHash":"[[\"highlights\",\"getHighlights\"],{\"input\":{\"contentId\":\"seed_bbeba7f48303ea71fe942873a62d74dd\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792316145367,"state":{"data":"$undefined","dataUpdateCount":0,"dataUpdatedAt":0,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"pending","fetchStatus":"fetching"},"queryKey":[["highlights","getPopularHighlights"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_bbeba7f48303ea71fe942873a62d74dd","minCount":2},"type":"query"}],"queryHash":"[[\"highlights\",\"getPopularHighlights\"],{\"input\":{\"contentId\":\"seed_bbeba7f48303ea71fe942873a62d74dd\",\"contentType\":\"LEARNING_PAGE\",\"minCount\":2},\"type\":\"query\"}]","promise":"$@6a"}]},"children":"$L6b"}]