Rust Option 链表数据提取与修改

末蓝、 2023-01-22 05:59 6阅读 0赞

### 文章目录 ###

*  核心解释
 *  代码
 *  参考文档

# 核心解释 #

链表中比较难处理的就是Option的解析处理，一般情况使用match 进行匹配，然后再处理：

let mut l1 = Some(Box::new(ListNode::new(1)));
    	// 简单匹配
        if let Some(ref mut _l1) = l1{
          _l1.next = Some(Box::new(ListNode::new(2)));
        }

如果不使用匹配，需要自己实现类似Some的解构处理：

// 关键点，unwarp会导致原始变量move, 所以需要使用ref或者mut
        let l2 = l1.as_mut().unwrap();
        let mut l21 = l2.next.as_mut();
        l21.as_mut().unwrap().next = Some(Box::new(ListNode::new(3)));

如果在函数中处理，返回值是`Option<xxx>` 时，也可以使用`?`替代`unwrap()`简化代码。

# 代码 #

// 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
        }
      }
    }
    
    // fn simple_1(){
    
    //     fn merge_two_lists(mut l1: Option<Box<ListNode>>, mut l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
    //       let l3 = Some(Box::new(ListNode::new(-200)));
    //       while true {
    //         match (l1, l2) {
    //           (None, None) => { return l3;},
    //           (Some(_l1), None) => {
    //             l3.unwrap().next = Some(_l1);
    //           },
    //           (None, Some(_)) => {}
    //           (Some(_), Some(_)) => {}
    //         }
    //       }
    //       l3
    //     }
    //     let l1 = Some(Box::new(ListNode::new(1)));
    //     let l2 = Some(Box::new(ListNode::new(3)));
    //     let out = Some(Box::new(ListNode::new(1)));
    
    //     println!("Result: {:?}", out == merge_two_lists(l1, l2));
    // }
    
    
    fn main() {
        println!("Hello, world!");
    
        let mut l1 = Some(Box::new(ListNode::new(1)));
    
        // Option 一般通过match匹配或者?进行提取数据
        // 我们想要在不改变原始变量情况下，修改内部Some数据
    
        // add
        if let Some(ref mut _l1) = l1{
          _l1.next = Some(Box::new(ListNode::new(2)));
        }
        // add 2
        // 关键点，unwarp会导致原始变量move, 所以需要使用ref或者mut
        let l2 = l1.as_mut().unwrap();
        let mut l21 = l2.next.as_mut();
        l21.as_mut().unwrap().next = Some(Box::new(ListNode::new(3)));
    
        println!("{:?}", l1);
    
        // list member
        let mut lp = &l1;
        while *lp != None {
          match lp {
            None => { break; }
            Some(_lp) => {
              println!("{:?} {:p}", _lp.val, _lp);
              lp = &_lp.next;
            }
          }
        }
    
        // remove 2
        println!("\r\nRemove value 2 from list.\r\n");
        let mut lp = &mut l1;
        while *lp != None {
          match lp {
            None => { break; }
            Some(_lp) => {
              println!("{:?} {:p}", _lp.val, _lp);
              // remove
              if _lp.val == 1{
                let tmp = _lp.next.take();
                _lp.next = tmp.unwrap().next;
              }
              lp = &mut _lp.next;
              
            }
          }
        }
        println!("{:?}", l1);
    }

# 参考文档 #

*  [使用 ? 解开 Option][_ _ Option]
 *  [rust引用疑问][rust]
 *  [Option的几个方法及所有权问题][Option]

[_ _ Option]: https://rust-by-example.budshome.com/error/option_unwrap/question_mark.html
[rust]: https://zhuanlan.zhihu.com/p/305170263
[Option]: https://blog.csdn.net/Konquerx/article/details/115394598