chore: cleanup readme and tests

Author: kaitinghh

src/main/java/dataStructures/bTree/BTree.java

@@ -1,5 +1,10 @@
 package dataStructures.bTree;
 
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
 /** This BTree implementation is a simplified implementation, which supports the basic search, insert, delete and
  * in-order traversal operations. It is not designed to cover edge cases.
  */
@@ -144,32 +149,6 @@ private void insertNonFull(BTreeNode x, int key) {
         }
     }
 
-    /**
-     * Prints the keys of the B-tree level by level.
-     */
-    public void printBTree() {
-        if (root != null) {
-            printBTree(root, 0);
-        }
-    }
-
-    private void printBTree(BTreeNode node, int level) {
-        System.out.println("Level " + level + ": " + node.keyCount + " keys");
-
-        for (int i = 0; i < node.keyCount; i++) {
-            System.out.print(node.keys[i] + " ");
-        }
-        System.out.println();
-
-        if (!node.leaf) {
-            for (int i = 0; i <= node.keyCount; i++) {
-                if (node.children[i] != null) {
-                    printBTree(node.children[i], level + 1);
-                }
-            }
-        }
-    }
-
     /**
      * Deletes the specified key from the B-tree.
      * @param key key to be deleted
@@ -361,4 +340,95 @@ private void borrowFromRight(BTreeNode x, int i) {
         sibling.keyCount--;
     }
 
+    /**
+     * Returns the level order traversal of the B Tree.
+     * @return An array containing the level order traversal of the B Tree.
+     */
+    public Object[] levelOrderTraversal() {
+        List<Integer> result = new ArrayList<>();
+
+        if (root == null) {
+            return result.toArray(); // Return an empty list for an empty tree
+        }
+
+        Queue<BTreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+
+        while (!queue.isEmpty()) {
+            int levelSize = queue.size();
+
+            for (int i = 0; i < levelSize; i++) {
+                BTreeNode current = queue.poll();
+
+                // Process current node
+                for (int j = 0; j < current.keyCount; j++) {
+                    result.add(current.keys[j]);
+                }
+
+                // Enqueue children if not a leaf
+                if (!current.leaf) {
+                    for (int j = 0; j <= current.keyCount; j++) {
+                        if (current.children[j] != null) {
+                            queue.offer(current.children[j]);
+                        }
+                    }
+                }
+            }
+        }
+
+        return result.toArray();
+    }
+
+    /**
+     * Returns the preorder traversal of the B Tree.
+     * @return An array containing the preorder traversal of the B Tree.
+     */
+    public Object[] preOrderTraversal() {
+        List<Integer> result = new ArrayList<>();
+        preOrderTraversal(root, result);
+        return result.toArray();
+    }
+
+    private void preOrderTraversal(BTreeNode node, List<Integer> result) {
+        if (node != null) {
+            // Process current node
+            for (int i = 0; i < node.keyCount; i++) {
+                result.add(node.keys[i]);
+            }
+
+            // Recursively traverse children
+            if (!node.leaf) {
+                for (int i = 0; i <= node.keyCount; i++) {
+                    preOrderTraversal(node.children[i], result);
+                }
+            }
+        }
+    }
+
+    /**
+     * Debugging method: Prints the keys of the B-tree level by level.
+     */
+    public void printBTree() {
+        if (root != null) {
+            printBTree(root, 0);
+        }
+    }
+
+    private void printBTree(BTreeNode node, int level) {
+        System.out.println("Level " + level + ": " + node.keyCount + " keys");
+
+        for (int i = 0; i < node.keyCount; i++) {
+            System.out.print(node.keys[i] + " ");
+        }
+        System.out.println();
+
+        if (!node.leaf) {
+            for (int i = 0; i <= node.keyCount; i++) {
+                if (node.children[i] != null) {
+                    printBTree(node.children[i], level + 1);
+                }
+            }
+        }
+    }
+
 }

src/main/java/dataStructures/bTree/README.md

@@ -1,7 +1,8 @@
 # B-Trees
 
 ## Background
-Is the fastest way to search for data to store them in an array, sort them and perform binary search? No. <br>
+Is the fastest way to search for data to store them in an array, sort them and perform binary search? No. This will
+incur minimally O(nlogn) sorting cost, and O(n) cost per insertion to maintain sorted order. <br>
 
 We have seen binary search trees (BSTs), which always maintains data in sorted order. This allows us to avoid the 
 overhead of sorting before we search. However, we also learnt that unbalanced BSTs can be incredibly inefficient for 
@@ -18,7 +19,7 @@ insertion, deletion and search operations.
 
 Before we talk about B-trees, we first introduce its family (generalized form) - (a,b) trees. <br> 
 
-- In an (a,b) tree, a nd b refer to the minimum and maximum number of children of an internal node in the tree. <br>
+- In an (a,b) tree, a and b refer to the minimum and maximum number of children of an internal node in the tree. <br>
 - a and b are parameters where 2 <= a <= (b+1)/2. 
 
 Note that unlike binary trees, in (a,b) trees, each node can have more than 2 children and each node can store multiple 
@@ -55,11 +56,12 @@ Specifically, for a non-leaf node with k keys and (k+1) children:
 Then: 
 - first child t1 has key range <= v1
 - final child tk+1 has key range > vk
-- all other children ti have key range (vi-1, vi)
+- all other children ti have key range (vi-1, vi]
 
 Rule #3: Leaf depth
 
 All leaf nodes must be at the same depth from root. 
+- This property forces the tree to be balanced. 
 
 ## Complexity Analysis
 
@@ -100,5 +102,26 @@ Image Source: https://www.geeksforgeeks.org/insert-operation-in-b-tree/
 The delete operation has a similar idea as the insert operation, but involves a lot more edge cases. If you are
 interested to learn about it, you can read more [here](https://www.geeksforgeeks.org/delete-operation-in-b-tree/).
 
+## Application
+There are many uses of B-Trees but the most common is their utility in database management systems in handling large 
+datasets by optimizing disk accesses.
+
+Large amounts of data have to be stored on the disk. But disk I/O operations are slow and not knowing where to look 
+for the data can drastically worsen search time. B-Tree is used as an index structure to efficiently locate the 
+desired data. Note, the B-Tree itself can be partially stored in RAM (higher levels) and and partially on disk 
+(lower, less freq accessed levels).
+
+Consider a database of all the CS modules offered in NUS. Suppose there is a column "Code" (module code) in the 
+"CS Modules" table. If the database has a B-Tree index on the "Code" column, the keys in the B-Tree would be the 
+module code of all CS modules offered.
+
+Each key in the B-Tree is associated with a pointer, that points to the location on the disk where the corresponding 
+data can be found. For e.g., a key for "CS2040s" would have a pointer to the disk location(s) where the row(s) 
+(i.e. data) with "CS2040s" is stored. This efficient querying allows the database quickly navigate through the keys 
+and find the disk location of the desired data without having to scan the whole "CS Modules" table.
+
+The choice of t will impact the height of the tree, and hence how fast the query is. Trade-off would be space, as a 
+higher t means more keys in each node and they would have to be (if not already) loaded to RAM.
+
 ## References
 This description heavily references CS2040S Recitation Sheet 4. 

src/test/java/dataStructures/bTree/BTreeTest.java

@@ -1,7 +1,10 @@
 package dataStructures.bTree;
 
 import org.junit.Test;
+import java.util.ArrayList;
+import java.util.Arrays;
 
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
 public class BTreeTest {
@@ -14,6 +17,11 @@ public void test_BTree() {
             bTree.insert(key);
         }
 
+        Object[] expectedLevelOrderTraversal1 = {5, 8, 1, 2, 3, 4, 6, 7, 9, 10, 11, 12};
+        Object[] expectedPreOrderTraversal1 = {5, 8, 1, 2, 3, 4, 6, 7, 9, 10, 11, 12};
+        assertArrayEquals(bTree.levelOrderTraversal(), expectedLevelOrderTraversal1);
+        assertArrayEquals(bTree.preOrderTraversal(), expectedPreOrderTraversal1);
+
         assertEquals(true, bTree.search(8));
         assertEquals(true, bTree.search(4));
         assertEquals(true, bTree.search(7));
@@ -23,8 +31,18 @@ public void test_BTree() {
         bTree.delete(7);
         assertEquals(false, bTree.search(7));
 
+        Object[] expectedLevelOrderTraversal2 = {4, 8, 1, 2, 3, 5, 6, 9, 10, 11, 12};
+        Object[] expectedPreOrderTraversal2 = {4, 8, 1, 2, 3, 5, 6, 9, 10, 11, 12};
+        assertArrayEquals(bTree.levelOrderTraversal(), expectedLevelOrderTraversal2);
+        assertArrayEquals(bTree.preOrderTraversal(), expectedPreOrderTraversal2);
+
         bTree.delete(4);
         assertEquals(false, bTree.search(4));
+
+        Object[] expectedLevelOrderTraversal3 = {3, 8, 1, 2, 5, 6, 9, 10, 11, 12};
+        Object[] expectedPreOrderTraversal3 = {3, 8, 1, 2, 5, 6, 9, 10, 11, 12};
+        assertArrayEquals(bTree.levelOrderTraversal(), expectedLevelOrderTraversal3);
+        assertArrayEquals(bTree.preOrderTraversal(), expectedPreOrderTraversal3);
     }
 
 }