实现双端队列

/// 双端队列
#[derive(Debug)]
struct Deque<T> {
    capacity: usize,
    data: Vec<T>,
}

/// 实现双端队列
impl<T> Deque<T> {
    fn new(capacity: usize) -> Self {
        Self {
            capacity,
            data: Vec::with_capacity(capacity),
        }
    }

    /// 返回当前长度
    fn size(&self) -> usize {
        self.data.len()
    }

    /// 队列是否为空
    fn is_empty(&self) -> bool {
        self.data.len() == 0
    }

    /// Vec 末尾为队首，添加一个值到队首
    fn add_front(&mut self, value: T) -> Result<(), String> {
        if self.size() >= self.capacity {
            return Err("capacity exceeded".to_string());
        }

        self.data.push(value);

        Ok(())
    }

    /// 从队首移除一个值
    fn remove_front(&mut self) -> Option<T> {
        if self.is_empty() {
            return None;
        }

        self.data.pop()
    }

    // Vec 头部为队尾，添加一个值到队尾
    fn add_rear(&mut self, value: T) -> Result<(), String> {
        if self.size() >= self.capacity {
            return Err("capacity exceeded".to_string());
        }

        self.data.insert(0, value);

        Ok(())
    }

    // 从队尾移除一个值
    fn remove_rear(&mut self) -> Option<T> {
        if self.is_empty() {
            return None;
        }

        Some(self.data.remove(0))
    }
}

fn main() {
    let mut dequeue = Deque::new(5);

    // 依次从头部插入
    dequeue.add_front(1);
    dequeue.add_front(2);
    dequeue.add_front(3);

    // 打印 Deque { capacity: 5, data: [1, 2, 3] }
    println!("{:?}", dequeue);

    // 依次从尾部插入
    dequeue.add_rear(4);
    dequeue.add_rear(5);

    // 超出了最大容量
    if let Err(e) = dequeue.add_rear(6) {
        // 打印 capacity exceeded
        println!("{e}");
    }

    // 打印 Deque { capacity: 5, data: [5, 4, 1, 2, 3] }
    println!("{:?}", dequeue);

    // 打印 5
    println!("{}", dequeue.size());
}