mirror of
https://github.com/krahets/hello-algo.git
synced 2026-07-10 22:46:07 +00:00
Add ru version (#1865)
* Add Russian docs site baseline * Add Russian localized codebase * Polish Russian code wording * Update ru code translation. * Update code translation and chapter covers. * Fix pythontutor extraction. * Add README and landing page. * placeholder of profiles * Use figures of English version * Remove chapter paperbook
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;
|
||||
/* Двусторонняя очередь на основе кольцевого массива */
|
||||
struct ArrayDeque<T> {
|
||||
nums: Vec<T>, // Массив для хранения элементов двусторонней очереди
|
||||
front: usize, // Указатель head, указывающий на первый элемент очереди
|
||||
que_size: usize, // Длина двусторонней очереди
|
||||
}
|
||||
|
||||
impl<T: Copy + Default> ArrayDeque<T> {
|
||||
/* Конструктор */
|
||||
pub fn new(capacity: usize) -> Self {
|
||||
Self {
|
||||
nums: vec![T::default(); capacity],
|
||||
front: 0,
|
||||
que_size: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/* Получить вместимость двусторонней очереди */
|
||||
pub fn capacity(&self) -> usize {
|
||||
self.nums.len()
|
||||
}
|
||||
|
||||
/* Получение длины двусторонней очереди */
|
||||
pub fn size(&self) -> usize {
|
||||
self.que_size
|
||||
}
|
||||
|
||||
/* Проверка, пуста ли двусторонняя очередь */
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.que_size == 0
|
||||
}
|
||||
|
||||
/* Вычислить индекс в кольцевом массиве */
|
||||
fn index(&self, i: i32) -> usize {
|
||||
// С помощью операции взятия по модулю соединить начало и конец массива
|
||||
// Когда i выходит за конец массива, он возвращается в начало
|
||||
// Когда i выходит за начало массива, он возвращается в конец
|
||||
((i + self.capacity() as i32) % self.capacity() as i32) as usize
|
||||
}
|
||||
|
||||
/* Добавление в голову очереди */
|
||||
pub fn push_first(&mut self, num: T) {
|
||||
if self.que_size == self.capacity() {
|
||||
println!("Двусторонняя очередь заполнена");
|
||||
return;
|
||||
}
|
||||
// Указатель головы сдвигается на одну позицию влево
|
||||
// С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост
|
||||
self.front = self.index(self.front as i32 - 1);
|
||||
// Добавить num в голову очереди
|
||||
self.nums[self.front] = num;
|
||||
self.que_size += 1;
|
||||
}
|
||||
|
||||
/* Добавление в хвост очереди */
|
||||
pub fn push_last(&mut self, num: T) {
|
||||
if self.que_size == self.capacity() {
|
||||
println!("Двусторонняя очередь заполнена");
|
||||
return;
|
||||
}
|
||||
// Вычислить указатель хвоста, указывающий на индекс хвоста + 1
|
||||
let rear = self.index(self.front as i32 + self.que_size as i32);
|
||||
// Добавить num в хвост очереди
|
||||
self.nums[rear] = num;
|
||||
self.que_size += 1;
|
||||
}
|
||||
|
||||
/* Извлечение из головы очереди */
|
||||
fn pop_first(&mut self) -> T {
|
||||
let num = self.peek_first();
|
||||
// Указатель головы сдвигается на одну позицию назад
|
||||
self.front = self.index(self.front as i32 + 1);
|
||||
self.que_size -= 1;
|
||||
num
|
||||
}
|
||||
|
||||
/* Извлечение из хвоста очереди */
|
||||
fn pop_last(&mut self) -> T {
|
||||
let num = self.peek_last();
|
||||
self.que_size -= 1;
|
||||
num
|
||||
}
|
||||
|
||||
/* Доступ к элементу в начале очереди */
|
||||
fn peek_first(&self) -> T {
|
||||
if self.is_empty() {
|
||||
panic!("двусторонняя очередь пуста")
|
||||
};
|
||||
self.nums[self.front]
|
||||
}
|
||||
|
||||
/* Доступ к элементу в конце очереди */
|
||||
fn peek_last(&self) -> T {
|
||||
if self.is_empty() {
|
||||
panic!("двусторонняя очередь пуста")
|
||||
};
|
||||
// Вычислить индекс хвостового элемента
|
||||
let last = self.index(self.front as i32 + self.que_size as i32 - 1);
|
||||
self.nums[last]
|
||||
}
|
||||
|
||||
/* Вернуть массив для вывода */
|
||||
fn to_array(&self) -> Vec<T> {
|
||||
// Преобразовывать только элементы списка в пределах фактической длины
|
||||
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() {
|
||||
/* Инициализация двусторонней очереди */
|
||||
let mut deque = ArrayDeque::new(10);
|
||||
deque.push_last(3);
|
||||
deque.push_last(2);
|
||||
deque.push_last(5);
|
||||
print!("Двусторонняя очередь deque = ");
|
||||
print_util::print_array(&deque.to_array());
|
||||
|
||||
/* Доступ к элементу */
|
||||
let peek_first = deque.peek_first();
|
||||
print!("\nПервый элемент peek_first = {}", peek_first);
|
||||
let peek_last = deque.peek_last();
|
||||
print!("\nПоследний элемент peek_last = {}", peek_last);
|
||||
|
||||
/* Добавление элемента в очередь */
|
||||
deque.push_last(4);
|
||||
print!("\nПосле добавления элемента 4 в хвост deque = ");
|
||||
print_util::print_array(&deque.to_array());
|
||||
deque.push_first(1);
|
||||
print!("\nПосле добавления элемента 1 в голову deque = ");
|
||||
print_util::print_array(&deque.to_array());
|
||||
|
||||
/* Извлечение элемента из очереди */
|
||||
let pop_last = deque.pop_last();
|
||||
print!("\nИзвлеченный из хвоста элемент = {}, deque после извлечения из хвоста = ", pop_last);
|
||||
print_util::print_array(&deque.to_array());
|
||||
let pop_first = deque.pop_first();
|
||||
print!("\nИзвлеченный из головы элемент = {}, deque после извлечения из головы = ", pop_first);
|
||||
print_util::print_array(&deque.to_array());
|
||||
|
||||
/* Получение длины двусторонней очереди */
|
||||
let size = deque.size();
|
||||
print!("\nДлина двусторонней очереди size = {}", size);
|
||||
|
||||
/* Проверка, пуста ли двусторонняя очередь */
|
||||
let is_empty = deque.is_empty();
|
||||
print!("\nПуста ли двусторонняя очередь = {}", is_empty);
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
/*
|
||||
* File: array_queue.rs
|
||||
* Created Time: 2023-02-06
|
||||
* Author: WSL0809 (wslzzy@outlook.com)
|
||||
*/
|
||||
|
||||
/* Очередь на основе кольцевого массива */
|
||||
struct ArrayQueue<T> {
|
||||
nums: Vec<T>, // Массив для хранения элементов очереди
|
||||
front: i32, // Указатель head, указывающий на первый элемент очереди
|
||||
que_size: i32, // Длина очереди
|
||||
que_capacity: i32, // Вместимость очереди
|
||||
}
|
||||
|
||||
impl<T: Copy + Default> ArrayQueue<T> {
|
||||
/* Конструктор */
|
||||
fn new(capacity: i32) -> ArrayQueue<T> {
|
||||
ArrayQueue {
|
||||
nums: vec![T::default(); capacity as usize],
|
||||
front: 0,
|
||||
que_size: 0,
|
||||
que_capacity: capacity,
|
||||
}
|
||||
}
|
||||
|
||||
/* Получить вместимость очереди */
|
||||
fn capacity(&self) -> i32 {
|
||||
self.que_capacity
|
||||
}
|
||||
|
||||
/* Получение длины очереди */
|
||||
fn size(&self) -> i32 {
|
||||
self.que_size
|
||||
}
|
||||
|
||||
/* Проверка, пуста ли очередь */
|
||||
fn is_empty(&self) -> bool {
|
||||
self.que_size == 0
|
||||
}
|
||||
|
||||
/* Поместить в очередь */
|
||||
fn push(&mut self, num: T) {
|
||||
if self.que_size == self.capacity() {
|
||||
println!("Очередь заполнена");
|
||||
return;
|
||||
}
|
||||
// Вычислить указатель хвоста, указывающий на индекс хвоста + 1
|
||||
// С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива
|
||||
let rear = (self.front + self.que_size) % self.que_capacity;
|
||||
// Добавить num в хвост очереди
|
||||
self.nums[rear as usize] = num;
|
||||
self.que_size += 1;
|
||||
}
|
||||
|
||||
/* Извлечь из очереди */
|
||||
fn pop(&mut self) -> T {
|
||||
let num = self.peek();
|
||||
// Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
|
||||
self.front = (self.front + 1) % self.que_capacity;
|
||||
self.que_size -= 1;
|
||||
num
|
||||
}
|
||||
|
||||
/* Доступ к элементу в начале очереди */
|
||||
fn peek(&self) -> T {
|
||||
if self.is_empty() {
|
||||
panic!("index out of bounds");
|
||||
}
|
||||
self.nums[self.front as usize]
|
||||
}
|
||||
|
||||
/* Вернуть массив */
|
||||
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() {
|
||||
/* Инициализация очереди */
|
||||
let capacity = 10;
|
||||
let mut queue = ArrayQueue::new(capacity);
|
||||
|
||||
/* Добавление элемента в очередь */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
queue.push(5);
|
||||
queue.push(4);
|
||||
println!("Очередь queue = {:?}", queue.to_vector());
|
||||
|
||||
/* Доступ к элементу в начале очереди */
|
||||
let peek = queue.peek();
|
||||
println!("Первый элемент peek = {}", peek);
|
||||
|
||||
/* Извлечение элемента из очереди */
|
||||
let pop = queue.pop();
|
||||
println!(
|
||||
"Извлеченный элемент pop = {:?}, queue после извлечения = {:?}",
|
||||
pop,
|
||||
queue.to_vector()
|
||||
);
|
||||
|
||||
/* Получение длины очереди */
|
||||
let size = queue.size();
|
||||
println!("Длина очереди size = {}", size);
|
||||
|
||||
/* Проверка, пуста ли очередь */
|
||||
let is_empty = queue.is_empty();
|
||||
println!("Пуста ли очередь = {}", is_empty);
|
||||
|
||||
/* Проверка кольцевого массива */
|
||||
for i in 0..10 {
|
||||
queue.push(i);
|
||||
queue.pop();
|
||||
println!("После {:?}-го раунда операций 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;
|
||||
|
||||
/* Стек на основе массива */
|
||||
struct ArrayStack<T> {
|
||||
stack: Vec<T>,
|
||||
}
|
||||
|
||||
impl<T> ArrayStack<T> {
|
||||
/* Инициализация стека */
|
||||
fn new() -> ArrayStack<T> {
|
||||
ArrayStack::<T> {
|
||||
stack: Vec::<T>::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/* Получение длины стека */
|
||||
fn size(&self) -> usize {
|
||||
self.stack.len()
|
||||
}
|
||||
|
||||
/* Проверка, пуст ли стек */
|
||||
fn is_empty(&self) -> bool {
|
||||
self.size() == 0
|
||||
}
|
||||
|
||||
/* Поместить в стек */
|
||||
fn push(&mut self, num: T) {
|
||||
self.stack.push(num);
|
||||
}
|
||||
|
||||
/* Извлечь из стека */
|
||||
fn pop(&mut self) -> Option<T> {
|
||||
self.stack.pop()
|
||||
}
|
||||
|
||||
/* Доступ к верхнему элементу стека */
|
||||
fn peek(&self) -> Option<&T> {
|
||||
if self.is_empty() {
|
||||
panic!("стек пуст")
|
||||
};
|
||||
self.stack.last()
|
||||
}
|
||||
|
||||
/* Вернуть &Vec */
|
||||
fn to_array(&self) -> &Vec<T> {
|
||||
&self.stack
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
fn main() {
|
||||
// Инициализация стека
|
||||
let mut stack = ArrayStack::<i32>::new();
|
||||
|
||||
// Помещение элемента в стек
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
print!("Стек stack = ");
|
||||
print_util::print_array(stack.to_array());
|
||||
|
||||
// Доступ к верхнему элементу стека
|
||||
let peek = stack.peek().unwrap();
|
||||
print!("\nВерхний элемент peek = {}", peek);
|
||||
|
||||
// Извлечение элемента из стека
|
||||
let pop = stack.pop().unwrap();
|
||||
print!("\nИзвлеченный элемент pop = {pop}, stack после извлечения = ");
|
||||
print_util::print_array(stack.to_array());
|
||||
|
||||
// Получение длины стека
|
||||
let size = stack.size();
|
||||
print!("\nДлина стека size = {size}");
|
||||
|
||||
// Проверка на пустоту
|
||||
let is_empty = stack.is_empty();
|
||||
print!("\nПуст ли стек = {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() {
|
||||
// Инициализация двусторонней очереди
|
||||
let mut deque: VecDeque<i32> = VecDeque::new();
|
||||
deque.push_back(3);
|
||||
deque.push_back(2);
|
||||
deque.push_back(5);
|
||||
print!("Двусторонняя очередь deque = ");
|
||||
print_util::print_queue(&deque);
|
||||
|
||||
// Доступ к элементу
|
||||
let peek_first = deque.front().unwrap();
|
||||
print!("\nПервый элемент peekFirst = {peek_first}");
|
||||
let peek_last = deque.back().unwrap();
|
||||
print!("\nПоследний элемент peekLast = {peek_last}");
|
||||
|
||||
/* Добавление элемента в очередь */
|
||||
deque.push_back(4);
|
||||
print!("\nПосле добавления элемента 4 в хвост deque = ");
|
||||
print_util::print_queue(&deque);
|
||||
deque.push_front(1);
|
||||
print!("\nПосле добавления элемента 1 в голову deque = ");
|
||||
print_util::print_queue(&deque);
|
||||
|
||||
// Извлечение элемента из очереди
|
||||
let pop_last = deque.pop_back().unwrap();
|
||||
print!("\nИзвлеченный из хвоста элемент = {pop_last}, deque после извлечения из хвоста = ");
|
||||
print_util::print_queue(&deque);
|
||||
let pop_first = deque.pop_front().unwrap();
|
||||
print!("\nИзвлеченный из головы элемент = {pop_first}, deque после извлечения из головы = ");
|
||||
print_util::print_queue(&deque);
|
||||
|
||||
// Получение длины двусторонней очереди
|
||||
let size = deque.len();
|
||||
print!("\nДлина двусторонней очереди size = {size}");
|
||||
|
||||
// Проверка, пуста ли двусторонняя очередь
|
||||
let is_empty = deque.is_empty();
|
||||
print!("\nПуста ли двусторонняя очередь = {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;
|
||||
|
||||
/* Узел двусвязного списка */
|
||||
pub struct ListNode<T> {
|
||||
pub val: T, // Значение узла
|
||||
pub next: Option<Rc<RefCell<ListNode<T>>>>, // Указатель на узел-преемник
|
||||
pub prev: Option<Rc<RefCell<ListNode<T>>>>, // Указатель на узел-предшественник
|
||||
}
|
||||
|
||||
impl<T> ListNode<T> {
|
||||
pub fn new(val: T) -> Rc<RefCell<ListNode<T>>> {
|
||||
Rc::new(RefCell::new(ListNode {
|
||||
val,
|
||||
next: None,
|
||||
prev: None,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
/* Двусторонняя очередь на основе двусвязного списка */
|
||||
#[allow(dead_code)]
|
||||
pub struct LinkedListDeque<T> {
|
||||
front: Option<Rc<RefCell<ListNode<T>>>>, // Головной узел front
|
||||
rear: Option<Rc<RefCell<ListNode<T>>>>, // Хвостовой узел rear
|
||||
que_size: usize, // Длина двусторонней очереди
|
||||
}
|
||||
|
||||
impl<T: Copy> LinkedListDeque<T> {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
front: None,
|
||||
rear: None,
|
||||
que_size: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/* Получение длины двусторонней очереди */
|
||||
pub fn size(&self) -> usize {
|
||||
return self.que_size;
|
||||
}
|
||||
|
||||
/* Проверка, пуста ли двусторонняя очередь */
|
||||
pub fn is_empty(&self) -> bool {
|
||||
return self.que_size == 0;
|
||||
}
|
||||
|
||||
/* Операция добавления в очередь */
|
||||
fn push(&mut self, num: T, is_front: bool) {
|
||||
let node = ListNode::new(num);
|
||||
// Операция добавления в голову очереди
|
||||
if is_front {
|
||||
match self.front.take() {
|
||||
// Если связный список пуст, сделать так, чтобы и front, и rear указывали на node
|
||||
None => {
|
||||
self.rear = Some(node.clone());
|
||||
self.front = Some(node);
|
||||
}
|
||||
// Добавить node в голову списка
|
||||
Some(old_front) => {
|
||||
old_front.borrow_mut().prev = Some(node.clone());
|
||||
node.borrow_mut().next = Some(old_front);
|
||||
self.front = Some(node); // Обновить головной узел
|
||||
}
|
||||
}
|
||||
}
|
||||
// Операция добавления в хвост очереди
|
||||
else {
|
||||
match self.rear.take() {
|
||||
// Если связный список пуст, сделать так, чтобы и front, и rear указывали на node
|
||||
None => {
|
||||
self.front = Some(node.clone());
|
||||
self.rear = Some(node);
|
||||
}
|
||||
// Добавить node в хвост списка
|
||||
Some(old_rear) => {
|
||||
old_rear.borrow_mut().next = Some(node.clone());
|
||||
node.borrow_mut().prev = Some(old_rear);
|
||||
self.rear = Some(node); // Обновить хвостовой узел
|
||||
}
|
||||
}
|
||||
}
|
||||
self.que_size += 1; // Обновить длину очереди
|
||||
}
|
||||
|
||||
/* Добавление в голову очереди */
|
||||
pub fn push_first(&mut self, num: T) {
|
||||
self.push(num, true);
|
||||
}
|
||||
|
||||
/* Добавление в хвост очереди */
|
||||
pub fn push_last(&mut self, num: T) {
|
||||
self.push(num, false);
|
||||
}
|
||||
|
||||
/* Операция извлечения из очереди */
|
||||
fn pop(&mut self, is_front: bool) -> Option<T> {
|
||||
// Если очередь пуста, сразу вернуть None
|
||||
if self.is_empty() {
|
||||
return None;
|
||||
};
|
||||
// Операция извлечения из головы очереди
|
||||
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); // Обновить головной узел
|
||||
}
|
||||
None => {
|
||||
self.rear.take();
|
||||
}
|
||||
}
|
||||
self.que_size -= 1; // Обновить длину очереди
|
||||
old_front.borrow().val
|
||||
})
|
||||
}
|
||||
// Операция извлечения из хвоста очереди
|
||||
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); // Обновить хвостовой узел
|
||||
}
|
||||
None => {
|
||||
self.front.take();
|
||||
}
|
||||
}
|
||||
self.que_size -= 1; // Обновить длину очереди
|
||||
old_rear.borrow().val
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/* Извлечение из головы очереди */
|
||||
pub fn pop_first(&mut self) -> Option<T> {
|
||||
return self.pop(true);
|
||||
}
|
||||
|
||||
/* Извлечение из хвоста очереди */
|
||||
pub fn pop_last(&mut self) -> Option<T> {
|
||||
return self.pop(false);
|
||||
}
|
||||
|
||||
/* Доступ к элементу в начале очереди */
|
||||
pub fn peek_first(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
|
||||
self.front.as_ref()
|
||||
}
|
||||
|
||||
/* Доступ к элементу в конце очереди */
|
||||
pub fn peek_last(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
|
||||
self.rear.as_ref()
|
||||
}
|
||||
|
||||
/* Вернуть массив для вывода */
|
||||
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() {
|
||||
/* Инициализация двусторонней очереди */
|
||||
let mut deque = LinkedListDeque::new();
|
||||
deque.push_last(3);
|
||||
deque.push_last(2);
|
||||
deque.push_last(5);
|
||||
print!("Двусторонняя очередь deque = ");
|
||||
print_util::print_array(&deque.to_array(deque.peek_first()));
|
||||
|
||||
/* Доступ к элементу */
|
||||
let peek_first = deque.peek_first().unwrap().borrow().val;
|
||||
print!("\nПервый элемент peek_first = {}", peek_first);
|
||||
let peek_last = deque.peek_last().unwrap().borrow().val;
|
||||
print!("\nПоследний элемент peek_last = {}", peek_last);
|
||||
|
||||
/* Добавление элемента в очередь */
|
||||
deque.push_last(4);
|
||||
print!("\nПосле добавления элемента 4 в хвост deque = ");
|
||||
print_util::print_array(&deque.to_array(deque.peek_first()));
|
||||
deque.push_first(1);
|
||||
print!("\nПосле добавления элемента 1 в голову deque = ");
|
||||
print_util::print_array(&deque.to_array(deque.peek_first()));
|
||||
|
||||
/* Извлечение элемента из очереди */
|
||||
let pop_last = deque.pop_last().unwrap();
|
||||
print!("\nИзвлеченный из хвоста элемент = {}, deque после извлечения из хвоста = ", pop_last);
|
||||
print_util::print_array(&deque.to_array(deque.peek_first()));
|
||||
let pop_first = deque.pop_first().unwrap();
|
||||
print!("\nИзвлеченный из головы элемент = {}, deque после извлечения из головы = ", pop_first);
|
||||
print_util::print_array(&deque.to_array(deque.peek_first()));
|
||||
|
||||
/* Получение длины двусторонней очереди */
|
||||
let size = deque.size();
|
||||
print!("\nДлина двусторонней очереди size = {}", size);
|
||||
|
||||
/* Проверка, пуста ли двусторонняя очередь */
|
||||
let is_empty = deque.is_empty();
|
||||
print!("\nПуста ли двусторонняя очередь = {}", 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;
|
||||
|
||||
/* Очередь на основе связного списка */
|
||||
#[allow(dead_code)]
|
||||
pub struct LinkedListQueue<T> {
|
||||
front: Option<Rc<RefCell<ListNode<T>>>>, // Головной узел front
|
||||
rear: Option<Rc<RefCell<ListNode<T>>>>, // Хвостовой узел rear
|
||||
que_size: usize, // Длина очереди
|
||||
}
|
||||
|
||||
impl<T: Copy> LinkedListQueue<T> {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
front: None,
|
||||
rear: None,
|
||||
que_size: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/* Получение длины очереди */
|
||||
pub fn size(&self) -> usize {
|
||||
return self.que_size;
|
||||
}
|
||||
|
||||
/* Проверка, пуста ли очередь */
|
||||
pub fn is_empty(&self) -> bool {
|
||||
return self.que_size == 0;
|
||||
}
|
||||
|
||||
/* Поместить в очередь */
|
||||
pub fn push(&mut self, num: T) {
|
||||
// Добавить num после хвостового узла
|
||||
let new_rear = ListNode::new(num);
|
||||
match self.rear.take() {
|
||||
// Если очередь не пуста, добавить этот узел после хвостового узла
|
||||
Some(old_rear) => {
|
||||
old_rear.borrow_mut().next = Some(new_rear.clone());
|
||||
self.rear = Some(new_rear);
|
||||
}
|
||||
// Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел
|
||||
None => {
|
||||
self.front = Some(new_rear.clone());
|
||||
self.rear = Some(new_rear);
|
||||
}
|
||||
}
|
||||
self.que_size += 1;
|
||||
}
|
||||
|
||||
/* Извлечь из очереди */
|
||||
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
|
||||
})
|
||||
}
|
||||
|
||||
/* Доступ к элементу в начале очереди */
|
||||
pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
|
||||
self.front.as_ref()
|
||||
}
|
||||
|
||||
/* Преобразовать связный список в Array и вернуть */
|
||||
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() {
|
||||
/* Инициализация очереди */
|
||||
let mut queue = LinkedListQueue::new();
|
||||
|
||||
/* Добавление элемента в очередь */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
queue.push(5);
|
||||
queue.push(4);
|
||||
print!("Очередь queue = ");
|
||||
print_util::print_array(&queue.to_array(queue.peek()));
|
||||
|
||||
/* Доступ к элементу в начале очереди */
|
||||
let peek = queue.peek().unwrap().borrow().val;
|
||||
print!("\nПервый элемент peek = {}", peek);
|
||||
|
||||
/* Извлечение элемента из очереди */
|
||||
let pop = queue.pop().unwrap();
|
||||
print!("\nИзвлеченный элемент pop = {}, queue после извлечения = ", pop);
|
||||
print_util::print_array(&queue.to_array(queue.peek()));
|
||||
|
||||
/* Получение длины очереди */
|
||||
let size = queue.size();
|
||||
print!("\nДлина очереди size = {}", size);
|
||||
|
||||
/* Проверка, пуста ли очередь */
|
||||
let is_empty = queue.is_empty();
|
||||
print!("\nПуста ли очередь = {}", 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;
|
||||
|
||||
/* Стек на основе связного списка */
|
||||
#[allow(dead_code)]
|
||||
pub struct LinkedListStack<T> {
|
||||
stack_peek: Option<Rc<RefCell<ListNode<T>>>>, // Использовать головной узел как вершину стека
|
||||
stk_size: usize, // Длина стека
|
||||
}
|
||||
|
||||
impl<T: Copy> LinkedListStack<T> {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
stack_peek: None,
|
||||
stk_size: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/* Получение длины стека */
|
||||
pub fn size(&self) -> usize {
|
||||
return self.stk_size;
|
||||
}
|
||||
|
||||
/* Проверка, пуст ли стек */
|
||||
pub fn is_empty(&self) -> bool {
|
||||
return self.size() == 0;
|
||||
}
|
||||
|
||||
/* Поместить в стек */
|
||||
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;
|
||||
}
|
||||
|
||||
/* Извлечь из стека */
|
||||
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
|
||||
})
|
||||
}
|
||||
|
||||
/* Доступ к верхнему элементу стека */
|
||||
pub fn peek(&self) -> Option<&Rc<RefCell<ListNode<T>>>> {
|
||||
self.stack_peek.as_ref()
|
||||
}
|
||||
|
||||
/* Преобразовать List в Array и вернуть */
|
||||
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() {
|
||||
/* Инициализация стека */
|
||||
let mut stack = LinkedListStack::new();
|
||||
|
||||
/* Помещение элемента в стек */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
print!("Стек stack = ");
|
||||
print_util::print_array(&stack.to_array());
|
||||
|
||||
/* Доступ к верхнему элементу стека */
|
||||
let peek = stack.peek().unwrap().borrow().val;
|
||||
print!("\nВерхний элемент peek = {}", peek);
|
||||
|
||||
/* Извлечение элемента из стека */
|
||||
let pop = stack.pop().unwrap();
|
||||
print!("\nИзвлеченный элемент pop = {}, stack после извлечения = ", pop);
|
||||
print_util::print_array(&stack.to_array());
|
||||
|
||||
/* Получение длины стека */
|
||||
let size = stack.size();
|
||||
print!("\nДлина стека size = {}", size);
|
||||
|
||||
/* Проверка на пустоту */
|
||||
let is_empty = stack.is_empty();
|
||||
print!("\nПуст ли стек = {}", 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() {
|
||||
// Инициализация очереди
|
||||
let mut queue: VecDeque<i32> = VecDeque::new();
|
||||
|
||||
// Добавление элемента в очередь
|
||||
queue.push_back(1);
|
||||
queue.push_back(3);
|
||||
queue.push_back(2);
|
||||
queue.push_back(5);
|
||||
queue.push_back(4);
|
||||
print!("Очередь queue = ");
|
||||
print_util::print_queue(&queue);
|
||||
|
||||
// Доступ к элементу в начале очереди
|
||||
let peek = queue.front().unwrap();
|
||||
println!("\nПервый элемент peek = {peek}");
|
||||
|
||||
// Извлечение элемента из очереди
|
||||
let pop = queue.pop_front().unwrap();
|
||||
print!("Извлеченный элемент pop = {pop}, queue после извлечения = ");
|
||||
print_util::print_queue(&queue);
|
||||
|
||||
// Получение длины очереди
|
||||
let size = queue.len();
|
||||
print!("\nДлина очереди size = {size}");
|
||||
|
||||
// Проверка, пуста ли очередь
|
||||
let is_empty = queue.is_empty();
|
||||
print!("\nПуста ли очередь = {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() {
|
||||
// Инициализировать стек
|
||||
// В Rust рекомендуется использовать Vec как стек
|
||||
let mut stack: Vec<i32> = Vec::new();
|
||||
|
||||
// Помещение элемента в стек
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
print!("Стек stack = ");
|
||||
print_util::print_array(&stack);
|
||||
|
||||
// Доступ к верхнему элементу стека
|
||||
let peek = stack.last().unwrap();
|
||||
print!("\nВерхний элемент peek = {peek}");
|
||||
|
||||
// Извлечение элемента из стека
|
||||
let pop = stack.pop().unwrap();
|
||||
print!("\nИзвлеченный элемент pop = {pop}, stack после извлечения = ");
|
||||
print_util::print_array(&stack);
|
||||
|
||||
// Получение длины стека
|
||||
let size = stack.len();
|
||||
print!("\nДлина стека size = {size}");
|
||||
|
||||
// Проверка, пуст ли стек
|
||||
let is_empty = stack.is_empty();
|
||||
print!("\nПуст ли стек = {is_empty}");
|
||||
}
|
||||
Reference in New Issue
Block a user