From f753fc5ba951faea13246972bb72f3b63585d5e0 Mon Sep 17 00:00:00 2001
From: Devon Sawatsky <devon@nove.dev>
Date: Mon, 8 Dec 2025 05:23:30 +0000
Subject: [PATCH] union-find time

---
 src/lib.rs        |  1 +
 src/union_find.rs | 71 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+)
 create mode 100644 src/union_find.rs

diff --git a/src/lib.rs b/src/lib.rs
index dfb8769..daeb27f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -122,6 +122,7 @@ pub mod day6;
 pub mod day7;
 pub mod day8;
 mod spatial;
+mod union_find;
 
 #[cfg(test)]
 mod tests {
diff --git a/src/union_find.rs b/src/union_find.rs
new file mode 100644
index 0000000..f038d57
--- /dev/null
+++ b/src/union_find.rs
@@ -0,0 +1,71 @@
+pub struct UnionFind<N> {
+    nodes: Vec<Node<N>>,
+}
+
+impl<N> Default for UnionFind<N> {
+    fn default() -> Self {
+        Self { nodes: vec![] }
+    }
+}
+
+impl<N> UnionFind<N>
+where
+    N: Clone + PartialEq,
+{
+    //returns a pointer to this element that can be used in union and find operations later
+    pub fn make_set(&mut self, element: N) -> usize {
+        let index = self.nodes.iter().enumerate().find(|(_, node)| node.inner == element);
+        if let Some(index) = index {
+            index.0
+        } else {
+            let new_node = Node {
+                parent: self.nodes.len(),
+                inner: element,
+            };
+            self.nodes.push(new_node);
+            self.nodes.len() - 1
+        }
+    }
+
+    /// operates on "pointers", which in this case are indexes into the internal vec
+    /// but can be considered opaque to a user
+    pub fn find(&mut self, element: usize) -> usize {
+        let root_index = self.root_index(element);
+
+        //take the opportunity to optimize??
+        let mut x_index;
+        let mut x_reference = &mut self.nodes[element];
+        
+        while x_reference.parent != root_index {
+            let parent_index = x_reference.parent;
+            x_reference.parent = root_index;
+            x_index = parent_index;
+            x_reference = &mut self.nodes[x_index];
+        }
+
+        root_index
+    }
+
+    fn root_index(&self, element_index: usize) -> usize {
+        let mut root_index = element_index;
+        let mut root_reference = &self.nodes[root_index];
+
+        while root_reference.parent != root_index {
+            root_index = root_reference.parent;
+            root_reference = &self.nodes[root_index];
+        }
+        root_index
+    }
+
+    pub fn union(&mut self, elem1: usize, elem2: usize) {
+        todo!()
+    }
+}
+
+pub struct Node<N> {
+    //index into the vec of nodes contained within the data structure
+    //nodes are never removed or shifted within that vec
+    //root nodes point to themselves
+    parent: usize,
+    inner: N,
+}
-- 
2.51.2