队列

  1. #[derive(Debug)]
  2. pub struct Queue<T> {
  3.     elements: Vec<T>,
  4. }
  6. impl<T: Clone> Queue<T> {
  7.     pub fn new() -> Queue<T> {
  8.         Queue {
  9.             elements: Vec::new(),
  10.         }
  11.     }
  13.     pub fn enqueue(&mut self, value: T) {
  14.         self.elements.push(value)
  15.     }
  17.     pub fn dequeue(&mut self) -> Result<T, &str> {
  18.         if !self.elements.is_empty() {
  19.             Ok(self.elements.remove(0usize))
  20.         } else {
  21.             Err("Queue is empty")
  22.         }
  23.     }
  25.     pub fn peek(&self) -> Result<&T, &str> {
  26.         match self.elements.first() {
  27.             Some(value) => Ok(value),
  28.             None => Err("Queue is empty"),
  29.         }
  30.     }
  32.     pub fn size(&self) -> usize {
  33.         self.elements.len()
  34.     }
  36.     pub fn is_empty(&self) -> bool {
  37.         self.elements.is_empty()
  38.     }
  39. }
  41. impl<T> Default for Queue<T> {
  42.     fn default() -> Queue<T> {
  43.         Queue {
  44.             elements: Vec::new(),
  45.         }
  46.     }
  47. }
  49. #[cfg(test)]
  50. mod tests {
  51.     use super::Queue;
  53.     #[test]
  54.     fn test_enqueue() {
  55.         let mut queue: Queue<u8> = Queue::new();
  56.         queue.enqueue(64);
  57.         assert_eq!(queue.is_empty(), false);
  58.     }
  60.     #[test]
  61.     fn test_dequeue() {
  62.         let mut queue: Queue<u8> = Queue::new();
  63.         queue.enqueue(32);
  64.         queue.enqueue(64);
  65.         let retrieved_dequeue = queue.dequeue();
  66.         assert!(retrieved_dequeue.is_ok());
  67.         assert_eq!(32, retrieved_dequeue.unwrap());
  68.     }
  70.     #[test]
  71.     fn test_peek() {
  72.         let mut queue: Queue<u8> = Queue::new();
  73.         queue.enqueue(8);
  74.         queue.enqueue(16);
  75.         let retrieved_peek = queue.peek();
  76.         assert!(retrieved_peek.is_ok());
  77.         assert_eq!(8, *retrieved_peek.unwrap());
  78.     }
  80.     #[test]
  81.     fn test_size() {
  82.         let mut queue: Queue<u8> = Queue::new();
  83.         queue.enqueue(8);
  84.         queue.enqueue(16);
  85.         assert_eq!(2, queue.size());
  86.     }
  87. }