Question

我一直试图使用rust来回答leetcode中的一些问题。虽然我觉得很难处理链表，尤其是对于问题2和。我该如何处理价值变动的问题？

这是一段可以通过测试的代码。

table = "led_status"
field = "test_led"
value = False

cursor.execute("UPDATE %s SET `%s` = %s", (table, field, value))

虽然无法通过本地编译，但出现错误消息

// Definition for singly-linked list.
// #[derive(PartialEq, Eq, Debug)]
// pub struct ListNode {
//   pub val: i32,
//   pub next: Option<Box<ListNode>>
// }
// 
// impl ListNode {
//   #[inline]
//   fn new(val: i32) -> Self {
//     ListNode {
//       next: None,
//       val
//     }
//   }
// }
pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        let mut head1 = l1;
        let mut head2 = l2;
        let mut res = Some(Box::new(ListNode::new(0)));
        let mut tmp = &mut res;
        loop {
            let node1 = head1.take().unwrap_or(Box::new(ListNode::new(0)));
            let node2 = head2.take().unwrap_or(Box::new(ListNode::new(0)));
            tmp = match tmp.as_mut(){
                Some(_n) => {
                    let sum = node1.val + node2.val + _n.val;
                    let carry = sum /10;
                    _n.val = sum % 10;
                    if node1.next.is_none() && node2.next.is_none() && carry == 0{
                        return res;
                    } else {
                        _n.next = Some(Box::new(ListNode::new(carry)));
                    }
                    &mut _n.next
                }
                _ => unreachable!(),
            };
            head1 = node1.next;
            head2 = node2.next;
        }
    }

我想我可能会有所了解，因为tmp是对res的可变引用，然后移动了res。但是我如何才能同时保持链接列表的开头，同时又增加结尾呢？

Answer 1

您的代码按照稳定的Rust 2018（或每晚#![feature(nll)]的Rust 2015）编写的方式进行编译。

您只需进行一些调整即可使其在稳定的Rust 2015中编译：

pub fn add_two_numbers(
    l1: Option<Box<ListNode>>,
    l2: Option<Box<ListNode>>,
) -> Option<Box<ListNode>> {
    let mut head1 = l1;
    let mut head2 = l2;
    let mut res = Some(Box::new(ListNode::new(0)));
    // Add this block to limit the scope of tmp.
    {
        let mut tmp = &mut res;
        loop {
            let node1 = head1.take().unwrap_or(Box::new(ListNode::new(0)));
            let node2 = head2.take().unwrap_or(Box::new(ListNode::new(0)));
            // Add braces around tmp to force it to be moved instead of reborrowed.
            tmp = match { tmp }.as_mut() {
                Some(_n) => {
                    let sum = node1.val + node2.val + _n.val;
                    let carry = sum / 10;
                    _n.val = sum % 10;
                    if node1.next.is_none() && node2.next.is_none() && carry == 0 {
                        // Move the return statement outside the block.
                        break;
                    } else {
                        _n.next = Some(Box::new(ListNode::new(carry)));
                    }
                    &mut _n.next
                }
                _ => unreachable!(),
            };
            head1 = node1.next;
            head2 = node2.next;
        }
    }
    return res;
}

为什么将return res移到tmp的范围之外可能很有意义。 { tmp }有点混乱：它告诉编译器移动tmp而不是重新借用（请参阅this explanation）。

两个和Leetcode Rust解决方案？

1 个答案: