rust学习笔记9-结构体与206.反转链表

结构体

rust不是面向对象语言，没有类（class），主要采用结构体（struct）来处理结构化数据，这点与go语言相似。

基本使用

struct Person {
    name: String,
    age: u32,
    height: f64,
}

fn main() {
    let person = Person {
        name: String::from("张三"),
        age: 34,
        height: 175.0,
    };

    println!("姓名: {}, 年龄: {}, 身高: {}", person.name, person.age, person.height);
}

2. 结构体的方法

通过 impl 块为结构体定义方法：

struct Person {
    name: String,
    age: u32,
    height: f64,
}

impl Person {
    // 关联函数（类似构造函数）
    fn new(name: &str, age: u32, height: f64) -> Person {
        Person {
            name: String::from(name),
            age,
            height,
        }
    }

    // 方法：打印信息
    fn greet(&self) {
        println!("我是: {}, 年龄: {}, 身高: {}", self.name, self.age, self.height);

    }

    // 方法：修改年龄
    fn celebrate_birthday(&mut self, age: u32) {
        self.age = age;
        println!("Happy Birthday! Now I am {} years old.", self.age);
    }
}

fn main() {
    let mut person = Person::new("小红", 25, 160.0);

    person.greet(); // 调用方法
    person.celebrate_birthday(24); // 修改年龄
    person.greet();
}

3.结构体与所有权

Rust 的所有权规则同样适用于结构体。如果结构体包含拥有所有权的字段（如 String 或 Vec），当结构体被移动时，这些字段的所有权也会被转移。

struct Person {
    name: String,
}

fn main() {
    let person = Person {
        name: String::from("小李"),
    };

    let another_person = person; // 所有权转移

    println!("{}", person.name); // 错误：`person` 已经被移动
}

4.rust结构体的可见性

结构体本身默认私有，用 pub 使其公有，这点与go语言不太一样，go是才用首字母是否大写来确定是否公有

pub struct PublicStruct {
    pub public_field: i32,
    private_field: i32,  // 默认私有
}

5.应用练习

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

• 链表中节点的数目范围是 [0, 5000]
• -5000 <= Node.val <= 5000

**进阶：**链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

（1）先定义数据库结构，直接从力扣上获取

 //Definition for singly-linked list.
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct ListNode {
   pub val: i32,
   pub next: Option<Box<ListNode>>
 }
 
 impl ListNode {
   #[inline]
   fn new(val: i32) -> Self {
     ListNode {
       next: None,
       val
     }
   }
 }

注 Box<T> 是 Rust 中最简单的智能指针之一，它允许在堆上分配一块内存，并将值存储在这个内存中，目前智能指针还没学，暂时先了解一下，不用深究

（2）节点为空判断，由于 Rust 不支持 null ，这就很难受了，不光链表，后面的栈、队列、二叉树等都免不了要判断为空的情况，这怎么办呢，那就是用上一篇说的，用Option枚举类型，用Option可以有效处理节点为空的情况，可以用if也可以用match模式匹配,考虑目前还不是很熟，match不易理解，先用if，后面再用match

fn main() { 

    // 创建单个节点
    let node1 = ListNode::new(1); // 值为 1 的节点
    println!("单个节点: {:?}", node1);
    let head = Some(Box::new(node1)); // 确保 head 是 Option<Box<ListNode>>
    if let Some(node) = head {
        println!("节点不为空, 值是: {}", node.val);
    } else {
        println!("节点为空");
    }
    //创建空节点
    let head :Option<Box<ListNode>> = None;
    if let Some(node) = head {
        println!("节点不为空, 值是: {}", node.val);
    } else {
        println!("节点为空");
    }
}

（3）解题原始版本

 pub fn reverse_list(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
    let mut cur = head;
    let mut pre: Option<Box<ListNode>> = None;
    loop {
        if let Some(mut node) = cur {
            // 使用 take 取出 node.next 的值，并将 node.next 设置为 None
            cur = node.next.take(); 
            node.next = pre;        // 将前一个节点赋值给当前节点的 next
            pre = Some(node);       // 更新 pre 为当前节点
            
        } else {
            break;
        }
    } 
    return pre;
    
}

简化版

pub fn reverse_list(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
    let mut cur = head;
    let mut pre: Option<Box<ListNode>> = None;
    while let Some(mut node) = cur.take() {
        cur = node.next;
        node.next = pre;  
        pre = Some(node);      
    }
    return pre;
}

运行结果

总结结构体是rust重要是数据结构，需要重点掌握，未来无论刷题还是做项目都会大量用到。再处理链表这类复杂的数据结构，特别是为空判断，可以使用Option枚举类型，来处理这种情况。

解题思路，首先先屏蔽一些不易理解的内容，如智能指针Box<T>、match模式匹配不易理解，先用if，递归等学到函数递归再用，然后逐个解决，先解决为空判断，然后再解题就很轻松了。

take函数

Option::take 的定义

pub fn take(&mut self) -> Option<T>

功能：从一个可变引用中取出当前的值，并将该 Option<T> 设置为 None。

返回值：返回当前的 Option<T> 值（可能是 Some(T) 或 None）。

通过这种方式，take 方法允许你在不破坏原始 Option<T> 的情况下，安全地获取其内部值。

cur.take(); // 使用 take 取出 cur的值，并将 cur设置为 None,这样所有权不用发生转移，特别适合处理链表这种复杂的数据结构，安全高效