added demo in main for complete algos. started dijkstras

src/dijkstras.rs

@@ -0,0 +1,102 @@
+use std::collections::{HashMap, HashSet};
+
+#[cfg(test)]
+mod tests {
+    use super::dijkstras_shortest_path;
+    #[test]
+    fn dijkstras_shortest_path_primeagen_class_test(){
+        //      (B) --- (E) ---- (F)
+        //    /  |       |       /|
+        // (A)   | ------|------- |
+        //    \  |/      |        |
+        //      (C) --- (D) ---- (G)
+        let mut graph:WeightedAdjacencyList<&str,usize> = WeightedAdjacencyList::new();
+        graph.add_vertex("A");
+        graph.add_vertex("B");
+        graph.add_vertex("C");
+        graph.add_vertex("D");
+        graph.add_vertex("E");
+        graph.add_vertex("F");
+        graph.add_edge("A","B",3);
+        graph.add_edge("A","C",1);
+        graph.add_edge("B","A",3);
+        graph.add_edge("B","C",4);
+        graph.add_edge("B","E",1);
+        graph.add_edge("C","B",4);
+        graph.add_edge("C","D",7);
+        graph.add_edge("C","A",1);
+        graph.add_edge("D","C",7);
+        graph.add_edge("D","E",5);
+        graph.add_edge("D","G",1);
+        graph.add_edge("E","B",1);
+        graph.add_edge("E","D",5);
+        graph.add_edge("E","F",2);
+        graph.add_edge("F","G",1);
+        graph.add_edge("F","E",2);
+        graph.add_edge("F","C",18);
+        graph.add_edge("G","D",1);
+        graph.add_edge("G","F",1);
+        dijkstras_shortest_path(source,sink,graph);
+    }
+}
+// Define a struct to represent the adjacency list with weighted edges
+pub struct WeightedAdjacencyList<T, W> {
+    vertices: HashMap<T, HashMap<T, W>>,
+}
+
+impl<T, W> WeightedAdjacencyList<T, W>
+where
+    T: std::hash::Hash + Eq + Clone,
+{
+    // Constructor to create a new weighted adjacency list
+    fn new() -> Self {
+        WeightedAdjacencyList {
+            vertices: HashMap::new(),
+        }
+    }
+
+    // Method to add a vertex to the adjacency list
+    fn add_vertex(&mut self, vertex: T) {
+        self.vertices.entry(vertex).or_insert(HashMap::new());
+    }
+
+    // Method to add an edge with weight between two vertices
+    fn add_edge(&mut self, from: T, to: T, weight: W) {
+        // Ensure both vertices exist in the adjacency list
+        self.add_vertex(from.clone());
+        self.add_vertex(to.clone());
+
+        // Add the edge from 'from' to 'to' with weight
+        self.vertices.get_mut(&from).unwrap().insert(to, weight);
+    }
+
+    // Method to get the weight of an edge between two vertices
+    fn get_weight(&self, from: &T, to: &T) -> Option<&W> {
+        self.vertices.get(from)?.get(to)
+    }
+
+    // Method to get the neighbors of a vertex
+    fn get_neighbors(&self, vertex: &T) -> Option<&HashMap<T, W>> {
+        self.vertices.get(vertex)
+    }
+}
+fn has_unvisited(seen: &[bool], dists: &[f64]) -> bool {
+    return seen.iter().enumerate().any(|(i, &s)| !s && dists[i] < f64::INFINITY);
+}
+fn get_lowest_unvisited(seen: &[bool], dists: &[f64]) -> usize {
+    let mut idx = usize::MAX;
+    let mut lowest_distance = f64::INFINITY;
+    for (i, &is_seen) in seen.iter().enumerate() {
+        if is_seen {
+            continue;
+        }
+        if lowest_distance > dists[i] {
+            lowest_distance = dists[i];
+            idx = i;
+        }
+    }
+    idx
+}
+pub fn dijkstras_shortest_path(source:usize,sink:usize,mut graph:WeightedAdjacencyList<&str,usize>){
+    
+}