data-structures-algorithms 1.0.0

Data Structures and Algorithms in Rust!
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#[cfg(test)]
mod heap_test {
    use crate::data_structures::heap::Heap;

    #[test]
    fn build_min_heap_test() {
        let values = vec![5, 6, 7, 8, 1, 2, 3];
        let mut min_heap = Heap::new(false);
        min_heap.values = values;
        min_heap.build_heap();
        
        assert_eq!(min_heap.values, vec![1, 5, 2, 8, 6, 7, 3]);
        assert_eq!(min_heap.values[0], 1);
        
        let len = min_heap.values.len();
        for i in 0..len / 2 {
            let left_child = 2 * i + 1;
            let right_child = 2 * i + 2;
            if left_child < len {
                assert!(min_heap.values[i] <= min_heap.values[left_child]);
            }
            if right_child < len {
                assert!(min_heap.values[i] <= min_heap.values[right_child]);
            }
        }
    }
    #[test]
    fn build_max_heap_test() {
        let values = vec![5, 6, 7, 8, 1, 2, 3];
        let mut max_heap = Heap::new(true);
        max_heap.values = values;
        max_heap.build_heap();
        
        assert_eq!(max_heap.values, vec![8, 6, 7, 5, 1, 2, 3]);
        assert_eq!(max_heap.values[0], 8);
        
        let len = max_heap.values.len();
        for i in 0..len / 2 {
            let left_child = 2 * i + 1;
            let right_child = 2 * i + 2;
            if left_child < len {
                assert!(max_heap.values[i] >= max_heap.values[left_child]);
            }
            if right_child < len {
                assert!(max_heap.values[i] >= max_heap.values[right_child]);
            }
        }
    }
}