Improving notes on BTrees.

Author: Clément

source/Makefile

@@ -310,8 +310,7 @@ PREREQ: $(TARGET_DIAG) $(TARGET_EXO) $(TARGET_IMAGES_FILES)
 
 .PHONY: CLEAN-PREREQ
 CLEAN-PREREQ:
-	rm -f $(DIAG_DIR)*/*.md $(DIAG_DIR)*/*.png $(DIAG_DIR)*/*m.svg && rm -rf $(EXO_DIR) && rm -rf $(TARGET_IMAGES_FILES)
-
+	rm -f $(DIAG_DIR)*/*.md $(DIAG_DIR)*/*.png $(DIAG_DIR)*/*.svg && rm -rf $(EXO_DIR) && rm -rf $(TARGET_IMAGES_FILES)
 
 # PREVIOUS RULE
 # $(CLA_DIR)%.md: $(CLA_DIR)%.txt | $(CLA_DIR)%.svg 
@@ -385,13 +384,15 @@ $(GRA_DIR)%.svg: $(GRA_DIR)%.txt
 	@echo "Creating $@"
 	echo "graph TB" > $@_tmp \
 	&& cat $< >> $@_tmp \
+	&& echo "\nclassDef hidden display: none;" >> $@_tmp \
 	&& mmdc -p .puppeteer.json -i $@_tmp -o $@ \
 	&& rm $@_tmp
 
 $(GRA_DIR)%.png: $(GRA_DIR)%.txt
 	@echo "Creating $@"
 	echo "graph TB" > $@_tmp \
 	&& cat $< >> $@_tmp \
+	&& echo "\nclassDef hidden display: none;" >> $@_tmp \
 	&& mmdc -s 2 -p .puppeteer.json -i  $@_tmp -o $@ \
 	&& rm $@_tmp
 

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

@@ -4,6 +4,7 @@
 public abstract class BTree<T>
   where T : IComparable<T>
 {
+  // We begin by defining a node class.
   protected class Node
   {
     public T Data { get; set; }
@@ -26,9 +27,12 @@ public override string ToString()
       return "| " + Data.ToString() + " |";
     }
   }
+  // We can now define the BTree class 
+  // using this notion of nodes.
 
+        // Constructor, Clear and IsEmpty
+        // are relying on the root Node.
   protected Node root;
-
   public BTree()
   {
     root = null;
@@ -43,38 +47,8 @@ public bool IsEmpty()
   {
     return root == null;
   }
-
-  public override string ToString()
-  {
-    string returned = "Depth: " + Depth() + "\n";
-    if (root != null)
-    {
-      returned += Stringify(root, 0);
-    }
-    return returned;
-  }
-
-  private string Stringify(Node nodeP, int depth)
-  {
-    string returned = "";
-    if (nodeP != null)
-    {
-      for (int i = 0; i < depth; i++)
-      {
-        returned += " ";
-      }
-      returned += nodeP + "\n"; // Calls Node's ToString method.
-      if (nodeP.left != null)
-      {
-        returned += "L" + Stringify(nodeP.left, depth + 1);
-      }
-      if (nodeP.right != null)
-      {
-        returned += "R" + Stringify(nodeP.right, depth + 1);
-      }
-    }
-    return returned;
-  }
+    // We now look at how to 
+    // compute the Depth of a tree.
 
   public int Depth()
   {
@@ -105,6 +79,7 @@ private int Depth(Node nodeP, int depth)
     }
     return result;
   }
+    // Finding is also recursive.
 
   public virtual bool Find(T dataP)
   {
@@ -135,6 +110,8 @@ private bool Find(Node nodeP, T dataP)
     return found;
   }
 
+    // Done with finding.
+
   public abstract void Insert(T dataP);
   public abstract bool Delete(T dataP);
 
@@ -210,4 +187,39 @@ private string TraversePo(Node nodeP)
     }
     return returned;
   }
+
+
+    // The ToString method is simply here to help debug.
+
+    public override string ToString()
+    {
+        string returned = "Depth: " + Depth() + "\n";
+        if (root != null)
+        {
+            returned += Stringify(root, 0);
+        }
+        return returned;
+    }
+
+    private string Stringify(Node nodeP, int depth)
+    {
+        string returned = "";
+        if (nodeP != null)
+        {
+            for (int i = 0; i < depth; i++)
+            {
+                returned += " ";
+            }
+            returned += nodeP + "\n"; // Calls Node's ToString method.
+            if (nodeP.left != null)
+            {
+                returned += "L" + Stringify(nodeP.left, depth + 1);
+            }
+            if (nodeP.right != null)
+            {
+                returned += "R" + Stringify(nodeP.right, depth + 1);
+            }
+        }
+        return returned;
+    }
 }

source/diag/gra/bstree_example_1.txt

@@ -0,0 +1,10 @@
+A((10))-->B((7))
+B-->C((5))
+B-->D((8))
+A-->E((11))
+E~~~H0:::hidden
+E-->F((30)) 
+F-->G((12))
+G~~~H2:::hidden
+G-->H1((15))
+F~~~H3:::hidden

source/diag/gra/bstree_example_1_with_depth.txt

@@ -0,0 +1,37 @@
+d1:::depthClass
+d2:::depthClass
+d3:::depthClass
+d4:::depthClass
+d5:::depthClass
+
+subgraph d1 [Depth 0]
+    A((10))
+end
+subgraph d2 [Depth 1]
+    B((7))
+    E((11))
+end
+subgraph d3 [Depth 2]
+    C((5))
+    D((8))
+    F((30))
+end
+subgraph d4 [Depth 3]
+    G((12))
+end
+subgraph d5 [Depth 4]
+    H((15))
+end
+
+A-->B
+B-->C
+B-->D
+A-->E
+E~~~H0:::hidden
+E-->F 
+F-->G
+G~~~H2:::hidden
+G-->H
+F~~~H3:::hidden
+
+classDef depthClass width:30em, height:4em, display:flex, justify-content: flex-start, align-items:flex-end;

source/diag/gra/bstree_example_1_with_null.txt

@@ -0,0 +1,10 @@
+A((10))-->B((7))
+B-->C((5))
+B-->D((8))
+A-->E((11))
+E-->N1((null))
+E-->F((30))
+F-->G((12))
+G--->N2((null))
+G-->H1((15))
+F--->N3((null))

source/lectures/data/trees.md

@@ -13,33 +13,98 @@ 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 (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.
+- 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 *subtree* is the tree obtain by considering a particular node in a tree as the root of the tree made of its children.
+- 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 smalles value in the tree,
-- Removing a node from the tree,
+- Finding the smallest value in the tree,
+- Removing a node from the tree, 
+- etc.
 
-<!--
-### Abstract Data Type
+In the following example:
 
-### Difference with array 
--->
+!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 (30): we call it "the right child", and observe that 11 has no "left child",
+- The depth of the tree is 3,
+- The nodes 7, 5 and 8 taken together form a subtree.
 
 ## Possible Implementation
 
 ### Binary Tree
 
-We implement a binary tree class abstractly, because two methods will be missing: how to insert a value, and how to delete a value.
+#### Node Class
+
+Defining a `BTree` class start by defining a `Node` class:
+
+```{download="./code/projects/Tree.zip"}
+!include`snippetStart="// We begin by defining a node class.", snippetEnd="// We can now define the BTree class"` code/projects/Tree/Tree/BTree.cs
+```
+
+As we can see, a `Node` has three elements:
+
+- `Data` is the value it is holding,
+- `left` denotes its "left child",
+- `right` denotes its "right child".
+
+If we wanted to be more technically correct in our drawing, we would explicitly label some nodes as `null`, and the previous tree would actually be as follows:
+
+!include diag/gra/bstree_example_1_with_null.md
+
+#### Initializing
+
+Then, 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
+
+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.
+For this, we will use *recursion*.
+
+In short, for a tree to determine its node, it needs to 
+
+- Have its `root` "ask its children" what their deepest node is,
+- Take the maximum value returned.
+
+For the `root`'s children to determine what the deepest node under them is, they need both to
+
+- "Ask its children" what is their deepest node,
+- Take the maximum value returned.
+
+Etc., etc. Hence, we get:
+
+```{download="./code/projects/Tree.zip"}
+!include`snippetStart="// compute the Depth of a tree.", snippetEnd="// Finding is also recursive."` code/projects/Tree/Tree/BTree.cs
+```
+
+#### Displaying Trees
+
+#### Implementation Detail
+
+We implemented the binary tree class abstractly, because two methods are still missing: how to insert a value, and how to delete a value (we will add them later on).
+This is the reason why we marked the `Node` class as `protected`, and not private: it will still be accessible by the class inheriting from `BTree`.
+
+#### Finding a Value
+
 We also mark the `Find` method as `virtual` because we will override it for something more efficient.
 Note, finally, that we use the `protected` keyword, so that classes inheriting the `BTree` class will be able to manipulate `Node`s.
 
+
 ```{download="./code/projects/Tree.zip"}
-!include code/projects/Tree/Tree/BTree.cs
+!include`snippetStart="// Finding is also recursive.", snippetEnd="// Done with finding."` code/projects/Tree/Tree/BTree.cs
 ```
 
 ### Binary Search Tree