feat: edit readme

Author: matheus-git

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "flat_rbtree"
-version = "0.1.5"
+version = "0.1.6"
 edition = "2024"
 authors = ["Matheus-git <mathiew0@gmail.com>"]
 description = "A flat, index-based Red-Black Tree with no heap allocations. Ideal for performance-critical or memory-constrained environments."

Cargo.toml

@@ -8,28 +8,46 @@ A fast, index-based Red-Black Tree with no heap allocations — ideal for system
 
 - **Flat storage**: all nodes are stored in a `array`, avoiding pointer indirection.
 - **No allocations per node**: avoids `Box`, `Rc`, or `Arc`.
-- **No-std**: suitable for embedded environments.
-- **Preallocated with MaybeUninit**: minimizes runtime overhead and ensures memory safety.
+- **No-std**: works in embedded or bare-metal environments without relying on the Rust standard library..
+- **Preallocated with MaybeUninit**: memory for all nodes is allocated upfront, minimizing runtime overhead and ensuring safe initialization.
+- **Fixed capacity**: tree size is bounded at compile-time, making resource usage predictable.
 
 ## Usage
 
 ```rust
-let mut tree = RedBlackTree::<&str, i32, 1>::new();
-tree.insert("A", 1);
-tree.update("A", 2);
-tree.search(&"A"); // Some(&2)
-tree.remove("A");
+    let mut tree = RedBlackTree::<i32, &str, 10>::new();
+
+    tree.insert(10, "A");
+    tree.insert(20, "B");
+    tree.insert(5, "C");
+
+    tree.update(10, "Updated A");
+
+    if let Some(value) = tree.search(&10) {
+        println!("Key 10 has value: {}", value);
+    }
+
+    for (key, value) in tree.iter() {
+        println!("Key: {}, Value: {}", key, value);
+    }
+
+    tree.remove(20);
+
+    if !tree.contains_key(&20) {
+        println!("Key 20 successfully removed");
+    }
 ```
 
 ## Benchmark: flat_rbtree vs [rbtree](https://docs.rs/rbtree/latest/rbtree/) (10,000 operations)
 
+Since all operations are at most O(log n), this benchmark is just to give an idea of the performance compared to a pointer-based implementation.
+
 | Operation | flat_rbtree | [rbtree](https://docs.rs/rbtree/latest/rbtree/) |
 |-----------|----------------|---------------|
 | **Insert** | 1.14 ms   | 1.34 ms  | 
 | **Remove** | 2.12 ns        | 354 ps       | 
 | **Search** | 655 µs         | 514 µs       | 
 
-> It’s worth noting that `rbtree` is a pointer-based implementation, which tends to be more performant than an index-based implementation.
 
 ## 📝 License
 

README.md

@@ -1,13 +1,14 @@
 #![allow(warnings)]
-#![cfg_attr(not(test), no_std)]
+#![no_std]
 
 //! A fast, index-based Red-Black Tree with no heap allocations.
 //!
 //! ## Features
-//! - No heap allocation
-//! - All nodes are stored in a `array`, avoiding pointers
-//! - Flat storage using `MaybeUninit`
-//! - Suitable for `no_std` environments
+//! - **Flat storage**: all nodes are stored in an `array`, avoiding pointer indirection.
+//! - **No allocations per node**: avoids `Box`, `Rc`, or `Arc`.
+//! - **No-std**: works in embedded or bare-metal environments without relying on the Rust standard library.
+//! - **Preallocated with `MaybeUninit`**: memory for all nodes is allocated upfront, minimizing runtime overhead and ensuring safe initialization.
+//! - **Fixed capacity**: tree size is bounded at compile-time, making resource usage predictable.
 //!
 use core::mem::MaybeUninit;
 use core::cmp::Ordering;
@@ -30,6 +31,7 @@ struct Node<K, V> {
     right: usize,
 }
 
+/// An iterator over the entries of a `RedBlackTree`.
 pub struct RedBlackTreeIter<'a, K: Ord + 'a, V: 'a, const N: usize> {
     tree: &'a RedBlackTree<K, V, N>,
     index: usize,
@@ -38,6 +40,7 @@ pub struct RedBlackTreeIter<'a, K: Ord + 'a, V: 'a, const N: usize> {
 impl<'a, K: Ord + 'a, V: 'a, const N: usize> Iterator for RedBlackTreeIter<'a, K, V, N> {
     type Item = (&'a K, &'a V);
 
+    /// Advances the iterator and returns the next key-value pair in ascending order.
     fn next(&mut self) -> Option<Self::Item> {
         if self.index == SENTINEL {
             let next = self.tree.min_usize(self.tree.root);
@@ -60,6 +63,7 @@ impl<'a, K: Ord + 'a, V: 'a, const N: usize> Iterator for RedBlackTreeIter<'a, K
 }
 
 impl<'a, K: Ord + 'a, V: 'a, const N: usize> DoubleEndedIterator for RedBlackTreeIter<'a, K, V, N> {
+    /// Advances the iterator from the back and returns the previous key-value pair in descending order.
     fn next_back(&mut self) -> Option<Self::Item> {
         if self.index == SENTINEL {
             let next = self.tree.max_usize(self.tree.root);
@@ -720,6 +724,34 @@ mod tests {
         tree
     }
 
+    #[test]
+    fn test_example() {
+        let mut tree = RedBlackTree::<i32, &str, 10>::new();
+
+        tree.insert(10, "A");
+        tree.insert(20, "B");
+        tree.insert(5, "C");
+
+        tree.update(10, "Updated A");
+
+        assert_eq!(tree.search(&10), Some(&"Updated A"));
+        assert_eq!(tree.search(&20), Some(&"B"));
+        assert_eq!(tree.search(&5), Some(&"C"));
+        assert_eq!(tree.contains_key(&20), true);
+        assert_eq!(tree.contains_key(&100), false);
+
+        // Check iteration order (should be sorted by key)
+        let mut iter = tree.iter();
+        assert_eq!(iter.next(), Some((&5, &"C")));
+        assert_eq!(iter.next(), Some((&10, &"Updated A")));
+        assert_eq!(iter.next(), Some((&20, &"B")));
+        assert_eq!(iter.next(), None);
+
+        tree.remove(20);
+        assert_eq!(tree.search(&20), None);
+        assert_eq!(tree.contains_key(&20), false);
+    }
+
     #[test]
     fn test_utils(){
         let mut tree = setup_small_tree();