1

Author: Ainevsia

notes/src/day3/lc203.md

@@ -78,14 +78,18 @@ impl Solution {
     pub fn remove_elements(head: Option<Box<ListNode>>, val: i32) -> Option<Box<ListNode>> {
         let mut dummyHead = Box::new(ListNode::new(0));
         dummyHead.next = head;
-        let mut cur = dummyHead.as_mut();
+        let mut cur: &mut ListNode = dummyHead.as_mut();
 	// 使用take()替换std::men::replace(&mut node.next, None)达到相同的效果，并且更普遍易读
         while let Some(nxt) = cur.next.take() {
             if nxt.val == val {
                 cur.next = nxt.next;
             } else {
                 cur.next = Some(nxt);
-                cur = cur.next.as_mut().unwrap();
+                cur = cur.next.as_mut().unwrap();   // coercion
+                //           ^ Option<Box<ListNode>>
+                //                    ^ Option<&mut Box<ListNode>>
+                //                             ^ &mut Box<ListNode>
+                //            deref   coerce ->     & mut ListNode
             }
         }
         dummyHead.next
@@ -94,3 +98,41 @@ impl Solution {
 ```
 
 向这位老哥学习，使用take，管它用不用，先取下来再说。并且 先把option刨了
+
+
+```rust
+
+# struct Solution {}
+# 
+# // 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
+#     }
+#   }
+# }
+
+impl Solution {
+    pub fn remove_elements(mut head: Option<Box<ListNode>>, val: i32) -> Option<Box<ListNode>> {
+        let mut res: Option<Box<ListNode>> = None;
+        let mut ptr: &mut Option<Box<ListNode>> = &mut res;
+        while let Some(mut x) = head {
+            head = x.next.take();
+            if x.val != val {
+                *ptr = Some(x);
+                ptr = &mut ptr.as_mut().unwrap().next;
+            }
+        }
+        res
+    }
+}
+```