Data Structures and Algorithms-Rust Edition Reading Notes-2 Linear Data Structure-Double-Ended Queue
1. Double-ended queue
Deque is also called a double-ended queue. A double-ended queue is an ordered collection of items similar to a queue. A deque has two ends: the head end and the tail end. The difference between deque and queue is that the addition and deletion of items are unrestricted. Items can be added from both ends, and items can also be removed from both ends. In a sense, this hybrid linear structure provides all the functionality of a stack and a queue.
While deques share many of the features of stacks and queues, they do not require the same mandatory LIFO and FIFO ordering, depending on how data is added and removed. Deque can be used as either a stack or a queue, but it is best not to do this because different data structures have their own characteristics and are designed for different computing purposes.
2. Rust code implementation and running results of double-ended queue
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 running results
Application: Palindrome detection
// 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”
}