binary search solition rust 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)             | 12           |
+| Rust           | [Rust](Rust/README.md)             | [@sektor7k](https://github.com/sektor7k)             | 13           |
 | C++            | [Cpp](Cpp/README.md)               | [@sametaydinq](https://github.com/sametaydinq)       | 0            |
 
 ---

Rust/0704-binary-search/1-answer.md

@@ -0,0 +1,42 @@
+# [✅ Counts the Frequencies to solve the 🧑🏻‍💻 Binary Search Problem on 🦀 Rust language]()
+
+## 🧑🏻‍💻 Approach
+The function `search` takes in a vector of integers (`nums`) and a target integer (`target`).
+A copy of the `nums` vector is created and stored in `nums2` to avoid modifying the original vector.
+The `nums2` vector is sorted in ascending order using the `sort()` function.
+Pointers `low` and `high` are initialized to keep track of the search range in the sorted vector.
+The binary search algorithm is performed using a while loop, which continues until `low` is greater than `high`.
+Inside the loop, the middle index `mid` is calculated as the average of `low` and `high`.
+The element at the middle index (`nums2[mid]`) is compared to the target.
+If they are equal, it means the target has been found, and the index `mid` is returned as the result.
+If the element at the middle index is less than the target, it means the target is in the right half of the remaining range. Therefore, the `low` pointer is moved to `mid + 1`.
+If the element at the middle index is greater than the target, it means the target is in the left half of the remaining range. Therefore, the `high` pointer is moved to `mid - 1`.
+If the target is not found after the loop finishes, `-1` is returned as the result.
+
+## 🔐 Code
+
+``` rust
+    impl Solution {
+    pub fn search(nums: Vec<i32>, target: i32) -> i32 {
+        let mut nums2 = nums.clone();
+    nums2.sort();
+
+    let mut low = 0;
+    let mut high = nums2.len() as i32 - 1;
+
+    while low <= high{
+        let mid= (low+(high - low)/2) as usize;
+        if nums2[mid] == target{
+            return mid as i32;
+        }
+        else if nums2[mid]< target {
+            low = mid as i32 +1;
+        }
+        else {
+            high = mid as i32 -1
+        }
+    }
+    -1
+    }
+}
+```

Rust/0704-binary-search/question.md

@@ -0,0 +1,35 @@
+# [Binary Search](https://leetcode.com/problems/binary-search/)
+
+## 🚨 Problem
+<!-- Explanation of problem. -->
+Given an array of integers `nums` which is sorted in ascending order, and an integer `target`, write a function to search `target` in `nums`. If `target` exists, then return its index. Otherwise, return `-1`.
+
+You must write an algorithm with `O(log n)` runtime complexity.
+
+**Example 1:**
+<!-- An example of problem. -->
+
+>**Input:** nums = \[-1,0,3,5,9,12\], target = 9 </br> <!-- Input example. -->
+**Output:** 4 </br> <!-- Output example. -->
+**Explanation:** 9 exists in nums and its index is 4 <!-- Basic explanation of example. -->
+
+**Example 2:**
+<!-- An example of problem. -->
+
+>**Input:** nums = \[-1,0,3,5,9,12\], target = 2 </br> <!-- Input example. -->
+**Output:** -1 </br> <!-- Output example. -->
+**Explanation:** 2 does not exist in nums so return -1 <!-- Basic explanation of example. -->
+
+**Constraints:**
+<!-- Constraints of problem. -->
+- $1 <= nums.length <= 10^4$
+- $-10^4 < nums[i], target < 10^4$
+- All the integers in `nums` are **unique**.
+- `nums` is sorted in ascending order.
+
+## 🔐 Solutions
+<!-- Solutions of problem and their links. -->
+
+| ID  |            METHOD            |
+| :-- | :--------------------------: |
+| 1   | [Binary Search](1-answer.md) |

Rust/README.md

@@ -16,6 +16,7 @@
 | 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           |
+| 13  | 0704        |                   [Binary Search](0704-binary-search/question.md)                   | Binary Search    | Easy           |
 
 <div align="center">
   <h1>Awesome Leetcode Algorithms Solututions With Rust</h1>