union-find time

src/lib.rs

···
 pub mod day7;
 pub mod day8;
 mod spatial;
+mod union_find;
 
 #[cfg(test)]
 mod tests {

src/union_find.rs

···
+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,
+}