Improving notes on BSTrees.

Author: aubertc

source/code/projects/Tree/Tree/BSTree.cs

@@ -33,19 +33,19 @@ private Node Insert(T dataP, Node nodeP)
     return nodeP;
   }
 
-  public override bool Find(T dataP)
-  {
-    bool found = false;
-    if (root != null)
+    // Finding into a BSTree
+
+    public override bool Find(T dataP)
     {
-      found = Find(root, dataP);
+        bool found = false;
+        if (root != null)
+        {
+            found = Find(root, dataP);
+        }
+        return found;
     }
-    return found;
-  }
-
-  // Finding into a BSTree
 
-  private bool Find(Node nodeP, T dataP)
+    private bool Find(Node nodeP, T dataP)
   {
     bool found = false;
     if (nodeP != null)

source/code/projects/Tree/Tree/BTree.cs

@@ -21,10 +21,11 @@ public Node(
       left = leftP;
       right = rightP;
     }
-
+        // Displaying a Node is only 
+        // displaying its data.
     public override string ToString()
     {
-      return "| " + Data.ToString() + " |";
+      return Data.ToString();
     }
   }
 
@@ -90,9 +91,9 @@ private int Depth(Node nodeP, int depth)
       depthR = Depth(nodeP.right, result + 1);
     }
     // Finally, if at least one sub-tree
-    // is not null, we take their max to
-    // be the depth of the tree starting
-    // with our current node.
+    // is not null, we take the max of their
+    // depths to be the depth of the tree
+    // starting with our current node.
     if (nodeP.left != null || nodeP.right != null)
     {
       result = Math.Max(depthL, depthR);
@@ -211,7 +212,10 @@ private string TraversePo(Node nodeP)
   public abstract void Insert(T dataP);
   public abstract bool Delete(T dataP);
 
-  // The ToString method is simply here to help debug.
+  // The ToString method is simply here to help us debug.
+  // It is not really pretty, but using pre-order and spaces
+  // to make it easier to understand how the tree is
+  // constructed. It also displays the depth of the tree.
 
   public override string ToString()
   {

source/diag/gra/bstree_example_2.txt

@@ -1,4 +1,4 @@
-%%% A simple binary tree illustrating that insertion order matter
+%%% The binary tree obtained by inserting 10, 6, 13, 12 and 14 (in that order).
 
 A((10))-->B((6))
 A-->C((13))

source/diag/gra/bstree_example_3.txt

@@ -1,4 +1,4 @@
-%%% A simple binary tree illustrating that insertion order matter
+%%% The binary tree obtained by inserting 14, 12, 13, 6 and 10 (in that order).
 
 A((14))-->B((12))
 A~~~H0:::hidden

source/lectures/data/trees.md

@@ -10,38 +10,38 @@ tags:
 A [binary tree](https://en.wikipedia.org/wiki/Binary_tree) is a precise mathematical concept that can be defined as a restriction on graphs.
 As an abstract data type, it generally uses the following definitions:
 
-- A binary tree is made of *nodes*, each of which contain *one value*, can have up to 2 *children*.
+- A binary tree is made of *nodes*, each of which holds *one value*, can have up to 2 *children*.
 - A (rooted) binary tree has exactly one node with 0 parent (that is not the child of any other node), called *the root*. Except for the root, all the nodes have exactly one parent.
-- A *leaf* is a node *without children*.
-- The *depth of a node* is the distance (i.e., the number of times we must go to its parent) from it to the root. This means in particular that the depth of a root is $0$.
-- The *depth of a tree* is the greatest distance of its nodes.
+- A node without children is called *a leaf*.
+- The *depth of a node* is the distance (i.e., the number of times we must go to its parent) from it to the root. This means in particular that the depth of the root is $0$.
+- The *depth of a tree* is the maximum depth of the nodes it contain.
 - A *subtree* is the tree obtain by considering a particular node in a tree as the root of the tree made of all the nodes "below" it, starting with its children.
 
 From there, operations generally include, as usual
 
 - Creating an empty tree,
 - Adding a node to a tree,
 - Finding the smallest value in the tree,
-- Removing a node from the tree, 
+- Removing a node holding a specific value from the tree, 
 - etc.
 
 In the following example:
 
 !include diag/gra/bstree_example_1_with_depth.md
 
-- The root has value 10,
-- The root has two children, 7 and 11,
-- The leaf with value 5 has $0$ children,
-- The node with value 11 has one child (with value 30): we call it "the right child", and observe that 11 has no "left child",
+- The root holds the value 10,
+- The root has two children, holding the values 7 and 11,
+- The node holding the value 5 has $0$ children, hence it is a leaf,
+- The node with value 11 has one child (holding the value 30): we call it "the right child", and observe that the node holding the value 11 has no "left child",
 - The depth of the tree is $4$,
-- The nodes 7, 5 and 8 taken together form a subtree, of depth $1$.
+- The nodes holding the values 7, 5 and 8 taken together form a subtree, of depth $1$.
 
 ## Possible Implementation
 
 ### Binary Tree
 
 We implemented the binary tree class abstractly, because two methods will be missing at the beginning: how to insert a value, and how to delete a value (we will add them later on, in a class that will inherit from this `BTree` class).
-This is the reason why we mark the `Node` class as `protected` below, and not private: it will still be accessible by the class inheriting from `BTree`.
+This is the reason why we mark the `Node` class as `protected` below, and not `private`: it will still be accessible by the class inheriting from `BTree`.
 
 #### Node Class
 
@@ -63,18 +63,20 @@ If we wanted to be more technically correct in our drawing, we would explicitly
 
 #### Initializing
 
-A `BTree` object is simply … the `root` `Node`, and we can construct, empty, and test for emptiness accordingly:
+A `BTree` object is simply the `root` `Node`, and we can construct, empty, and test for emptiness accordingly:
 
 ```{download="./code/projects/Tree.zip"}
 !include`snippetStart="// are relying on the root Node.", snippetEnd="// We now look at how to"` code/projects/Tree/Tree/BTree.cs
 ```
 
-#### Computing the Depth
+#### Computing the Depth of the tree
 
 Now, assume that we are given a `BTree` object. How can we compute its depth?
-Its depth is the depth of the "deeper" node, but each node do not know their depth, only that they have 0, 1 or 2 children.
-Of course, if the `BTree` is `null`, then deciding its depth is easy: it is $0$.
-Then, the idea is that each node knows that its depth is $1$ more than the depth of its parent: remains to find which node has the biggest depth.
+Its depth is the maximum depth of the nodes it contain.
+However, only the root knows its depth (it is $0$), all the other nodes do not know their depth, only that they have 0, 1 or 2 children.
+
+Of course, if the `BTree` is `null` or if its `root` has $0$ children, then deciding its depth is easy: it is $0$.
+Otherwise, the idea is that each tree knows that its depth is $1$ more than the depth of the its two sub-trees: remains to find which sub-tree has the biggest depth.
 For this, we will use *recursion*.
 
 In short, for a tree to determine its node, it needs to 
@@ -93,21 +95,21 @@ Etc., etc. Hence, we get:
 !include`snippetStart="// compute the Depth of a tree.", snippetEnd="// Finding is also recursive."` code/projects/Tree/Tree/BTree.cs
 ```
 
-Note that we have *two* recursive calls: one for the `left` `Node`, one for the `right` `Node` (if they are not empty).
+Note that we have *two* recursive calls: one for the `left` `Node`, one for the `right` `Node` (if they are not `null`).
 
 #### Displaying Trees
 
-There are essentially three ways of "linearizing" a tree (that is, listing its value as a list), depending how we organize the recursive calls.
+There are essentially three ways of "linearizing" a tree (that is, listing its value in a sequence), depending how we organize the recursive calls.
 
 - *Inorder* traversal displays 
     - First the left sub-tree,
-    - Secondly the data of the current node,
+    - Secondly the data held by the current node,
     - Thirdly the right sub-tree.
 
     For our recurring example, we obtain "5 7 8 10 11 12 15 30".
 
 - *Preorder* traversal displays 
-    - First the data of the current node,
+    - First the data held by the current node,
     - Secondly the left sub-tree,
     - Thirdly the right sub-tree.
 
@@ -116,7 +118,7 @@ There are essentially three ways of "linearizing" a tree (that is, listing its v
 - *Postorder* traversal displays 
     - First the left sub-tree,
     - Secondly the right sub-tree,
-    - Thirdly the data of the current node.
+    - Thirdly the data held by the current node.
 
     For our recurring example, we obtain "5 8 7 15 12 30 11 10".
 
@@ -154,7 +156,7 @@ A binary *search* tree (BST) is a specific type of binary tree that ensures that
 - each node's value is less than all the values stored in its right subtree, 
 - a value cannot occur twice.
 
-Our example is a binary search thee: 
+Our recurring example happens to be a binary search tree: 
 
 - All the values "to the left of" the root are less than $10$, 
 - All the values "to the right of" the root are greater than $10$,
@@ -163,10 +165,11 @@ Our example is a binary search thee:
 - etc.
 
 Note that this is the reason why the node with value $30$ is drawn "to the right of" the node with value $11$: we always need to make the difference between left and right children, even if there is only one child.
+A tree almost identical to our recurring example, but where $30$ was at the right of the node holding the value $11$ would not be a binary *search* tree, but simply a binary tree.
 
 #### Implementation detail
 
-Note that since we need to be able to compare our values, we must tell C# that we will not just be using any `T` generic type, but a type that realizes the [IComparable](https://learn.microsoft.com/en-us/dotnet/api/system.icomparable-1?view=net-9.0) interface.
+Note that since we need to be able to compare our values, we must tell C# that we will not just be using any generic type `T`, but a type that realizes the [IComparable](https://learn.microsoft.com/en-us/dotnet/api/system.icomparable-1?view=net-9.0) interface.
 This forces `T` to have a `CompareTo` method, that we will use to compare the data held by the nodes as follows:
 
 ```
@@ -178,7 +181,7 @@ will return
 - a value less than $0$ if `dataP < nodeP.Data`,
 - a value greater than $0$ if `dataP > nodeP.Data`.
 
-Similarly to the `Equals` method, this is because the `>` and `<` operators are not overloaded by default, so we must use this more convoluted way of determining if `dataP` is less than or greater than `nodeP.Data`. Of course, if neither is `true`, it means that `dataP` is equl to `nodeP.Data`.
+Similarly to the `Equals` method, this is because the `>` and `<` operators are not overloaded by default, so we must use this more convoluted way of determining if `dataP` is less than or greater than `nodeP.Data`. Of course, if neither is `true`, it means that `dataP` is equal to `nodeP.Data`.
 
 #### Insertion