mirror of
https://github.com/krahets/hello-algo.git
synced 2026-07-10 22:46:07 +00:00
Translate all code to English (#1836)
* Review the EN heading format. * Fix pythontutor headings. * Fix pythontutor headings. * bug fixes * Fix headings in **/summary.md * Revisit the CN-to-EN translation for Python code using Claude-4.5 * Revisit the CN-to-EN translation for Java code using Claude-4.5 * Revisit the CN-to-EN translation for Cpp code using Claude-4.5. * Fix the dictionary. * Fix cpp code translation for the multipart strings. * Translate Go code to English. * Update workflows to test EN code. * Add EN translation for C. * Add EN translation for CSharp. * Add EN translation for Swift. * Trigger the CI check. * Revert. * Update en/hash_map.md * Add the EN version of Dart code. * Add the EN version of Kotlin code. * Add missing code files. * Add the EN version of JavaScript code. * Add the EN version of TypeScript code. * Fix the workflows. * Add the EN version of Ruby code. * Add the EN version of Rust code. * Update the CI check for the English version code. * Update Python CI check. * Fix cmakelists for en/C code. * Fix Ruby comments
This commit is contained in:
Yudong Jin
@@ -0,0 +1,160 @@
|
||||
/*
|
||||
* File: array_deque.rs
|
||||
* Created Time: 2023-03-11
|
||||
* Author: codingonion (coderonion@gmail.com)
|
||||
*/
|
||||
use hello_algo_rust::include::print_util;
|
||||
/* Double-ended queue based on circular array implementation */
|
||||
struct ArrayDeque<T> {
|
||||
nums: Vec<T>, // Array for storing double-ended queue elements
|
||||
front: usize, // Front pointer, points to the front of the queue element
|
||||
que_size: usize, // Double-ended queue length
|
||||
}
|
||||
|
||||
impl<T: Copy + Default> ArrayDeque<T> {
|
||||
/* Constructor */
|
||||
pub fn new(capacity: usize) -> Self {
|
||||
Self {
|
||||
nums: vec![T::default(); capacity],
|
||||
front: 0,
|
||||
que_size: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/* Get the capacity of the double-ended queue */
|
||||
pub fn capacity(&self) -> usize {
|
||||
self.nums.len()
|
||||
}
|
||||
|
||||
/* Get the length of the double-ended queue */
|
||||
pub fn size(&self) -> usize {
|
||||
self.que_size
|
||||
}
|
||||
|
||||
/* Check if the double-ended queue is empty */
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.que_size == 0
|
||||
}
|
||||
|
||||
/* Calculate circular array index */
|
||||
fn index(&self, i: i32) -> usize {
|
||||
// Use modulo operation to wrap the array head and tail together
|
||||
// When i passes the tail of the array, return to the head
|
||||
// When i passes the head of the array, return to the tail
|
||||
((i + self.capacity() as i32) % self.capacity() as i32) as usize
|
||||
}
|
||||
|
||||
/* Front of the queue enqueue */
|
||||
pub fn push_first(&mut self, num: T) {
|
||||
if self.que_size == self.capacity() {
|
||||
println!("Double-ended queue is full");
|
||||
return;
|
||||
}
|
||||
// Use modulo operation to wrap front around to the tail after passing the head of the array
|
||||
// Add num to the front of the queue
|
||||
self.front = self.index(self.front as i32 - 1);
|
||||
// Add num to front of queue
|
||||
self.nums[self.front] = num;
|
||||
self.que_size += 1;
|
||||
}
|
||||
|
||||
/* Rear of the queue enqueue */
|
||||
pub fn push_last(&mut self, num: T) {
|
||||
if self.que_size == self.capacity() {
|
||||
println!("Double-ended queue is full");
|
||||
return;
|
||||
}
|
||||
// Use modulo operation to wrap rear around to the head after passing the tail of the array
|
||||
let rear = self.index(self.front as i32 + self.que_size as i32);
|
||||
// Front pointer moves one position backward
|
||||
self.nums[rear] = num;
|
||||
self.que_size += 1;
|
||||
}
|
||||
|
||||
/* Rear of the queue dequeue */
|
||||
fn pop_first(&mut self) -> T {
|
||||
let num = self.peek_first();
|
||||
// Move front pointer backward by one position
|
||||
self.front = self.index(self.front as i32 + 1);
|
||||
self.que_size -= 1;
|
||||
num
|
||||
}
|
||||
|
||||
/* Access rear of the queue element */
|
||||
fn pop_last(&mut self) -> T {
|
||||
let num = self.peek_last();
|
||||
self.que_size -= 1;
|
||||
num
|
||||
}
|
||||
|
||||
/* Return list for printing */
|
||||
fn peek_first(&self) -> T {
|
||||
if self.is_empty() {
|
||||
panic!("Deque is empty")
|
||||
};
|
||||
self.nums[self.front]
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
fn peek_last(&self) -> T {
|
||||
if self.is_empty() {
|
||||
panic!("Deque is empty")
|
||||
};
|
||||
// Initialize double-ended queue
|
||||
let last = self.index(self.front as i32 + self.que_size as i32 - 1);
|
||||
self.nums[last]
|
||||
}
|
||||
|
||||
/* Return array for printing */
|
||||
fn to_array(&self) -> Vec<T> {
|
||||
// Elements enqueue
|
||||
let mut res = vec![T::default(); self.que_size];
|
||||
let mut j = self.front;
|
||||
for i in 0..self.que_size {
|
||||
res[i] = self.nums[self.index(j as i32)];
|
||||
j += 1;
|
||||
}
|
||||
res
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
fn main() {
|
||||
/* Get the length of the double-ended queue */
|
||||
let mut deque = ArrayDeque::new(10);
|
||||
deque.push_last(3);
|
||||
deque.push_last(2);
|
||||
deque.push_last(5);
|
||||
print!("Double-ended queue deque = ");
|
||||
print_util::print_array(&deque.to_array());
|
||||
|
||||
/* Update element */
|
||||
let peek_first = deque.peek_first();
|
||||
print!("\nFront element peek_first = {}", peek_first);
|
||||
let peek_last = deque.peek_last();
|
||||
print!("\nRear element peek_last = {}", peek_last);
|
||||
|
||||
/* Elements enqueue */
|
||||
deque.push_last(4);
|
||||
print!("\nAfter element 4 enqueues at rear, deque = ");
|
||||
print_util::print_array(&deque.to_array());
|
||||
deque.push_first(1);
|
||||
print!("\nAfter element 1 enqueues at front, deque = ");
|
||||
print_util::print_array(&deque.to_array());
|
||||
|
||||
/* Element dequeue */
|
||||
let pop_last = deque.pop_last();
|
||||
print!("\nDequeue rear element = {}, after dequeue deque = ", pop_last);
|
||||
print_util::print_array(&deque.to_array());
|
||||
let pop_first = deque.pop_first();
|
||||
print!("\nDequeue front element = {}, after dequeue deque = ", pop_first);
|
||||
print_util::print_array(&deque.to_array());
|
||||
|
||||
/* Get the length of the double-ended queue */
|
||||
let size = deque.size();
|
||||
print!("\nDeque length size = {}", size);
|
||||
|
||||
/* Check if the double-ended queue is empty */
|
||||
let is_empty = deque.is_empty();
|
||||
print!("\nIs deque empty = {}", is_empty);
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
/*
|
||||
* File: array_queue.rs
|
||||
* Created Time: 2023-02-06
|
||||
* Author: WSL0809 (wslzzy@outlook.com)
|
||||
*/
|
||||
|
||||
/* Queue based on circular array implementation */
|
||||
struct ArrayQueue<T> {
|
||||
nums: Vec<T>, // Array for storing queue elements
|
||||
front: i32, // Front pointer, points to the front of the queue element
|
||||
que_size: i32, // Queue length
|
||||
que_capacity: i32, // Queue capacity
|
||||
}
|
||||
|
||||
impl<T: Copy + Default> ArrayQueue<T> {
|
||||
/* Constructor */
|
||||
fn new(capacity: i32) -> ArrayQueue<T> {
|
||||
ArrayQueue {
|
||||
nums: vec![T::default(); capacity as usize],
|
||||
front: 0,
|
||||
que_size: 0,
|
||||
que_capacity: capacity,
|
||||
}
|
||||
}
|
||||
|
||||
/* Get the capacity of the queue */
|
||||
fn capacity(&self) -> i32 {
|
||||
self.que_capacity
|
||||
}
|
||||
|
||||
/* Get the length of the queue */
|
||||
fn size(&self) -> i32 {
|
||||
self.que_size
|
||||
}
|
||||
|
||||
/* Check if the queue is empty */
|
||||
fn is_empty(&self) -> bool {
|
||||
self.que_size == 0
|
||||
}
|
||||
|
||||
/* Enqueue */
|
||||
fn push(&mut self, num: T) {
|
||||
if self.que_size == self.capacity() {
|
||||
println!("Queue is full");
|
||||
return;
|
||||
}
|
||||
// Use modulo operation to wrap rear around to the head after passing the tail of the array
|
||||
// Add num to the rear of the queue
|
||||
let rear = (self.front + self.que_size) % self.que_capacity;
|
||||
// Front pointer moves one position backward
|
||||
self.nums[rear as usize] = num;
|
||||
self.que_size += 1;
|
||||
}
|
||||
|
||||
/* Dequeue */
|
||||
fn pop(&mut self) -> T {
|
||||
let num = self.peek();
|
||||
// Move front pointer backward by one position, if it passes the tail, return to array head
|
||||
self.front = (self.front + 1) % self.que_capacity;
|
||||
self.que_size -= 1;
|
||||
num
|
||||
}
|
||||
|
||||
/* Return list for printing */
|
||||
fn peek(&self) -> T {
|
||||
if self.is_empty() {
|
||||
panic!("index out of bounds");
|
||||
}
|
||||
self.nums[self.front as usize]
|
||||
}
|
||||
|
||||
/* Return array */
|
||||
fn to_vector(&self) -> Vec<T> {
|
||||
let cap = self.que_capacity;
|
||||
let mut j = self.front;
|
||||
let mut arr = vec![T::default(); cap as usize];
|
||||
for i in 0..self.que_size {
|
||||
arr[i as usize] = self.nums[(j % cap) as usize];
|
||||
j += 1;
|
||||
}
|
||||
arr
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
fn main() {
|
||||
/* Access front of the queue element */
|
||||
let capacity = 10;
|
||||
let mut queue = ArrayQueue::new(capacity);
|
||||
|
||||
/* Elements enqueue */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
queue.push(5);
|
||||
queue.push(4);
|
||||
println!("Queue queue = {:?}", queue.to_vector());
|
||||
|
||||
/* Return list for printing */
|
||||
let peek = queue.peek();
|
||||
println!("Front element peek = {}", peek);
|
||||
|
||||
/* Element dequeue */
|
||||
let pop = queue.pop();
|
||||
println!(
|
||||
"Dequeue element pop = {:?}, after dequeue queue = {:?}",
|
||||
pop,
|
||||
queue.to_vector()
|
||||
);
|
||||
|
||||
/* Get the length of the queue */
|
||||
let size = queue.size();
|
||||
println!("Queue length size = {}", size);
|
||||
|
||||
/* Check if the queue is empty */
|
||||
let is_empty = queue.is_empty();
|
||||
println!("Is queue empty = {}", is_empty);
|
||||
|
||||
/* Test circular array */
|
||||
for i in 0..10 {
|
||||
queue.push(i);
|
||||
queue.pop();
|
||||
println!("After round {:?} of enqueue + dequeue, queue = {:?}", i, queue.to_vector());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
/*
|
||||
* File: array_stack.rs
|
||||
* Created Time: 2023-02-05
|
||||
* Author: WSL0809 (wslzzy@outlook.com), codingonion (coderonion@gmail.com)
|
||||
*/
|
||||
|
||||
use hello_algo_rust::include::print_util;
|
||||
|
||||
/* Stack based on array implementation */
|
||||
struct ArrayStack<T> {
|
||||
stack: Vec<T>,
|
||||
}
|
||||
|
||||
impl<T> ArrayStack<T> {
|
||||
/* Access top of the stack element */
|
||||
fn new() -> ArrayStack<T> {
|
||||
ArrayStack::<T> {
|
||||
stack: Vec::<T>::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/* Get the length of the stack */
|
||||
fn size(&self) -> usize {
|
||||
self.stack.len()
|
||||
}
|
||||
|
||||
/* Check if the stack is empty */
|
||||
fn is_empty(&self) -> bool {
|
||||
self.size() == 0
|
||||
}
|
||||
|
||||
/* Push */
|
||||
fn push(&mut self, num: T) {
|
||||
self.stack.push(num);
|
||||
}
|
||||
|
||||
/* Pop */
|
||||
fn pop(&mut self) -> Option<T> {
|
||||
self.stack.pop()
|
||||
}
|
||||
|
||||
/* Return list for printing */
|
||||
fn peek(&self) -> Option<&T> {
|
||||
if self.is_empty() {
|
||||
panic!("Stack is empty")
|
||||
};
|
||||
self.stack.last()
|
||||
}
|
||||
|
||||
/* Return &Vec */
|
||||
fn to_array(&self) -> &Vec<T> {
|
||||
&self.stack
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
fn main() {
|
||||
// Access top of the stack element
|
||||
let mut stack = ArrayStack::<i32>::new();
|
||||
|
||||
// Elements push onto stack
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
print!("Stack stack = ");
|
||||
print_util::print_array(stack.to_array());
|
||||
|
||||
// Return list for printing
|
||||
let peek = stack.peek().unwrap();
|
||||
print!("\nTop element peek = {}", peek);
|
||||
|
||||
// Element pop from stack
|
||||
let pop = stack.pop().unwrap();
|
||||
print!("\nPop element pop = {pop}, after pop stack = ");
|
||||
print_util::print_array(stack.to_array());
|
||||
|
||||
// Get the length of the stack
|
||||
let size = stack.size();
|
||||
print!("\nStack length size = {size}");
|
||||
|
||||
// Check if empty
|
||||
let is_empty = stack.is_empty();
|
||||
print!("\nIs stack empty = {is_empty}");
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
/*
|
||||
* File: deque.rs
|
||||
* Created Time: 2023-02-05
|
||||
* Author: codingonion (coderonion@gmail.com), xBLACKICEx (xBLACKICEx@outlook.com)
|
||||
*/
|
||||
|
||||
use hello_algo_rust::include::print_util;
|
||||
use std::collections::VecDeque;
|
||||
|
||||
/* Driver Code */
|
||||
pub fn main() {
|
||||
// Get the length of the double-ended queue
|
||||
let mut deque: VecDeque<i32> = VecDeque::new();
|
||||
deque.push_back(3);
|
||||
deque.push_back(2);
|
||||
deque.push_back(5);
|
||||
print!("Double-ended queue deque = ");
|
||||
print_util::print_queue(&deque);
|
||||
|
||||
// Update element
|
||||
let peek_first = deque.front().unwrap();
|
||||
print!("\nFront element peekFirst = {peek_first}");
|
||||
let peek_last = deque.back().unwrap();
|
||||
print!("\nRear element peekLast = {peek_last}");
|
||||
|
||||
/* Elements enqueue */
|
||||
deque.push_back(4);
|
||||
print!("\nAfter element 4 enqueues at rear, deque = ");
|
||||
print_util::print_queue(&deque);
|
||||
deque.push_front(1);
|
||||
print!("\nAfter element 1 enqueues at front, deque = ");
|
||||
print_util::print_queue(&deque);
|
||||
|
||||
// Element dequeue
|
||||
let pop_last = deque.pop_back().unwrap();
|
||||
print!("\nDequeue rear element = {pop_last}, after dequeue deque = ");
|
||||
print_util::print_queue(&deque);
|
||||
let pop_first = deque.pop_front().unwrap();
|
||||
print!("\nDequeue front element = {pop_first}, after dequeue deque = ");
|
||||
print_util::print_queue(&deque);
|
||||
|
||||
// Get the length of the double-ended queue
|
||||
let size = deque.len();
|
||||
print!("\nDeque length size = {size}");
|
||||
|
||||
// Check if the double-ended queue is empty
|
||||
let is_empty = deque.is_empty();
|
||||
print!("\nIs deque empty = {is_empty}");
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
/*
|
||||
* File: linkedlist_deque.rs
|
||||
* Created Time: 2023-03-11
|
||||
* Author: codingonion (coderonion@gmail.com)
|
||||
*/
|
||||
|
||||
use hello_algo_rust::include::print_util;
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::rc::Rc;
|
||||
|
||||
/* Doubly linked list node */
|
||||
pub struct ListNode<T> {
|
||||
pub val: T, // Node value
|
||||
pub next: Option<Rc<RefCell<ListNode<T>>>>, // Successor node pointer
|
||||
pub prev: Option<Rc<RefCell<ListNode<T>>>>, // Predecessor node pointer
|
||||
}
|
||||
|
||||
impl<T> ListNode<T> {
|
||||
pub fn new(val: T) -> Rc<RefCell<ListNode<T>>> {
|
||||
Rc::new(RefCell::new(ListNode {
|
||||
val,
|
||||
next: None,
|
||||
prev: None,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
/* Double-ended queue based on doubly linked list implementation */
|
||||
#[allow(dead_code)]
|
||||
pub struct LinkedListDeque<T> {
|
||||
front: Option<Rc<RefCell<ListNode<T>>>>, // Head node front
|
||||
rear: Option<Rc<RefCell<ListNode<T>>>>, // Tail node rear
|
||||
que_size: usize, // Length of the double-ended queue
|
||||
}
|
||||
|
||||
impl<T: Copy> LinkedListDeque<T> {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
front: None,
|
||||
rear: None,
|
||||
que_size: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/* Get the length of the double-ended queue */
|
||||
pub fn size(&self) -> usize {
|
||||
return self.que_size;
|
||||
}
|
||||
|
||||
/* Check if the double-ended queue is empty */
|
||||
pub fn is_empty(&self) -> bool {
|
||||
return self.que_size == 0;
|
||||
}
|
||||
|
||||
/* Enqueue operation */
|
||||
fn push(&mut self, num: T, is_front: bool) {
|
||||
let node = ListNode::new(num);
|
||||
// Front of the queue enqueue operation
|
||||
if is_front {
|
||||
match self.front.take() {
|
||||
// If the linked list is empty, make both front and rear point to node
|
||||
None => {
|
||||
self.rear = Some(node.clone());
|
||||
self.front = Some(node);
|
||||
}
|
||||
// Add node to the head of the linked list
|
||||
Some(old_front) => {
|
||||
old_front.borrow_mut().prev = Some(node.clone());
|
||||
node.borrow_mut().next = Some(old_front);
|
||||
self.front = Some(node); // Update head node
|
||||
}
|
||||
}
|
||||
}
|
||||
// Rear of the queue enqueue operation
|
||||
else {
|
||||
match self.rear.take() {
|
||||
// If the linked list is empty, make both front and rear point to node
|
||||
None => {
|
||||
self.front = Some(node.clone());
|
||||
self.rear = Some(node);
|
||||
}
|
||||
// Add node to the tail of the linked list
|
||||
Some(old_rear) => {
|
||||
old_rear.borrow_mut().next = Some(node.clone());
|
||||
node.borrow_mut().prev = Some(old_rear);
|
||||
self.rear = Some(node); // Update tail node
|
||||
}
|
||||
}
|
||||
}
|
||||
self.que_size += 1; // Update queue length
|
||||
}
|
||||
|
||||
/* Front of the queue enqueue */
|
||||
pub fn push_first(&mut self, num: T) {
|
||||
self.push(num, true);
|
||||
}
|
||||
|
||||
/* Rear of the queue enqueue */
|
||||
pub fn push_last(&mut self, num: T) {
|
||||
self.push(num, false);
|
||||
}
|
||||
|
||||
/* Dequeue operation */
|
||||
fn pop(&mut self, is_front: bool) -> Option<T> {
|
||||
// If queue is empty, return None directly
|
||||
if self.is_empty() {
|
||||
return None;
|
||||
};
|
||||
// Temporarily store head node value
|
||||
if is_front {
|
||||
self.front.take().map(|old_front| {
|
||||
match old_front.borrow_mut().next.take() {
|
||||
Some(new_front) => {
|
||||
new_front.borrow_mut().prev.take();
|
||||
self.front = Some(new_front); // Update head node
|
||||
}
|
||||
None => {
|
||||
self.rear.take();
|
||||
}
|
||||
}
|
||||
self.que_size -= 1; // Update queue length
|
||||
old_front.borrow().val
|
||||
})
|
||||
}
|
||||
// Temporarily store tail node value
|
||||
else {
|
||||
self.rear.take().map(|old_rear| {
|
||||
match old_rear.borrow_mut().prev.take() {
|
||||
Some(new_rear) => {
|
||||
new_rear.borrow_mut().next.take();
|
||||
self.rear = Some(new_rear); // Update tail node
|
||||
}
|
||||
None => {
|
||||
self.front.take();
|
||||
}
|
||||
}
|
||||
self.que_size -= 1; // Update queue length
|
||||
old_rear.borrow().val
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/* Rear of the queue dequeue */
|
||||
pub fn pop_first(&mut self) -> Option<T> {
|
||||
return self.pop(true);
|
||||
}
|
||||
|
||||
/* Access rear of the queue element */
|
||||
pub fn pop_last(&mut self) -> Option<T> {
|
||||
return self.pop(false);
|
||||
}
|
||||
|
||||
/* Return list for printing */
|
||||
pub fn peek_first(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
|
||||
self.front.as_ref()
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
pub fn peek_last(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
|
||||
self.rear.as_ref()
|
||||
}
|
||||
|
||||
/* Return array for printing */
|
||||
pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
|
||||
let mut res: Vec<T> = Vec::new();
|
||||
fn recur<T: Copy>(cur: Option<&Rc<RefCell<ListNode<T>>>>, res: &mut Vec<T>) {
|
||||
if let Some(cur) = cur {
|
||||
res.push(cur.borrow().val);
|
||||
recur(cur.borrow().next.as_ref(), res);
|
||||
}
|
||||
}
|
||||
|
||||
recur(head, &mut res);
|
||||
res
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
fn main() {
|
||||
/* Get the length of the double-ended queue */
|
||||
let mut deque = LinkedListDeque::new();
|
||||
deque.push_last(3);
|
||||
deque.push_last(2);
|
||||
deque.push_last(5);
|
||||
print!("Double-ended queue deque = ");
|
||||
print_util::print_array(&deque.to_array(deque.peek_first()));
|
||||
|
||||
/* Update element */
|
||||
let peek_first = deque.peek_first().unwrap().borrow().val;
|
||||
print!("\nFront element peek_first = {}", peek_first);
|
||||
let peek_last = deque.peek_last().unwrap().borrow().val;
|
||||
print!("\nRear element peek_last = {}", peek_last);
|
||||
|
||||
/* Elements enqueue */
|
||||
deque.push_last(4);
|
||||
print!("\nAfter element 4 enqueues at rear, deque = ");
|
||||
print_util::print_array(&deque.to_array(deque.peek_first()));
|
||||
deque.push_first(1);
|
||||
print!("\nAfter element 1 enqueues at front, deque = ");
|
||||
print_util::print_array(&deque.to_array(deque.peek_first()));
|
||||
|
||||
/* Element dequeue */
|
||||
let pop_last = deque.pop_last().unwrap();
|
||||
print!("\nDequeue rear element = {}, after dequeue deque = ", pop_last);
|
||||
print_util::print_array(&deque.to_array(deque.peek_first()));
|
||||
let pop_first = deque.pop_first().unwrap();
|
||||
print!("\nDequeue front element = {}, after dequeue deque = ", pop_first);
|
||||
print_util::print_array(&deque.to_array(deque.peek_first()));
|
||||
|
||||
/* Get the length of the double-ended queue */
|
||||
let size = deque.size();
|
||||
print!("\nDeque length size = {}", size);
|
||||
|
||||
/* Check if the double-ended queue is empty */
|
||||
let is_empty = deque.is_empty();
|
||||
print!("\nIs deque empty = {}", is_empty);
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
/*
|
||||
* File: linkedlist_queue.rs
|
||||
* Created Time: 2023-03-11
|
||||
* Author: codingonion (coderonion@gmail.com)
|
||||
*/
|
||||
|
||||
use hello_algo_rust::include::{print_util, ListNode};
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::rc::Rc;
|
||||
|
||||
/* Queue based on linked list implementation */
|
||||
#[allow(dead_code)]
|
||||
pub struct LinkedListQueue<T> {
|
||||
front: Option<Rc<RefCell<ListNode<T>>>>, // Head node front
|
||||
rear: Option<Rc<RefCell<ListNode<T>>>>, // Tail node rear
|
||||
que_size: usize, // Queue length
|
||||
}
|
||||
|
||||
impl<T: Copy> LinkedListQueue<T> {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
front: None,
|
||||
rear: None,
|
||||
que_size: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/* Get the length of the queue */
|
||||
pub fn size(&self) -> usize {
|
||||
return self.que_size;
|
||||
}
|
||||
|
||||
/* Check if the queue is empty */
|
||||
pub fn is_empty(&self) -> bool {
|
||||
return self.que_size == 0;
|
||||
}
|
||||
|
||||
/* Enqueue */
|
||||
pub fn push(&mut self, num: T) {
|
||||
// Add num after the tail node
|
||||
let new_rear = ListNode::new(num);
|
||||
match self.rear.take() {
|
||||
// If the queue is not empty, add the node after the tail node
|
||||
Some(old_rear) => {
|
||||
old_rear.borrow_mut().next = Some(new_rear.clone());
|
||||
self.rear = Some(new_rear);
|
||||
}
|
||||
// If the queue is empty, make both front and rear point to the node
|
||||
None => {
|
||||
self.front = Some(new_rear.clone());
|
||||
self.rear = Some(new_rear);
|
||||
}
|
||||
}
|
||||
self.que_size += 1;
|
||||
}
|
||||
|
||||
/* Dequeue */
|
||||
pub fn pop(&mut self) -> Option<T> {
|
||||
self.front.take().map(|old_front| {
|
||||
match old_front.borrow_mut().next.take() {
|
||||
Some(new_front) => {
|
||||
self.front = Some(new_front);
|
||||
}
|
||||
None => {
|
||||
self.rear.take();
|
||||
}
|
||||
}
|
||||
self.que_size -= 1;
|
||||
old_front.borrow().val
|
||||
})
|
||||
}
|
||||
|
||||
/* Return list for printing */
|
||||
pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
|
||||
self.front.as_ref()
|
||||
}
|
||||
|
||||
/* Convert linked list to Array and return */
|
||||
pub fn to_array(&self, head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
|
||||
let mut res: Vec<T> = Vec::new();
|
||||
|
||||
fn recur<T: Copy>(cur: Option<&Rc<RefCell<ListNode<T>>>>, res: &mut Vec<T>) {
|
||||
if let Some(cur) = cur {
|
||||
res.push(cur.borrow().val);
|
||||
recur(cur.borrow().next.as_ref(), res);
|
||||
}
|
||||
}
|
||||
|
||||
recur(head, &mut res);
|
||||
|
||||
res
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
fn main() {
|
||||
/* Access front of the queue element */
|
||||
let mut queue = LinkedListQueue::new();
|
||||
|
||||
/* Elements enqueue */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
queue.push(5);
|
||||
queue.push(4);
|
||||
print!("Queue queue = ");
|
||||
print_util::print_array(&queue.to_array(queue.peek()));
|
||||
|
||||
/* Return list for printing */
|
||||
let peek = queue.peek().unwrap().borrow().val;
|
||||
print!("\nFront element peek = {}", peek);
|
||||
|
||||
/* Element dequeue */
|
||||
let pop = queue.pop().unwrap();
|
||||
print!("\nDequeue element pop = {}, after dequeue queue = ", pop);
|
||||
print_util::print_array(&queue.to_array(queue.peek()));
|
||||
|
||||
/* Get the length of the queue */
|
||||
let size = queue.size();
|
||||
print!("\nQueue length size = {}", size);
|
||||
|
||||
/* Check if the queue is empty */
|
||||
let is_empty = queue.is_empty();
|
||||
print!("\nIs queue empty = {}", is_empty);
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
/*
|
||||
* File: linkedlist_stack.rs
|
||||
* Created Time: 2023-03-11
|
||||
* Author: codingonion (coderonion@gmail.com)
|
||||
*/
|
||||
|
||||
use hello_algo_rust::include::{print_util, ListNode};
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::rc::Rc;
|
||||
|
||||
/* Stack based on linked list implementation */
|
||||
#[allow(dead_code)]
|
||||
pub struct LinkedListStack<T> {
|
||||
stack_peek: Option<Rc<RefCell<ListNode<T>>>>, // Use head node as stack top
|
||||
stk_size: usize, // Stack length
|
||||
}
|
||||
|
||||
impl<T: Copy> LinkedListStack<T> {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
stack_peek: None,
|
||||
stk_size: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/* Get the length of the stack */
|
||||
pub fn size(&self) -> usize {
|
||||
return self.stk_size;
|
||||
}
|
||||
|
||||
/* Check if the stack is empty */
|
||||
pub fn is_empty(&self) -> bool {
|
||||
return self.size() == 0;
|
||||
}
|
||||
|
||||
/* Push */
|
||||
pub fn push(&mut self, num: T) {
|
||||
let node = ListNode::new(num);
|
||||
node.borrow_mut().next = self.stack_peek.take();
|
||||
self.stack_peek = Some(node);
|
||||
self.stk_size += 1;
|
||||
}
|
||||
|
||||
/* Pop */
|
||||
pub fn pop(&mut self) -> Option<T> {
|
||||
self.stack_peek.take().map(|old_head| {
|
||||
self.stack_peek = old_head.borrow_mut().next.take();
|
||||
self.stk_size -= 1;
|
||||
|
||||
old_head.borrow().val
|
||||
})
|
||||
}
|
||||
|
||||
/* Return list for printing */
|
||||
pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
|
||||
self.stack_peek.as_ref()
|
||||
}
|
||||
|
||||
/* Convert List to Array and return */
|
||||
pub fn to_array(&self) -> Vec<T> {
|
||||
fn _to_array<T: Sized + Copy>(head: Option<&Rc<RefCell<ListNode<T>>>>) -> Vec<T> {
|
||||
if let Some(node) = head {
|
||||
let mut nums = _to_array(node.borrow().next.as_ref());
|
||||
nums.push(node.borrow().val);
|
||||
return nums;
|
||||
}
|
||||
return Vec::new();
|
||||
}
|
||||
|
||||
_to_array(self.peek())
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
fn main() {
|
||||
/* Access top of the stack element */
|
||||
let mut stack = LinkedListStack::new();
|
||||
|
||||
/* Elements push onto stack */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
print!("Stack stack = ");
|
||||
print_util::print_array(&stack.to_array());
|
||||
|
||||
/* Return list for printing */
|
||||
let peek = stack.peek().unwrap().borrow().val;
|
||||
print!("\nTop element peek = {}", peek);
|
||||
|
||||
/* Element pop from stack */
|
||||
let pop = stack.pop().unwrap();
|
||||
print!("\nPop element pop = {}, after pop stack = ", pop);
|
||||
print_util::print_array(&stack.to_array());
|
||||
|
||||
/* Get the length of the stack */
|
||||
let size = stack.size();
|
||||
print!("\nStack length size = {}", size);
|
||||
|
||||
/* Check if empty */
|
||||
let is_empty = stack.is_empty();
|
||||
print!("\nIs stack empty = {}", is_empty);
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
/*
|
||||
* File: queue.rs
|
||||
* Created Time: 2023-02-05
|
||||
* Author: codingonion (coderonion@gmail.com), xBLACKICEx (xBLACKICEx@outlook.com)
|
||||
*/
|
||||
|
||||
use hello_algo_rust::include::print_util;
|
||||
|
||||
use std::collections::VecDeque;
|
||||
|
||||
/* Driver Code */
|
||||
pub fn main() {
|
||||
// Access front of the queue element
|
||||
let mut queue: VecDeque<i32> = VecDeque::new();
|
||||
|
||||
// Elements enqueue
|
||||
queue.push_back(1);
|
||||
queue.push_back(3);
|
||||
queue.push_back(2);
|
||||
queue.push_back(5);
|
||||
queue.push_back(4);
|
||||
print!("Queue queue = ");
|
||||
print_util::print_queue(&queue);
|
||||
|
||||
// Return list for printing
|
||||
let peek = queue.front().unwrap();
|
||||
println!("\nFront element peek = {peek}");
|
||||
|
||||
// Element dequeue
|
||||
let pop = queue.pop_front().unwrap();
|
||||
print!("Dequeue element pop = {pop}, after dequeue queue = ");
|
||||
print_util::print_queue(&queue);
|
||||
|
||||
// Get the length of the queue
|
||||
let size = queue.len();
|
||||
print!("\nQueue length size = {size}");
|
||||
|
||||
// Check if the queue is empty
|
||||
let is_empty = queue.is_empty();
|
||||
print!("\nIs queue empty = {is_empty}");
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
/*
|
||||
* File: stack.rs
|
||||
* Created Time: 2023-02-05
|
||||
* Author: codingonion (coderonion@gmail.com)
|
||||
*/
|
||||
|
||||
use hello_algo_rust::include::print_util;
|
||||
|
||||
/* Driver Code */
|
||||
pub fn main() {
|
||||
// Access top of the stack element
|
||||
// In Rust, it's recommended to use Vec as a stack
|
||||
let mut stack: Vec<i32> = Vec::new();
|
||||
|
||||
// Elements push onto stack
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
print!("Stack stack = ");
|
||||
print_util::print_array(&stack);
|
||||
|
||||
// Return list for printing
|
||||
let peek = stack.last().unwrap();
|
||||
print!("\nTop element peek = {peek}");
|
||||
|
||||
// Element pop from stack
|
||||
let pop = stack.pop().unwrap();
|
||||
print!("\nPop element pop = {pop}, after pop stack = ");
|
||||
print_util::print_array(&stack);
|
||||
|
||||
// Get the length of the stack
|
||||
let size = stack.len();
|
||||
print!("\nStack length size = {size}");
|
||||
|
||||
// Check if the stack is empty
|
||||
let is_empty = stack.is_empty();
|
||||
print!("\nIs stack empty = {is_empty}");
|
||||
}
|
||||
Reference in New Issue
Block a user