数据结构与算法-Rust 版读书笔记-2线性数据结构-双端队列

1、双端队列

deque又称为双端队列，双端队列是与队列类似的项的有序集合。deque有两个端部：首端和尾端。deque不同于队列的地方就在于项的添加和删除是不受限制的，既可以从首尾两端添加项，也可以从首尾两端移除项。在某种意义上，这种混合线性结构提供了栈和队列的所有功能。

虽然deque拥有栈和队列的许多特性，但其不需要像它们一样强制地进行LIFO和FIFO排序，这取决于如何添加和删除数据。deque既可以当作栈使用，也可以当作队列使用，但最好不要如此，因为不同的数据结构都有自身的特性，它们均是为了不同的计算目的而设计的。

2、双端队列的 Rust 代码实现、运行结果

queue.rs

/*
 * @Description: 
 * @Author: tianyw
 * @Date: 2023-12-10 17:43:34
 * @LastEditTime: 2023-12-11 22:19:06
 * @LastEditors: tianyw
 */
// 定义队列
#[derive(Debug)]

pub struct Deque<T> { // pub 表示公开的
    cap: usize, // 容量
    data: Vec<T>, // 数据容器
}

impl<T> Deque<T> { // impl 用于定义类型的实现，如实现 new 方法、is_empty 方法等
    // 初始化空栈
    pub fn new(cap: usize) -> Self { 
        Self {
           cap: cap,
           data:Vec::with_capacity(cap)
        }
    }

    pub fn is_empty(&self) -> bool {
        0 == self.len()
    }

    pub fn is_full(&self) -> bool {
        self.len() == self.cap
    }

    pub fn len(&self) -> usize { // &self 只可读
        self.data.len()
    }

    // 清空
    pub fn clear(&mut self) { // &mut self 可读、可写
        self.data = Vec::with_capacity(self.cap)
    }

    // Vec 的末尾为队首
   pub fn add_front(&mut self, val: T) -> Result<(), String> {
    if self.len() == self.cap {
        return  Err("No space available".to_string());
    }
    self.data.push(val);
    Ok(())
   }

   // Vec 的首部为队尾
   pub fn add_rear(&mut self,val: T) -> Result<(), String>  {
    if self.len() == self.cap {
        return  Err("No space available".to_string());
    }
    self.data.insert(0,val);
    Ok(())
   }

   // 从队首移除数据
   pub fn remove_front(&mut self) -> Option<T> {
    if self.len() > 0 {
        self.data.pop()
    }else {
        None
    }
   }

   // 从队尾移除数据
   pub fn remove_rear(&mut self) -> Option<T> {
    if self.len() > 0 {
        Some(self.data.remove(0))
    }else {
        None
    }
   }

    // 以下是为双端队列实现的迭代功能
    // into_iter：双端队列改变，成为迭代器
    // iter: 双端队列不变，得到不可变迭代器
    // iter_mut: 双端队列不变，得到可变迭代器
    pub fn into_iter(self) -> IntoIter<T> {
        IntoIter(self)
    }

    pub fn iter(&self) -> Iter<T> {
        let mut iterator = Iter { stack: Vec::new() };
        for item in self.data.iter() {
            iterator.stack.push(item);
        }
        iterator
    }

    pub fn iter_mut(&mut self) -> IterMut<T> {
        let mut iterator = IterMut { stack: Vec::new() };
        for item in self.data.iter_mut() {
            iterator.stack.push(item);
        }
        iterator
    }

    
}

// 实现三种迭代功能
pub struct IntoIter<T>(Deque<T>);
impl<T:Clone> Iterator for IntoIter<T> {
    type Item = T;
    fn next(&mut self) -> Option<Self::Item> {
        // 元组的第一个元素不为空
        if !self.0.is_empty() {
            Some(self.0.data.remove(0))
        } else {
            None
        }
    }
}

pub struct Iter<'a,T:'a> { stack: Vec<&'a T>, }
impl<'a,T> Iterator for Iter<'a,T> {
    type Item = &'a T;
    fn next(&mut self) -> Option<Self::Item> {
        if 0 != self.stack.len() {
            Some(self.stack.remove(0)) // 索引移除
        }else {
            None
        }
    }
}

pub struct IterMut<'a,T:'a> { stack: Vec<&'a mut T> }
impl<'a,T> Iterator for IterMut<'a,T> {
    type Item = &'a mut T;
    fn next(&mut self) -> Option<Self::Item> {
       if 0 != self.stack.len() {
        Some(self.stack.remove(0))
       }else {
        None
       }
    }
}    

main.rs

/*
 * @Description:
 * @Author: tianyw
 * @Date: 2023-12-11 21:29:04
 * @LastEditTime: 2023-12-11 22:21:01
 * @LastEditors: tianyw
 */

mod deque;
fn main() {
    basic();
    iter();

    fn basic() {
        let mut d = deque::Deque::new(4);
        let _r1 = d.add_front(1);
        let _r2 = d.add_front(2);
        let _r3 = d.add_rear(3);
        let _r4 = d.add_rear(4); // 入队

        if let Err(error) = d.add_front(5) {
            println!("Enqueue error:{error}")
        }
        
        println!("{:?}",d);

        match d.remove_rear() {
            Some(data) => println!("remove rear data {data}"),
            None => println!("empty deque"),
        }

        match d.remove_front() {
            Some(data) => println!("remove front data {data}"),
            None => println!("empty deque"),
        }

        println!("empty: {},len: {}",d.is_empty(),d.len());
        println!("full: {},{:?}",d.is_full(),d);
        d.clear();
        println!("{:?}",d);
    }

    fn iter() {
        let mut d = deque::Deque::new(4);
        let _r1 = d.add_front(1);
        let _r2 = d.add_front(2);
        let _r3 = d.add_rear(3);
        let _r4 = d.add_rear(4);

        let sum1 = d.iter().sum::<i32>();
        let mut addend = 0;
        for item in d.iter_mut() {
            *item += 1;
            addend += 1;
        }
        let sum2 = d.iter().sum::<i32>(); // vec 的 sum 方法
        println!("{sum1} + {addend} = {sum2}");
        assert_eq!(14,d.into_iter().sum::<i32>());
    }
}

cargo run 运行结果

应用：回文检测

// palindrome_checker.rs
　
fn palindrome_checker(pal: &str) -> bool {
    // 数据入队
    let mut d = Deque::new(pal.len());
    for c in pal.chars() {
        let _r = d.add_rear(c);
    }
　
    let mut is_pal = true;
    while d.size() > 1 && is_pal {
        // 出队首尾字符
        let head = d.remove_front();
        let tail = d.remove_rear();
　
        // 比较首尾字符，若不同，则字符串非回文
        if head != tail {
            is_pal = false;
        }
    }
　
    is_pal
}
　
fn main() {
    let pal = "rustsur";
    let is_pal = palindrome_checker(pal);
    println!("{pal} is palindrome string: {is_pal}");
    // 输出“rustsur is palindrome string: true”
　
    let pal = "panda";
    let is_pal = palindrome_checker(pal);
    println!("{pal} is palindrome string: {is_pal}");
    // 输出“panda is palindrome string: false”
}