Added tasks 21-78

Author: javadev

README.md

@@ -0,0 +1,82 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 21\. Merge Two Sorted Lists
+
+Easy
+
+Merge two sorted linked lists and return it as a **sorted** list. The list should be made by splicing together the nodes of the first two lists.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/03/merge_ex1.jpg)
+
+**Input:** l1 = [1,2,4], l2 = [1,3,4]
+
+**Output:** [1,1,2,3,4,4]
+
+**Example 2:**
+
+**Input:** l1 = [], l2 = []
+
+**Output:** []
+
+**Example 3:**
+
+**Input:** l1 = [], l2 = [0]
+
+**Output:** [0]
+
+**Constraints:**
+
+*   The number of nodes in both lists is in the range `[0, 50]`.
+*   `-100 <= Node.val <= 100`
+*   Both `l1` and `l2` are sorted in **non-decreasing** order.
+
+## Solution
+
+```rust
+// Definition for singly-linked list.
+// 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 merge_two_lists(
+        mut l1: Option<Box<ListNode>>,
+        mut l2: Option<Box<ListNode>>,
+    ) -> Option<Box<ListNode>> {
+        let mut dummy = Some(Box::new(ListNode::new(-1)));
+        let mut current = &mut dummy;
+
+        while l1.is_some() || l2.is_some() {
+            if let (Some(ref l1_node), Some(ref l2_node)) = (&l1, &l2) {
+                if l1_node.val <= l2_node.val {
+                    current.as_mut().unwrap().next = l1.take();
+                    l1 = current.as_mut().unwrap().next.as_mut().unwrap().next.take();
+                } else {
+                    current.as_mut().unwrap().next = l2.take();
+                    l2 = current.as_mut().unwrap().next.as_mut().unwrap().next.take();
+                }
+            } else if l1.is_some() {
+                current.as_mut().unwrap().next = l1.take();
+            } else {
+                current.as_mut().unwrap().next = l2.take();
+            }
+            current = &mut current.as_mut().unwrap().next;
+        }
+
+        dummy.unwrap().next
+    }
+}
+```

src/main/rust/g0001_0100/s0021_merge_two_sorted_lists/readme.md

@@ -0,0 +1,56 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 22\. Generate Parentheses
+
+Medium
+
+Given `n` pairs of parentheses, write a function to _generate all combinations of well-formed parentheses_.
+
+**Example 1:**
+
+**Input:** n = 3
+
+**Output:** ["((()))","(()())","(())()","()(())","()()()"]
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** ["()"]
+
+**Constraints:**
+
+*   `1 <= n <= 8`
+
+## Solution
+
+```rust
+impl Solution {
+    pub fn generate_parenthesis(n: i32) -> Vec<String> {
+        let mut result = Vec::new();
+        let mut current = String::new();
+        Solution::generate(&mut current, &mut result, n, n);
+        result
+    }
+
+    fn generate(current: &mut String, result: &mut Vec<String>, open: i32, close: i32) {
+        if open == 0 && close == 0 {
+            result.push(current.clone());
+            return;
+        }
+
+        if open > 0 {
+            current.push('(');
+            Solution::generate(current, result, open - 1, close);
+            current.pop();
+        }
+
+        if close > 0 && open < close {
+            current.push(')');
+            Solution::generate(current, result, open, close - 1);
+            current.pop();
+        }
+    }
+}
+```

src/main/rust/g0001_0100/s0022_generate_parentheses/readme.md

@@ -0,0 +1,109 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 23\. Merge k Sorted Lists
+
+Hard
+
+You are given an array of `k` linked-lists `lists`, each linked-list is sorted in ascending order.
+
+_Merge all the linked-lists into one sorted linked-list and return it._
+
+**Example 1:**
+
+**Input:** lists = \[\[1,4,5],[1,3,4],[2,6]]
+
+**Output:** [1,1,2,3,4,4,5,6]
+
+**Explanation:** The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted list: 1->1->2->3->4->4->5->6
+
+**Example 2:**
+
+**Input:** lists = []
+
+**Output:** []
+
+**Example 3:**
+
+**Input:** lists = \[\[]]
+
+**Output:** []
+
+**Constraints:**
+
+*   `k == lists.length`
+*   `0 <= k <= 10^4`
+*   `0 <= lists[i].length <= 500`
+*   `-10^4 <= lists[i][j] <= 10^4`
+*   `lists[i]` is sorted in **ascending order**.
+*   The sum of `lists[i].length` won't exceed `10^4`.
+
+## Solution
+
+```rust
+// Definition for singly-linked list.
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+// 
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+use std::cmp::Ordering;
+use std::collections::BinaryHeap;
+use std::cmp::Reverse;
+
+struct HeapNode(Box<ListNode>);
+
+impl PartialEq for HeapNode {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.val == other.0.val
+    }
+}
+
+impl Eq for HeapNode {}
+
+impl PartialOrd for HeapNode {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for HeapNode {
+    fn cmp(&self, other: &Self) -> Ordering {
+        other.0.val.cmp(&self.0.val)
+    }
+}
+
+impl Solution {
+    pub fn merge_k_lists(lists: Vec<Option<Box<ListNode>>>) -> Option<Box<ListNode>> {
+        let mut heap = BinaryHeap::new();
+        
+        for list in lists {
+            if let Some(node) = list {
+                heap.push(HeapNode(node));
+            }
+        }
+
+        let mut dummy = Box::new(ListNode::new(0));
+        let mut tail = &mut dummy;
+
+        while let Some(HeapNode(mut node)) = heap.pop() {
+            if let Some(next) = node.next.take() {
+                heap.push(HeapNode(next));
+            }
+            tail.next = Some(node);
+            tail = tail.next.as_mut().unwrap();
+        }
+
+        dummy.next
+    }
+}
+```

src/main/rust/g0001_0100/s0023_merge_k_sorted_lists/readme.md

@@ -0,0 +1,76 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Rust/LeetCode-in-Rust?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust)
+[![](https://img.shields.io/github/forks/LeetCode-in-Rust/LeetCode-in-Rust?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Rust/LeetCode-in-Rust/fork)
+
+## 24\. Swap Nodes in Pairs
+
+Medium
+
+Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg)
+
+**Input:** head = [1,2,3,4]
+
+**Output:** [2,1,4,3]
+
+**Example 2:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Example 3:**
+
+**Input:** head = [1]
+
+**Output:** [1]
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 100]`.
+*   `0 <= Node.val <= 100`
+
+## Solution
+
+```rust
+// Definition for singly-linked list.
+// 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 swap_pairs(mut head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut dummy = ListNode {
+            val: 0,
+            next: head,
+        };
+        let mut current = &mut dummy;
+        
+        while let Some(mut first) = current.next.take() {
+            if let Some(mut second) = first.next.take() {
+                first.next = second.next.take();
+                second.next = Some(first);
+                current.next = Some(second);
+                current = current.next.as_mut().unwrap().next.as_mut().unwrap();
+            } else {
+                current.next = Some(first);
+                break;
+            }
+        }      
+
+        dummy.next   
+    }
+}
+```