'1'

notes/src/SUMMARY.md

@@ -6,4 +6,12 @@
 - [Day 2](./day2.md)
   - [977. 有序数组的平方](./day2/lc977.md)
   - [209. 长度最小的子数组](./day2/lc209.md)
-  - [59. 螺旋矩阵II](./day2/lc59.md)
+  - [59. 螺旋矩阵II](./day2/lc59.md)
+- [Day 3](./day3.md)
+  - [203. 移除链表元素](./day3/lc203.md)
+  - [707. 设计链表](./day3/lc707.md)
+  - [206. 反转链表](./day3/lc206.md)
+- [Day 4](./day4.md)
+  - []
+- [Day 5](./day5.md)
+  - []

notes/src/day3.md

@@ -0,0 +1,38 @@
+# 第二章 链表part01
+
+day1 任务以及具体安排：https://docs.qq.com/doc/DUG9UR2ZUc3BjRUdY
+day 2 任务以及具体安排：https://docs.qq.com/doc/DUGRwWXNOVEpyaVpG 
+今日任务 
+
+● 链表理论基础 
+● 203.移除链表元素 
+● 707.设计链表 
+● 206.反转链表 
+
+ 详细布置 
+
+ 链表理论基础 
+
+建议：了解一下链接基础，以及链表和数组的区别 
+
+文章链接：https://programmercarl.com/%E9%93%BE%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html
+
+## 203.移除链表元素  
+
+建议： 本题最关键是要理解 虚拟头结点的使用技巧，这个对链表题目很重要。
+
+题目链接/文章讲解/视频讲解：：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html
+
+##  707.设计链表  
+
+建议： 这是一道考察 链表综合操作的题目，不算容易，可以练一练 使用虚拟头结点
+
+题目链接/文章讲解/视频讲解：https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html
+
+## 206.反转链表 
+
+建议先看我的视频讲解，视频讲解中对 反转链表需要注意的点讲的很清晰了，看完之后大家的疑惑基本都解决了。
+
+题目链接/文章讲解/视频讲解：https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html 
+
+

notes/src/day3/lc203.md

@@ -0,0 +1,96 @@
+# 203. 移除链表元素
+
+## 题目描述
+
+给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
+## 解题思路
+
+链表题，hhhh，不是特别想用rust，不多说，直接操作ownersheip
+
+
+```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(head: Option<Box<ListNode>>, val: i32) -> Option<Box<ListNode>> {
+        let mut head = Some(Box::new(ListNode { val: 0, next: head }));
+        let mut a = &mut head;
+        while a.as_deref_mut().unwrap().next.is_some() {
+            let v = a.as_deref_mut().unwrap().next.as_deref().unwrap().val;
+            if v == val {
+                let mut b = a.as_deref_mut().unwrap().next.take();
+                let c = b.as_deref_mut().unwrap().next.take();
+                a.as_deref_mut().unwrap().next = c;
+            } else {
+                let b = &mut a.as_deref_mut().unwrap().next;
+                a = b;
+            }
+        }
+        head.unwrap().next
+    }
+}
+```
+
+属实有点恶心了
+
+## 学习感想
+
+```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(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();
+	// 使用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();
+            }
+        }
+        dummyHead.next
+    }
+}
+```
+
+向这位老哥学习，使用take，管它用不用，先取下来再说。并且 先把option刨了

notes/src/day3/lc206.md

@@ -0,0 +1,50 @@
+# 206. 反转链表
+
+## 题目描述
+
+给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
+
+
+## 解题思路
+这就很简单了，一边出栈 一边入
+
+```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 dummy = Box::new(ListNode { val: 0, next: None });
+        while let Some(mut node) = head {
+            let tmp = dummy.next.take();
+            let n = node.next.take();
+            node.next = tmp;
+            dummy.next = Some(node);
+            head = n;
+        }
+        dummy.next
+    }
+}
+```
+
+## 学习感想
+
+所以我这个算是什么方式

notes/src/day3/lc707.md

@@ -0,0 +1,117 @@
+# 707. 设计链表
+
+## 题目描述
+
+你可以选择使用单链表或者双链表，设计并实现自己的链表。
+
+单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
+
+如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
+
+实现 MyLinkedList 类：
+
+MyLinkedList() 初始化 MyLinkedList 对象。
+int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
+void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
+void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
+void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
+void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。
+## 解题思路
+
+
+```rust
+struct MyLinkedList {
+    val: i32,
+    next: Option<Box<MyLinkedList>>
+}
+
+
+/**
+ * `&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 { val: 0, next: None }
+    }
+
+    fn get(&self, index: i32) -> i32 {
+        let mut dummpy = self.next.as_deref();
+        let mut cnt = 0;
+        while let Some(node) = dummpy {
+            if index == cnt { return node.val }
+            dummpy = node.next.as_deref();
+            cnt += 1;
+        }
+        -1
+    }
+
+    fn add_at_head(&mut self, val: i32) {
+        self.next = Some(Box::new(
+            MyLinkedList {
+                val: val, 
+                next: self.next.take()
+            }
+        ));
+    }
+
+    fn add_at_tail(&mut self, val: i32) {
+        let mut dummpy = self;
+        while dummpy.next.is_some() {
+            dummpy = dummpy.next.as_mut().unwrap();
+        }
+        dummpy.next = Some(Box::new(
+            MyLinkedList {
+                val: val, 
+                next: None
+            }
+        ));
+    }
+
+    fn add_at_index(&mut self, index: i32, val: i32) {
+        let mut cnt = 0;
+        let mut dummpy = self;
+        while dummpy.next.is_some() {
+            if cnt == index {
+                let nxt = dummpy.next.take();
+                dummpy.next = Some(Box::new(
+                    MyLinkedList {
+                        val: val, 
+                        next: nxt
+                    }
+                ));
+                return;
+            }
+            dummpy = dummpy.next.as_mut().unwrap();
+            cnt += 1;
+        }
+        if cnt == index {
+            dummpy.next = Some(Box::new(
+                MyLinkedList {
+                    val: val, 
+                    next: None
+                }
+            ));
+        }
+    }
+
+    fn delete_at_index(&mut self, index: i32) {
+        let mut cnt = 0;
+        let mut dummpy = self;
+        while dummpy.next.is_some() {
+            if cnt == index {
+                let nxt = dummpy.next.take().unwrap();
+                dummpy.next = nxt.next;
+                return;
+            }
+            dummpy = dummpy.next.as_mut().unwrap();
+            cnt += 1;
+        }
+    }
+}
+```
+
+## 学习感想
+
+也没啥好说的，rust只要写出来，基本是对的，没有用take的形式，而是全部去除了option用ref