Merge pull request #278 from ben1009/tool-chain

feat: 148

Author: mergify[bot]

src/problem/mod.rs

@@ -32,6 +32,7 @@ pub mod p0128_longest_consecutive_sequence;
 pub mod p0133_clone_graph;
 pub mod p0144_binary_tree_preorder_traversal;
 pub mod p0145_binary_tree_postorder_traversal;
+pub mod p0148_sort_list;
 pub mod p0152_maximum_product_subarray;
 pub mod p0153_find_minimum_in_rotated_sorted_array;
 pub mod p0155_min_stack;

src/problem/p0148_sort_list.rs

@@ -0,0 +1,129 @@
+// Given the head of a linked list, return the list after sorting it in ascending order.
+
+// Example 1:
+
+// Input: head = [4,2,1,3]
+// Output: [1,2,3,4]
+// Example 2:
+
+// Input: head = [-1,5,3,4,0]
+// Output: [-1,0,3,4,5]
+// Example 3:
+
+// Input: head = []
+// Output: []
+
+// Constraints:
+
+// The number of nodes in the list is in the range [0, 5 * 104].
+// -105 <= Node.val <= 105
+
+// Follow up: Can you sort the linked list in O(n logn) time and O(1) memory (i.e. constant space)?
+
+use crate::util::linked_list::ListNode;
+
+// 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
+//     }
+//   }
+// }
+pub struct Solution;
+
+impl Solution {
+    pub fn sort_list(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        if head.is_none() || head.as_ref().unwrap().next.is_none() {
+            return head;
+        }
+
+        let (h1, h2) = Solution::half_cut(head);
+        let h1 = Solution::sort_list(h1);
+        let h2 = Solution::sort_list(h2);
+
+        Solution::merge(h1, h2)
+    }
+
+    fn merge(
+        mut h1: Option<Box<ListNode>>,
+        mut h2: Option<Box<ListNode>>,
+    ) -> Option<Box<ListNode>> {
+        if h1.is_none() {
+            return h2;
+        }
+        if h2.is_none() {
+            return h1;
+        }
+
+        let mut head_pointer = ListNode::new(0);
+        let mut pre = &mut head_pointer;
+        while h1.is_some() || h2.is_some() {
+            if h1.is_none() {
+                pre.next = h2.clone();
+                break;
+            }
+            if h2.is_none() {
+                pre.next = h1.clone();
+                break;
+            }
+
+            if h1.as_ref().unwrap().val < h2.as_ref().unwrap().val {
+                pre.next = h1.clone();
+                h1 = h1.as_ref().unwrap().next.clone();
+            } else {
+                pre.next = h2.clone();
+                h2 = h2.as_ref().unwrap().next.clone();
+            }
+            pre = pre.next.as_deref_mut().unwrap();
+        }
+
+        head_pointer.next
+    }
+
+    fn half_cut(head: Option<Box<ListNode>>) -> (Option<Box<ListNode>>, Option<Box<ListNode>>) {
+        if head.is_none() || head.as_ref().unwrap().next.is_none() {
+            return (head, None);
+        }
+
+        let mut head_pointer = ListNode::new(0);
+        head_pointer.next = head.clone();
+
+        let mut slow = &mut head_pointer;
+        let mut fast = Some(Box::new(slow.clone()));
+        while fast.is_some() && fast.as_ref().unwrap().next.is_some() {
+            slow = slow.next.as_mut().unwrap();
+            fast = fast.as_ref().unwrap().next.as_ref().unwrap().next.clone();
+        }
+        let head2 = slow.next.clone();
+        slow.next = None;
+
+        (head_pointer.next, head2)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::util::linked_list;
+
+    #[test]
+    fn test_148() {
+        assert_eq!(
+            Solution::sort_list(linked_list::to_list(vec![4, 2, 1, 3])),
+            linked_list::to_list(vec![1, 2, 3, 4])
+        );
+        assert_eq!(
+            Solution::sort_list(linked_list::to_list(vec![-1, 5, 3, 4, 0])),
+            linked_list::to_list(vec![-1, 0, 3, 4, 5])
+        );
+    }
+}