Reverse Linked List solition added

Author: sektor7k

README.md

@@ -5,7 +5,7 @@
 | Python         | [Python](Python/README.md)         | [@muffafa](https://github.com/muffafa)               | 14           |
 | Java           | [JAVA](Java/README.md)             | [@cagridemirtash](https://github.com/cagridemirtash) | 3            |
 | Javascript     | [Javascript](Javascript/README.md) | [@kaanncavdar](https://github.com/kaanncavdar)       | 4            |
-| Rust           | [Rust](Rust/README.md)             | [@sektor7k](https://github.com/sektor7k)             | 11           |
+| Rust           | [Rust](Rust/README.md)             | [@sektor7k](https://github.com/sektor7k)             | 12           |
 | C++            | [Cpp](Cpp/README.md)               | [@sametaydinq](https://github.com/sametaydinq)       | 0            |
 
 ---

Rust/0001-two-sum/two-sum.md

@@ -1,7 +1,7 @@
 # Brute Force to solve the Two-Sum Problem on Rust language
 
 
-## Complexity
+## 🧑🏻‍💻 Approach
 
 The function `two_sum` takes two parameters: a vector of integers `nums` and a target integer `target`. It aims to find two numbers in the `nums` vector whose sum equals the `target`. The function returns a vector containing the indices of these two numbers.
 

Rust/0020-valid-parentheses/1-answer.md

@@ -1,6 +1,6 @@
 # [✅ Stack and Map to solve the 🧑🏻‍💻 Valid Parentheses on 🦀  RUST language]()
 
-## 🧩 Complexity
+## 🧑🏻‍💻 Approach
 
 Create an empty vector called `result` to act as a stack.
 

Rust/0049-group-anagram/group-anagram.md

@@ -1,7 +1,7 @@
 # ✅ Counts the Frequencies to solve the 🧑🏻‍💻 Group Anagram Problem on 😎 Rust language
 
 
-## Complexity
+## 🧑🏻‍💻 Approach
 
 This code contains a function called `group_anagrams`, which takes a `Vec<String>` parameter named `strs` and returns a vector containing the groups of anagrams.
 

Rust/0121-best-time-to-buy-and-sell-stock/1-answer.md

@@ -1,6 +1,6 @@
 # [✅ Double Stack to solve the 🧑🏻‍💻 Best Time to Buy and Sell Stock Problem on 🦀 RUST language](#)
 
-## 🧩 Complexity
+## 🧑🏻‍💻 Approach
 
 The function `max_profit` takes a vector of integers `prices` as input and returns an integer representing the maximum profit that can be obtained from buying and selling a stock.
 

Rust/0125-valid-palindrome/1-answer.md

@@ -1,6 +1,6 @@
 # [✅ Lowercase Alphanumeric to solve the 🧑🏻‍💻 Valid Palindrome Problem on 🦀 Python language]()
 
-## 🧩 Complexity
+## 🧑🏻‍💻 Approach
 
 The `Solution` struct contains a public function `is_palindrome` that takes a `String` parameter `s` and returns a boolean value. The goal of the function is to determine if the given string `s` is a palindrome.
 

Rust/0155-min-stack/1-answer.md

@@ -1,6 +1,6 @@
 # [✅ Double Stack to solve the 🧑🏻‍💻 Min Stack Problem on 🦀 RUST language]()
 
-## 🧩 Complexity
+## 🧑🏻‍💻 Approach
 
 `new()`: This is the constructor method that creates a new instance of `MinStack` by initializing an empty `Vec` using `Vec::new()`.
 

Rust/0155-min-stack/2-answer.md

@@ -1,6 +1,6 @@
 # [✅ Double Stack to solve the 🧑🏻‍💻 Min Stack Problem on 🦀 RUST language]()
 
-## 🧩 Complexity
+## 🧑🏻‍💻 Approach
 
 `new()`: This is the constructor method that creates a new instance of `MinStack` by initializing empty vectors for `stack` and `min_stack` using `Vec::new()`.
 

Rust/0167-two-sum-2/1-answer.md

@@ -1,6 +1,6 @@
 # Brute Force to solve the Two-Sum 2 Problem on Rust language
 
-## Complexity
+## 🧑🏻‍💻 Approach
 
 The function `two_sum` takes two parameters: a vector of integers `nums` and a target integer `target`. It aims to find two numbers in the `nums` vector whose sum equals the `target`. The function returns a vector containing the indices of these two numbers.
 

Rust/0206-reverse-linked-list/1-answer.md

@@ -0,0 +1,55 @@
+# [✅ Iteratively solving the 🧑🏻‍💻 Reverse Linked List Problem on 🦀 Rust language]()
+
+## 🧑🏻‍💻 Approach
+
+The given code defines a struct `ListNode` that represents a node of a linked list. It has two fields: `val`, which stores the value of the node, and `next`, which is an `Option` containing the next node in the list.
+
+The `impl` block contains an implementation for the `ListNode` struct. It defines a constructor function `new` that creates a new `ListNode` with the given value and initializes `next` to `None`.
+
+The `reverse_list` function takes an `Option<Box<ListNode>>` as input, representing the head of a linked list, and returns the head of the reversed linked list.
+
+Inside the function, two variables `current` and `previous` are initialized. `current` holds the current node being processed, and `previous` holds the reversed portion of the linked list.
+
+The function enters a loop, where it iteratively reverses the linked list. It uses a combination of `while let` and `Option::take()` to move the current node (`node`) out of the Option and assign its next to `current`.
+
+Within each iteration, the `next` node is temporarily stored, and the `next` field of the current node is set to `previous`, effectively reversing the pointer direction.
+
+Finally, the `previous` node becomes the new `current` node, and the `next` node becomes the new `current` for the next iteration.
+
+Once the loop completes, the reversed linked list is stored in `previous`, which now represents the new head of the reversed list, and it is returned.
+
+## 🔐 Code
+
+``` 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_list(head: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        let mut current = head;
+        let mut previous = None;
+
+        while let Some(mut node) = current{
+            let next = node.next.take();
+            node.next=previous;
+            previous = Some(node);
+            current = next;
+        }
+
+        previous
+    }
+}
+```

Rust/0206-reverse-linked-list/img/rev1ex1.jpg

@@ -0,0 +1,42 @@
+# [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/)
+
+## 🚨 Problem
+<!-- Explanation of problem. -->
+Given the `head` of a singly linked list, reverse the list, and return _the reversed list_.
+
+**Example 1:**
+<!-- An example of problem. -->
+![example 1](./img/rev1ex1.jpg)
+
+>**Input:** head = \[1,2,3,4,5\] </br> <!-- Input example. -->
+**Output:** \[5,4,3,2,1\] </br> <!-- Output example. -->
+
+**Example 2:**
+<!-- An example of problem. -->
+![example 2](./img/rev1ex2.jpg)
+
+>**Input:** head = \[1,2\] </br> <!-- Input example. -->
+**Output:** \[2,1\] </br> <!-- Output example. -->
+
+**Example 3:**
+<!-- An example of problem. -->
+
+>**Input:** head = \[\] </br> <!-- Input example. -->
+**Output:** \[\] </br> <!-- Output example. -->
+
+**Constraints:**
+<!-- Constraints of problem. -->
+- The number of nodes in the list is the range `[0, 5000]`.
+- `-5000 <= Node.val <= 5000`
+
+**Follow-up:**  
+<!-- Do more! -->
+A linked list can be reversed either iteratively or recursively. Could you implement both?
+
+## 🔐 Solutions
+<!-- Solutions of problem and their links. -->
+
+| ID  |          METHOD          |
+| :-- | :----------------------: |
+| 1   | [Iterative](1-answer.md) |
+

Rust/0206-reverse-linked-list/img/rev1ex2.jpg

@@ -1,6 +1,6 @@
 # Contains Duplicate on Rust language
 
-## Complexity
+## 🧑🏻‍💻 Approach
 
 First, we import the necessary library std::collections::HashSet to use the HashSet data structure.ses a constant amount of memory, regardless of the size of the input array. Next, we define a function called contains_duplicate which takes a Vec<i32> input parameter named nums and returns a bool value. Inside the function, we create a HashSet of type HashSet<i32> to keep track of numbers we have encountered so far. Then, we start a loop for each element in the nums vector. At each iteration, we check if the element is already present in the set. If it is, it means we have encountered a duplicate element, so we return true. If the element is not present in the set, we add it to the set so that we can check if the next element is a duplicate. Once the loop is completed, it means there are no duplicate elements, so we return false. This way, the contains_duplicate function checks for the presence of duplicate elements in the given number vector. You can call the function and test it with sample cases to ensure its correctness. In this example, since the number 1 appears twice in the nums vector, the output will be "true". You can create your own test cases to verify that the function works correctly.
 

Rust/0206-reverse-linked-list/question.md

@@ -1,6 +1,6 @@
 # [✅ Prefix and Postfix to solve the 🧑🏻‍💻 Product of Array Except Self Problem on 🦀 Rust language]()
 
-## 🧩 Complexity
+## 🧑🏻‍💻 Approach
 
 First, we assign the length of the `nums` vector to the variable `n`.
 

Rust/0217-contains-duplicate/1-answer.md

@@ -1,10 +1,6 @@
 # ✅ Counts the Frequencies to solve the 🧑🏻‍💻 Valid Anagram Problem on 😎 Rust language
 
-## Approach
-<!-- Describe your approach to solving the problem. -->
-In summary, the approach counts the frequencies of characters in both strings using dictionaries and checks if the character frequencies in s and t are the same. If the character frequencies match, the method returns `True`, indicating that t is an anagram of s. Otherwise, it returns `False`.
-
-## Complexity
+## 🧑🏻‍💻 Approach
 
 This code contains a function `is_anagram` nested inside a structure called `Solution`. The function checks whether the given two input strings are anagrams of each other.
 

Rust/0238-product-of-array-except-self/1-answer.md

@@ -1,6 +1,6 @@
 # [✅ Counts and Sort to solve the 🧑🏻‍💻 Top K Frequent Elements Problem on 🦀 RUST language]()
 
-## 🧩 Complexity
+## 🧑🏻‍💻 Approach
 
 You defined a helper function called `remove_duplicates`. This function removes duplicate numbers from the given vector and returns a sorted vector. It achieves this by first converting the input vector into a `HashSet`, which automatically filters out duplicates. Then, it converts the `HashSet` back into a `Vec` and sorts it to maintain the order of the numbers.
 

Rust/0242-valid-anagram/valid-anagram.md

@@ -15,6 +15,7 @@
 | 9   | 0155        |                       [Min Stack](0155-min-stack/question.md)                       | Stack            | Medium         | Amazon      |
 | 10  | 0167        |           [Two Sum II Input Array Is Sorted](0167-two-sum-2/question.md)            | Two Pointers     | Medium         | Amazon      |
 | 11  | 0121        | [Best Time to Buy and Sell Stock](0121-best-time-to-buy-and-sell-stock/question.md) | Sliding Window   | Easy           |             |
+| 12  | 0206        |             [Reverse Linked List](0206-reverse-linked-list/question.md)             | Linked List      | Easy           |
 
 <div align="center">
   <h1>Awesome Leetcode Algorithms Solututions With Rust</h1>