1

Author: Ainevsia

notes/src/day3/lc206.md

@@ -47,4 +47,40 @@ impl Solution {
 
 ## 学习感想
 
-所以我这个算是什么方式
+所以我这个算是什么方式
+
+
+```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 reverse_list(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut res: Option<Box<ListNode>> = None;
+        while let Some(mut x) = head {
+            head = x.next.take();
+            x.next = res;
+            res = Some(x);
+        }
+        res
+    }
+}
+```

notes/src/day3/lc707.md

@@ -114,4 +114,82 @@ impl MyLinkedList {
 
 ## 学习感想
 
-也没啥好说的，rust只要写出来，基本是对的，没有用take的形式，而是全部去除了option用ref
+也没啥好说的，rust只要写出来，基本是对的，没有用take的形式，而是全部去除了option用ref
+
+
+```rust
+struct MyLinkedList {
+    head: Option<Box<ListNode>>,
+    cnt: i32,
+}
+
+struct ListNode {
+    val: i32,
+    next: Option<Box<ListNode>>,
+}
+
+/** 
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl MyLinkedList {
+
+    fn new() -> Self {
+        Self {
+            head: None,
+            cnt: 0i32,
+        }
+    }
+    
+    fn get(&self, mut index: i32) -> i32 {
+        if index >= self.cnt { return -1i32 }
+        let mut ptr: & Box<ListNode> = self.head.as_ref().unwrap();
+        while index > 0i32 {
+            ptr = ptr.next.as_ref().unwrap();
+            index -= 1i32;
+        }
+        ptr.val
+    }
+    
+    fn add_at_head(&mut self, val: i32) {
+        self.add_at_index(0i32, val);
+    }
+    
+    fn add_at_tail(&mut self, val: i32) {
+        self.add_at_index(self.cnt, val);
+    }
+    
+    fn add_at_index(&mut self, mut index: i32, val: i32) {
+        if index > self.cnt { return }
+        let mut ptr: &mut Option<Box<ListNode>> = &mut self.head;
+        while index > 0i32 {
+            ptr = &mut ptr.as_mut().unwrap().next;
+            index -= 1i32;
+        }
+        self.cnt += 1i32;
+        *ptr = Some(Box::new(ListNode { val: val, next: ptr.take() }))
+    }
+    
+    fn delete_at_index(&mut self, mut index: i32) {
+        if index >= self.cnt { return }
+        let mut ptr: &mut Option<Box<ListNode>> = &mut self.head;
+        while index > 0i32 {
+            ptr = &mut ptr.as_mut().unwrap().next;
+            index -= 1i32;
+        }
+        let nxt: Option<Box<ListNode>> = ptr.take().unwrap().next.take();
+        *ptr = nxt;
+        self.cnt -= 1i32;
+    }
+}
+
+/**
+ * Your MyLinkedList object will be instantiated and called as such:
+ * let obj = MyLinkedList::new();
+ * let ret_1: i32 = obj.get(index);
+ * obj.add_at_head(val);
+ * obj.add_at_tail(val);
+ * obj.add_at_index(index, val);
+ * obj.delete_at_index(index);
+ */
+```