PQ: Finished priority queue

Author: metame

src/priority_queue.rs

@@ -43,8 +43,7 @@ impl<T: Default + PartialOrd> PriorityQueue<T> {
         } else if self.len() == 1 {
             self.queue.remove(1)
         } else {
-            let end = self.len() - 1;
-            self.queue.swap(1, end);
+            self.queue.swap(1, self.len());
             let v = self.queue.pop_back();
             self.heapify_down(1);
             v
@@ -57,24 +56,36 @@ impl<T: Default + PartialOrd> PriorityQueue<T> {
         self.heapify_up(i);
     }
 
-    // child
-    // l (i * 2)
-    // r (i * 2) + 1
-    // parent
-    // (i/2)
+    fn left(&self, i: usize) -> (usize, Option<&T>) {
+        let l_i = i * 2;
+        (l_i, self.queue.get(l_i))
+    }
+
+    fn right(&self, i: usize) -> (usize, Option<&T>) {
+        let r_i = (i * 2) + 1;
+        (r_i, self.queue.get(r_i))
+    }
+
+    fn min_child (&self, i: usize) -> (usize, Option<&T>) {
+        let (l_i, l) = self.left(i);
+        let (r_i, r) = self.right(i);
+
+        match (l, r) {
+            (Some(l), Some(r)) if l > r => (r_i, Some(r)),
+            (Some(l), _) => (l_i, Some(l)),
+            _ => (0, None),
+        }
+    }
+
+    /// Panics if i is out of bounds
     fn heapify_down(&mut self, i: usize) {
-        let v = self.queue.get(i);
-        let l = self.queue.get(i * 2);
-        let r = self.queue.get((i * 2) + 1);
-        // find min child
+        let v = &self.queue[i];
         // if min child is < v, swap with min child
-        match (v, l, r) {
-            (Some(v), Some(l), _) if l < v => {
-            },
-            (Some(v), _, Some(r)) if r < v => {
-
-            },
-            _ => (),
+        if let (c_i, Some(child)) = self.min_child(i) {
+            if child < v {
+                self.queue.swap(c_i, i);
+                self.heapify_down(c_i);
+            }
         }
     }
 
@@ -95,17 +106,25 @@ mod tests {
     use super::*;
 
     #[test]
-    fn push_works() {
+    fn pq_works() {
         let mut pq = PriorityQueue::new();
         assert_eq!(None, pq.peak());
+        assert_eq!(None, pq.pop());
         pq.push(50);
         assert_eq!(Some(&50), pq.peak());
         pq.push(75);
         pq.push(100);
-        assert_eq!(Some(&50), pq.peak());
         dbg!(&pq);
+        assert_eq!(Some(&50), pq.peak());
         pq.push(30);
         dbg!(&pq);
+        assert_eq!(Some(&30), pq.peak());
+        assert_eq!(Some(30), pq.pop());
+        dbg!(&pq);
+        assert_eq!(Some(50), pq.pop());
+        assert_eq!(Some(75), pq.pop());
+        assert_eq!(Some(100), pq.pop());
+        assert_eq!(None, pq.pop());
     }
 
 }