feat: add more

Author: gengjiawen

Cargo.lock

@@ -8,6 +8,7 @@ members = [
     "sliding_window",
     "String",
     "greedy",
+    "linked_list",
     "Tree",
     "trie",
     "stack",

Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "leetcode_linked_list"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+path = "lib.rs"
+doctest = false
+
+[dependencies]

linked_list/Cargo.toml

@@ -0,0 +1,100 @@
+// https://leetcode.com/problems/merge-two-sorted-lists
+//
+// You are given the heads of two sorted linked lists `list1` and `list2`.
+//
+// Merge the two lists in a one **sorted** list. The list should be made by splicing together the nodes of the first two lists.
+//
+// Return _the head of the merged linked list_.
+//
+// **Example 1:**
+//
+// ![](https://assets.leetcode.com/uploads/2020/10/03/merge_ex1.jpg)
+// ```
+// **Input:** list1 = [1,2,4], list2 = [1,3,4]
+// **Output:** [1,1,2,3,4,4]
+// ```
+//
+// **Example 2:**
+//
+// ```
+// **Input:** list1 = [], list2 = []
+// **Output:** []
+// ```
+//
+// **Example 3:**
+//
+// ```
+// **Input:** list1 = [], list2 = [0]
+// **Output:** [0]
+// ```
+//
+// **Constraints:**
+//
+// *   The number of nodes in both lists is in the range `[0, 50]`.
+// *   `-100 <= Node.val <= 100`
+// *   Both `list1` and `list2` are sorted in **non-decreasing** order.
+use crate::list_node::ListNode;
+
+pub fn merge_two_lists(
+    list1: Option<Box<ListNode>>,
+    list2: Option<Box<ListNode>>,
+) -> Option<Box<ListNode>> {
+    let mut list1 = list1.as_ref();
+    let mut list2 = list2.as_ref();
+    let mut start = Box::new(ListNode::new(0));
+    let mut end = &mut start;
+    while let (Some(n1), Some(n2)) = (list1, list2) {
+        if n1.val < n2.val {
+            end.next = list1.cloned();
+            list1 = n1.next.as_ref();
+        } else {
+            end.next = list2.cloned();
+            list2 = n2.next.as_ref();
+        }
+        end = end.next.as_mut().unwrap();
+    }
+    if list1.is_some() {
+        end.next = list1.cloned();
+    } else if list2.is_some() {
+        end.next = list2.cloned();
+    }
+    return start.next;
+}
+
+#[test]
+pub fn t1() {
+    assert_eq!(
+        merge_two_lists(
+            Some(Box::new(ListNode {
+                val: 1,
+                next: Some(Box::new(ListNode {
+                    val: 2,
+                    next: Some(Box::new(ListNode { val: 4, next: None })),
+                })),
+            })),
+            Some(Box::new(ListNode {
+                val: 1,
+                next: Some(Box::new(ListNode {
+                    val: 3,
+                    next: Some(Box::new(ListNode { val: 4, next: None })),
+                })),
+            })),
+        ),
+        Some(Box::new(ListNode {
+            val: 1,
+            next: Some(Box::new(ListNode {
+                val: 1,
+                next: Some(Box::new(ListNode {
+                    val: 2,
+                    next: Some(Box::new(ListNode {
+                        val: 3,
+                        next: Some(Box::new(ListNode {
+                            val: 4,
+                            next: Some(Box::new(ListNode { val: 4, next: None })),
+                        })),
+                    })),
+                })),
+            })),
+        }))
+    );
+}

linked_list/_0021_merge_two_sorted_lists.rs

@@ -0,0 +1,77 @@
+// https://leetcode.com/problems/reverse-linked-list
+//
+// Given the `head` of a singly linked list, reverse the list, and return _the reversed list_.
+//
+// **Example 1:**
+//
+// ![](https://assets.leetcode.com/uploads/2021/02/19/rev1ex1.jpg)
+// ```
+// **Input:** head = [1,2,3,4,5]
+// **Output:** [5,4,3,2,1]
+// ```
+//
+// **Example 2:**
+//
+// ![](https://assets.leetcode.com/uploads/2021/02/19/rev1ex2.jpg)
+// ```
+// **Input:** head = [1,2]
+// **Output:** [2,1]
+// ```
+//
+// **Example 3:**
+//
+// ```
+// **Input:** head = []
+// **Output:** []
+// ```
+//
+// **Constraints:**
+//
+// *   The number of nodes in the list is the range `[0, 5000]`.
+// *   `-5000 <= Node.val <= 5000`
+//
+// **Follow up:** A linked list can be reversed either iteratively or recursively. Could you implement both?
+
+use crate::list_node::ListNode;
+
+pub fn reverse_list(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+    let (mut head, mut prev) = (head, None);
+    while let Some(mut node) = head {
+        head = node.next.take();
+        node.next = prev;
+        prev = Some(node);
+    }
+    return prev;
+}
+
+#[test]
+pub fn t1() {
+    assert_eq!(
+        reverse_list(Some(Box::new(ListNode {
+            val: 1,
+            next: Some(Box::new(ListNode {
+                val: 2,
+                next: Some(Box::new(ListNode {
+                    val: 3,
+                    next: Some(Box::new(ListNode {
+                        val: 4,
+                        next: Some(Box::new(ListNode { val: 5, next: None })),
+                    })),
+                })),
+            })),
+        }))),
+        Some(Box::new(ListNode {
+            val: 5,
+            next: Some(Box::new(ListNode {
+                val: 4,
+                next: Some(Box::new(ListNode {
+                    val: 3,
+                    next: Some(Box::new(ListNode {
+                        val: 2,
+                        next: Some(Box::new(ListNode { val: 1, next: None })),
+                    })),
+                })),
+            })),
+        }))
+    );
+}

linked_list/_0206_reverse_linked_list.rs

@@ -0,0 +1,5 @@
+#![allow(dead_code)]
+
+mod _0021_merge_two_sorted_lists;
+mod _0206_reverse_linked_list;
+mod list_node;

linked_list/lib.rs

@@ -0,0 +1,13 @@
+// Definition for singly-linked list.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>,
+}
+
+impl ListNode {
+    #[inline]
+    pub fn new(val: i32) -> Self {
+        ListNode { next: None, val }
+    }
+}