docs: add trie examples and benchmarks

Author: jeresoftx

Cargo.toml

@@ -85,6 +85,18 @@ path = "examples/soluciones/heap_top_k.rs"
 name = "solution_heap_dijkstra_frontier"
 path = "examples/soluciones/heap_dijkstra_frontier.rs"
 
+[[example]]
+name = "solution_trie_trace_prefixes"
+path = "examples/soluciones/trie_trace_prefixes.rs"
+
+[[example]]
+name = "solution_trie_autocomplete"
+path = "examples/soluciones/trie_autocomplete.rs"
+
+[[example]]
+name = "solution_trie_unicode_policy"
+path = "examples/soluciones/trie_unicode_policy.rs"
+
 [[bench]]
 name = "vector_bench"
 path = "benches/vector_bench.rs"
@@ -114,3 +126,8 @@ harness = false
 name = "heap_bench"
 path = "benches/heap_bench.rs"
 harness = false
+
+[[bench]]
+name = "trie_bench"
+path = "benches/trie_bench.rs"
+harness = false

benches/trie_bench.rs

@@ -0,0 +1,75 @@
+use rust_data_structures::trie::Trie;
+use std::collections::HashSet;
+use std::hint::black_box;
+use std::time::{Duration, Instant};
+
+const SIZE: usize = 10_000;
+
+fn main() {
+    let words = generate_words();
+
+    println!("trie benchmark (manual, std::time::Instant)");
+    println!("size: {SIZE}");
+    println!("trie lookup: {:?}", bench_trie_lookup(&words));
+    println!("hashset lookup: {:?}", bench_hashset_lookup(&words));
+    println!("trie prefix search: {:?}", bench_trie_prefix_search(&words));
+    println!(
+        "sorted vector prefix search: {:?}",
+        bench_sorted_vector_prefix_search(&words)
+    );
+}
+
+fn bench_trie_lookup(words: &[String]) -> Duration {
+    let mut trie = Trie::new();
+    for word in words {
+        trie.insert(word);
+    }
+
+    let start = Instant::now();
+    for word in words {
+        black_box(trie.contains(word));
+    }
+    start.elapsed()
+}
+
+fn bench_hashset_lookup(words: &[String]) -> Duration {
+    let set = words.iter().collect::<HashSet<_>>();
+
+    let start = Instant::now();
+    for word in words {
+        black_box(set.contains(word));
+    }
+    start.elapsed()
+}
+
+fn bench_trie_prefix_search(words: &[String]) -> Duration {
+    let mut trie = Trie::new();
+    for word in words {
+        trie.insert(word);
+    }
+
+    let start = Instant::now();
+    for prefix in ["course-0", "course-1", "course-9"] {
+        black_box(trie.words_with_prefix(prefix));
+    }
+    start.elapsed()
+}
+
+fn bench_sorted_vector_prefix_search(words: &[String]) -> Duration {
+    let mut sorted = words.to_vec();
+    sorted.sort();
+
+    let start = Instant::now();
+    for prefix in ["course-0", "course-1", "course-9"] {
+        let matches = sorted
+            .iter()
+            .filter(|word| word.starts_with(prefix))
+            .collect::<Vec<_>>();
+        black_box(matches);
+    }
+    start.elapsed()
+}
+
+fn generate_words() -> Vec<String> {
+    (0..SIZE).map(|index| format!("course-{index:05}")).collect()
+}

diagrams/07-trie.mmd

@@ -0,0 +1,32 @@
+flowchart TB
+    title["Trie: prefijos compartidos y terminales"]
+
+    root["root"]
+    c["c"]
+    a["a"]
+    r["r terminal: car"]
+    t1["t terminal: cart"]
+    t2["t terminal: cat"]
+    d["d"]
+    o["o"]
+    g["g terminal: dog"]
+
+    root --> c
+    c --> a
+    a --> r
+    r --> t1
+    a --> t2
+
+    root --> d
+    d --> o
+    o --> g
+
+    insert["insert(car)<br/>marca terminal al final"]
+    lookup["contains(ca)<br/>existe prefijo, no terminal"]
+    prefix["words_with_prefix(ca)<br/>recorre subarbol"]
+    remove["remove(car)<br/>desmarca terminal y poda si queda sin hijos"]
+
+    insert --> r
+    lookup --> a
+    prefix --> a
+    remove --> r

examples/soluciones/trie_autocomplete.rs

@@ -0,0 +1,20 @@
+use rust_data_structures::trie::Trie;
+
+fn main() {
+    let mut trie = Trie::new();
+    for word in ["app", "apple", "apply", "apt", "backend"] {
+        trie.insert(word);
+    }
+
+    let suggestions = autocomplete(&trie, "ap", 3);
+
+    assert_eq!(suggestions, vec!["app", "apple", "apply"]);
+    println!("{suggestions:?}");
+}
+
+fn autocomplete(trie: &Trie, prefix: &str, limit: usize) -> Vec<String> {
+    trie.words_with_prefix(prefix)
+        .into_iter()
+        .take(limit)
+        .collect()
+}

examples/soluciones/trie_trace_prefixes.rs

@@ -0,0 +1,15 @@
+use rust_data_structures::trie::Trie;
+
+fn main() {
+    let mut trie = Trie::new();
+    trie.insert("car");
+    trie.insert("cart");
+    trie.insert("cat");
+
+    assert!(trie.contains("car"));
+    assert!(!trie.contains("ca"));
+    assert!(trie.starts_with("ca"));
+    assert_eq!(trie.words_with_prefix("car"), vec!["car", "cart"]);
+
+    println!("{:?}", trie.words_with_prefix("ca"));
+}

examples/soluciones/trie_unicode_policy.rs

@@ -0,0 +1,15 @@
+use rust_data_structures::trie::Trie;
+
+fn main() {
+    let mut trie = Trie::new();
+    trie.insert("é");
+    trie.insert("e\u{301}");
+    trie.insert("🚀rust");
+
+    assert!(trie.contains("é"));
+    assert!(trie.contains("e\u{301}"));
+    assert!(trie.starts_with("🚀"));
+    assert_eq!(trie.words_with_prefix("🚀"), vec!["🚀rust"]);
+
+    println!("{:?}", trie.words_with_prefix(""));
+}

examples/trie_advanced.rs

@@ -0,0 +1,14 @@
+use rust_data_structures::trie::Trie;
+
+fn main() {
+    let mut trie = Trie::new();
+
+    trie.insert("tea");
+    trie.insert("team");
+    trie.insert("tear");
+    trie.remove("tea");
+
+    println!("tea: {}", trie.contains("tea"));
+    println!("team: {}", trie.contains("team"));
+    println!("nodos internos: {}", trie.node_count());
+}

examples/trie_basic.rs

@@ -0,0 +1,12 @@
+use rust_data_structures::trie::Trie;
+
+fn main() {
+    let mut dictionary = Trie::new();
+
+    dictionary.insert("rust");
+    dictionary.insert("runner");
+    dictionary.insert("route");
+
+    println!("contiene rust: {}", dictionary.contains("rust"));
+    println!("prefijo ru: {}", dictionary.starts_with("ru"));
+}

examples/trie_intermediate.rs

@@ -0,0 +1,12 @@
+use rust_data_structures::trie::Trie;
+
+fn main() {
+    let mut autocomplete = Trie::new();
+
+    autocomplete.insert("app");
+    autocomplete.insert("apple");
+    autocomplete.insert("apply");
+    autocomplete.insert("backend");
+
+    println!("{:?}", autocomplete.words_with_prefix("app"));
+}

examples/trie_real_case.rs

@@ -0,0 +1,19 @@
+use rust_data_structures::trie::Trie;
+
+fn main() {
+    let mut routes = Trie::new();
+
+    routes.insert("/courses");
+    routes.insert("/courses/rust-data-structures");
+    routes.insert("/docs");
+
+    let request_path = "/courses/rust";
+    println!(
+        "rutas que empiezan con /courses: {:?}",
+        routes.words_with_prefix("/courses")
+    );
+    println!(
+        "request {request_path} comparte prefijo: {}",
+        routes.starts_with("/courses")
+    );
+}