CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-09 05:41:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

cargo fmt rust code (#1131)

Browse Source 
* cargo fmt code

* Add empty line to seperate unrelated comments

* Fix review

* Update bubble_sort.rs

* Update merge_sort.rs

---------

Co-authored-by: Yudong Jin <krahets@163.com>
This commit is contained in:
rongyi
2024-03-16 02:13:41 +08:00
committed by GitHub
parent 54ceef3443
commit 7b1094318b
70 changed files with 1021 additions and 836 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
codes/rust/chapter_stack_and_queue/array_deque.rs
View File

@@ -8,9 +8,9 @@ include!("../include/include.rs");
/* 基于环形数组实现的双向队列 */
struct ArrayDeque {
nums: Vec<i32>, // 用于存储双向队列元素的数组
front: usize, // 队首指针，指向队首元素
que_size: usize, // 双向队列长度
nums: Vec<i32>, // 用于存储双向队列元素的数组
front: usize, // 队首指针，指向队首元素
que_size: usize, // 双向队列长度
}
impl ArrayDeque {
@@ -50,7 +50,7 @@ impl ArrayDeque {
pub fn push_first(&mut self, num: i32) {
if self.que_size == self.capacity() {
println!("双向队列已满");
return
return;
}
// 队首指针向左移动一位
// 通过取余操作实现 front 越过数组头部后回到尾部
@@ -64,7 +64,7 @@ impl ArrayDeque {
pub fn push_last(&mut self, num: i32) {
if self.que_size == self.capacity() {
println!("双向队列已满");
return
return;
}
// 计算队尾指针，指向队尾索引 + 1
let rear = self.index(self.front as i32 + self.que_size as i32);
@@ -91,18 +91,22 @@ impl ArrayDeque {
/* 访问队首元素 */
fn peek_first(&self) -> i32 {
if self.is_empty() { panic!("双向队列为空") };
if self.is_empty() {
panic!("双向队列为空")
};
self.nums[self.front]
}
/* 访问队尾元素 */
fn peek_last(&self) -> i32 {
if self.is_empty() { panic!("双向队列为空") };
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<i32> {
// 仅转换有效长度范围内的列表元素
@@ -146,7 +150,7 @@ fn main() {
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());
print_util::print_array(&deque.to_array());
/* 获取双向队列的长度 */
let size = deque.size();

8
codes/rust/chapter_stack_and_queue/array_queue.rs
View File

@@ -6,10 +6,10 @@
/* 基于环形数组实现的队列 */
struct ArrayQueue {
nums: Vec<i32>, // 用于存储队列元素的数组
front: i32, // 队首指针，指向队首元素
que_size: i32, // 队列长度
que_capacity: i32, // 队列容量
nums: Vec<i32>, // 用于存储队列元素的数组
front: i32, // 队首指针，指向队首元素
que_size: i32, // 队列长度
que_capacity: i32, // 队列容量
}
impl ArrayQueue {

10
codes/rust/chapter_stack_and_queue/array_stack.rs
View File

@@ -14,7 +14,9 @@ struct ArrayStack<T> {
impl<T> ArrayStack<T> {
/* 初始化栈 */
fn new() -> ArrayStack<T> {
ArrayStack::<T> { stack: Vec::<T>::new() }
ArrayStack::<T> {
stack: Vec::<T>::new(),
}
}
/* 获取栈的长度 */
@@ -42,7 +44,9 @@ impl<T> ArrayStack<T> {
/* 访问栈顶元素 */
fn peek(&self) -> Option<&T> {
if self.is_empty() { panic!("栈为空") };
if self.is_empty() {
panic!("栈为空")
};
self.stack.last()
}
@@ -82,4 +86,4 @@ fn main() {
// 判断是否为空
let is_empty = stack.is_empty();
print!("\n栈是否为空 = {is_empty}");
}
}

8
codes/rust/chapter_stack_and_queue/deque.rs
View File

@@ -12,16 +12,16 @@ use std::collections::VecDeque;
pub fn main() {
// 初始化双向队列
let mut deque: VecDeque<i32> = VecDeque::new();
deque.push_back(3);
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();
let peek_first = deque.front().unwrap();
print!("\n队首元素 peekFirst = {peek_first}");
let peek_last = deque.back().unwrap();
let peek_last = deque.back().unwrap();
print!("\n队尾元素 peekLast = {peek_last}");
/* 元素入队 */
@@ -47,4 +47,4 @@ pub fn main() {
// 判断双向队列是否为空
let is_empty = deque.is_empty();
print!("\n双向队列是否为空 = {is_empty}");
}
}

25
codes/rust/chapter_stack_and_queue/linkedlist_deque.rs
View File

@@ -6,8 +6,8 @@
include!("../include/include.rs");
use std::rc::Rc;
use std::cell::RefCell;
use std::rc::Rc;
/* 双向链表节点 */
pub struct ListNode<T> {
@@ -29,9 +29,9 @@ impl<T> ListNode<T> {
/* 基于双向链表实现的双向队列 */
#[allow(dead_code)]
pub struct LinkedListDeque<T> {
front: Option<Rc<RefCell<ListNode<T>>>>, // 头节点 front
rear: Option<Rc<RefCell<ListNode<T>>>>, // 尾节点 rear
que_size: usize, // 双向队列的长度
front: Option<Rc<RefCell<ListNode<T>>>>, // 头节点 front
rear: Option<Rc<RefCell<ListNode<T>>>>, // 尾节点 rear
que_size: usize, // 双向队列的长度
}
impl<T: Copy> LinkedListDeque<T> {
@@ -39,7 +39,7 @@ impl<T: Copy> LinkedListDeque<T> {
Self {
front: None,
rear: None,
que_size: 0,
que_size: 0,
}
}
@@ -71,7 +71,7 @@ impl<T: Copy> LinkedListDeque<T> {
self.front = Some(node); // 更新头节点
}
}
}
}
// 队尾入队操作
else {
match self.rear.take() {
@@ -104,8 +104,8 @@ impl<T: Copy> LinkedListDeque<T> {
/* 出队操作 */
pub fn pop(&mut self, is_front: bool) -> Option<T> {
// 若队列为空，直接返回 None
if self.is_empty() {
return None
if self.is_empty() {
return None;
};
// 队首出队操作
if is_front {
@@ -113,7 +113,7 @@ impl<T: Copy> LinkedListDeque<T> {
match old_front.borrow_mut().next.take() {
Some(new_front) => {
new_front.borrow_mut().prev.take();
self.front = Some(new_front); // 更新头节点
self.front = Some(new_front); // 更新头节点
}
None => {
self.rear.take();
@@ -122,15 +122,14 @@ impl<T: Copy> LinkedListDeque<T> {
self.que_size -= 1; // 更新队列长度
Rc::try_unwrap(old_front).ok().unwrap().into_inner().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); // 更新尾节点
self.rear = Some(new_rear); // 更新尾节点
}
None => {
self.front.take();
@@ -203,7 +202,7 @@ fn main() {
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()));
print_util::print_array(&deque.to_array(deque.peek_first()));
/* 获取双向队列的长度 */
let size = deque.size();

14
codes/rust/chapter_stack_and_queue/linkedlist_queue.rs
View File

@@ -6,16 +6,16 @@
include!("../include/include.rs");
use std::rc::Rc;
use std::cell::RefCell;
use list_node::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, // 队列的长度
front: Option<Rc<RefCell<ListNode<T>>>>, // 头节点 front
rear: Option<Rc<RefCell<ListNode<T>>>>, // 尾节点 rear
que_size: usize, // 队列的长度
}
impl<T: Copy> LinkedListQueue<T> {
@@ -23,7 +23,7 @@ impl<T: Copy> LinkedListQueue<T> {
Self {
front: None,
rear: None,
que_size: 0,
que_size: 0,
}
}
@@ -118,4 +118,4 @@ fn main() {
/* 判断队列是否为空 */
let is_empty = queue.is_empty();
print!("\n队列是否为空 = {}", is_empty);
}
}

10
codes/rust/chapter_stack_and_queue/linkedlist_stack.rs
View File

@@ -6,15 +6,15 @@
include!("../include/include.rs");
use std::rc::Rc;
use std::cell::RefCell;
use list_node::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, // 栈的长度
stack_peek: Option<Rc<RefCell<ListNode<T>>>>, // 将头节点作为栈顶
stk_size: usize, // 栈的长度
}
impl<T: Copy> LinkedListStack<T> {
@@ -105,4 +105,4 @@ fn main() {
/* 判断是否为空 */
let is_empty = stack.is_empty();
print!("\n栈是否为空 = {}", is_empty);
}
}

2
codes/rust/chapter_stack_and_queue/queue.rs
View File

@@ -38,4 +38,4 @@ pub fn main() {
// 判断队列是否为空
let is_empty = queue.is_empty();
print!("\n队列是否为空 = {is_empty}");
}
}

2
codes/rust/chapter_stack_and_queue/stack.rs
View File

@@ -37,4 +37,4 @@ pub fn main() {
// 判断栈是否为空
let is_empty = stack.is_empty();
print!("\n栈是否为空 = {is_empty}");
}
}