feat: add rust solution to lc problem: No.0025 (doocs#1687)

No.0025.Reverse Nodes in k-Group

Author: poltao

solution/0000-0099/0025.Reverse Nodes in k-Group/README.md

@@ -377,6 +377,66 @@ public class Solution {
 }
 ```
 
+### **Rust**
+
+```rust
+// 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_k_group(head: Option<Box<ListNode>>, k: i32) -> Option<Box<ListNode>> {
+        fn reverse(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+            let mut head = head;
+            let mut pre = None;
+            while let Some(mut node) = head {
+                head = node.next.take();
+                node.next = pre.take();
+                pre = Some(node);
+            }
+            pre
+        }
+
+        let mut dummy = Some(Box::new(ListNode::new(0)));
+        let mut pre = &mut dummy;
+        let mut cur = head;
+        while cur.is_some() {
+            let mut q = &mut cur;
+            for _ in 0..k - 1 {
+                if q.is_none() {
+                    break;
+                }
+                q = &mut q.as_mut().unwrap().next;
+            }
+            if q.is_none() {
+                pre.as_mut().unwrap().next = cur;
+                return dummy.unwrap().next;
+            }
+
+            let b = q.as_mut().unwrap().next.take();
+            pre.as_mut().unwrap().next = reverse(cur);
+            while pre.is_some() && pre.as_mut().unwrap().next.is_some() {
+                pre = &mut pre.as_mut().unwrap().next;
+            }
+            cur = b;
+        }
+        dummy.unwrap().next
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0025.Reverse Nodes in k-Group/README_EN.md

@@ -362,6 +362,66 @@ public class Solution {
 }
 ```
 
+### **Rust**
+
+```rust
+// 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_k_group(head: Option<Box<ListNode>>, k: i32) -> Option<Box<ListNode>> {
+        fn reverse(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+            let mut head = head;
+            let mut pre = None;
+            while let Some(mut node) = head {
+                head = node.next.take();
+                node.next = pre.take();
+                pre = Some(node);
+            }
+            pre
+        }
+
+        let mut dummy = Some(Box::new(ListNode::new(0)));
+        let mut pre = &mut dummy;
+        let mut cur = head;
+        while cur.is_some() {
+            let mut q = &mut cur;
+            for _ in 0..k - 1 {
+                if q.is_none() {
+                    break;
+                }
+                q = &mut q.as_mut().unwrap().next;
+            }
+            if q.is_none() {
+                pre.as_mut().unwrap().next = cur;
+                return dummy.unwrap().next;
+            }
+
+            let b = q.as_mut().unwrap().next.take();
+            pre.as_mut().unwrap().next = reverse(cur);
+            while pre.is_some() && pre.as_mut().unwrap().next.is_some() {
+                pre = &mut pre.as_mut().unwrap().next;
+            }
+            cur = b;
+        }
+        dummy.unwrap().next
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0025.Reverse Nodes in k-Group/Solution.rs

@@ -0,0 +1,55 @@
+// 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_k_group(head: Option<Box<ListNode>>, k: i32) -> Option<Box<ListNode>> {
+        fn reverse(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+            let mut head = head;
+            let mut pre = None;
+            while let Some(mut node) = head {
+                head = node.next.take();
+                node.next = pre.take();
+                pre = Some(node);
+            }
+            pre
+        }
+
+        let mut dummy = Some(Box::new(ListNode::new(0)));
+        let mut pre = &mut dummy;
+        let mut cur = head;
+        while cur.is_some() {
+            let mut q = &mut cur;
+            for _ in 0..k - 1 {
+                if q.is_none() {
+                    break;
+                }
+                q = &mut q.as_mut().unwrap().next;
+            }
+            if q.is_none() {
+                pre.as_mut().unwrap().next = cur;
+                return dummy.unwrap().next;
+            }
+
+            let b = q.as_mut().unwrap().next.take();
+            pre.as_mut().unwrap().next = reverse(cur);
+            while pre.is_some() && pre.as_mut().unwrap().next.is_some() {
+                pre = &mut pre.as_mut().unwrap().next;
+            }
+            cur = b;
+        }
+        dummy.unwrap().next
+    }
+}