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
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104

/// Strcuture holding the vector of elements and the size of the vector for fast lookup
pub struct Rusted {
    vector: Vec<i32>,
    size: i32,
}

impl Rusted {
    /// create a new sorted list
    pub fn new() -> Rusted {
        return Rusted {
            vector: Vec::new(),
            size: 0,
        };
    }
    /// insert a new elemenet into the list by using the binary search method
    /// Complexity : O(log n)
    pub fn insert(&mut self, element: i32) {
        self.insert_element_binary(element, 0, self.size);
    }
    /// retreave the current size of the list
    pub fn get_size(&self) -> i32 {
        return self.size;
    }
    /// retreve the element at a position index by an i32.
    /// If index smaller 0 or bigger size, will return -1
    pub fn get_element_at(&self, index: i32) -> i32 {
        if index < 0 {
            return -1;
        }
        if index > self.size - 1 {
            return -1;
        }
        return self.vector.get(index as usize).unwrap().clone();
    }
    /// get all element as a vector
    pub fn get_list(&self) -> Vec<i32> {
        return self.vector.clone();
    }
    /// pop out the last element of the list
    pub fn pop(&mut self) -> i32 {
        self.size -= 1;
        return self.vector.pop().unwrap();
    }
    /// Remvoing any dublicates in the list
    /// Having a Complexity of O(n)
    pub fn convert_to_set(&mut self) {
        self.vector.dedup();
        self.size = self.vector.len() as i32;
    }

    fn insert_element_binary(&mut self, element: i32, min: i32, max: i32) {
        if max == 0 {
            self.size += 1;
            self.vector.push(element);
            return;
        }
        if max == 1 {
            if element > self.vector[0] {
                self.vector.push(element);
            } else {
                self.vector.insert(0, element);
            }
            return;
        }
        if max - min == 1 {
            self.size += 1;
            if element < self.vector[max as usize] {
                self.vector.insert((max) as usize, element);
            } else {
                self.vector.insert((max - 1) as usize, element);
            }
            return;
        } else {
            let middle = ((max + min) / 2) as i32;
            let middle_value = self.vector[middle as usize];
            if element < middle_value {
                self.insert_element_binary(element, min, middle + 1);
            } else {
                self.insert_element_binary(element, middle, max);
            }
        }
    }
    //
    //return the sum for a rusted list as a i32
    pub fn sum(&self) -> i32 {
        let mut total_value: i32 = 0;
        for i in &self.vector {
            let val = self.vector[*i as usize];
            total_value += val;
        }
        return total_value;
    }
    //return the median for a rusted list, which can be used to form graphs and statistics in a
    //less error proune way when compared to the average
    pub fn median(self) -> i32 {
        let vec_size = self.vector.len();
        if vec_size % 2 == 0 {
            let middle = vec_size / 2;
            return (self.vector[middle as usize] + self.vector[middle - 1 as usize]) / 2;
        } else {
            return self.vector[vec_size / 2 as usize];
        }
    }
}