From f0d4b18d29e741cf31d1587acc83786bba96176c Mon Sep 17 00:00:00 2001
From: Daksh Shah <dakshshah96@gmail.com>
Date: Wed, 22 Jun 2016 21:47:55 +0300
Subject: [PATCH 1/2] Add Algorithms Binary Search

---
 Algorithms-Binary-Search.md | 82 +++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 Algorithms-Binary-Search.md

diff --git a/Algorithms-Binary-Search.md b/Algorithms-Binary-Search.md
new file mode 100644
index 000000000..0f0b301bb
--- /dev/null
+++ b/Algorithms-Binary-Search.md
@@ -0,0 +1,82 @@
+# Binary search
+
+Binary search is a search algorithm that finds the position of a target value within a sorted array.
+
+## Example
+
+![Binary search](https://upload.wikimedia.org/wikipedia/commons/f/f7/Binary_search_into_array.png)
+
+The above illustration shows the working of the binary search algorithm on a sorted array when the target value is **4**.
+
+## Algorithm
+
+Binary search works on sorted arrays. A binary search begins by comparing the middle element of the array with the target value. If the target value matches the middle element, its position in the array is returned. If the target value is less or more than the middle element, the search continues the lower or upper half of the array respectively with a new middle element, eliminating the other half from consideration.
+
+The pseudocode for binary search algorithm is as follows:
+
+```
+BinarySearch(A[0..N-1], value) {
+  low = 0
+  high = N - 1
+  while (low <= high) {
+    // invariants: value > A[i] for all i < low
+                   value < A[i] for all i > high
+    mid = (low + high) / 2
+    if (A[mid] > value)
+      high = mid - 1
+    else if (A[mid] < value)
+      low = mid + 1
+    else
+      return mid
+  }
+  return not_found // value would be inserted at index "low"
+}
+```
+
+## Complexity
+
+```
+Worst case performance: O(log n)
+
+Best case performance: O(1)
+
+Average case performance: O(log n)
+
+Worst case space complexity: O(1) for iterative; O(log n) for recursive.
+```
+
+## C++ Implementation
+
+```c++
+int binarySearch(int arr[], int value, int left, int right) {
+  int middle;
+  while (left <= right) {
+    middle = (left + right) / 2;
+    if (arr[middle] == value)
+      return middle;
+    else if (arr[middle] > value)
+      right = middle - 1;
+    else
+      left = middle + 1;
+  }
+  return -1;
+}
+```
+
+:rocket: [Run Code](https://repl.it/CWZq/158)
+
+## Python Implementation
+
+```python
+def binary_search(l, value):
+    low = 0
+    high = len(l)-1
+    while low <= high:
+        mid = (low+high)//2
+        if l[mid] > value: high = mid-1
+        elif l[mid] < value: low = mid+1
+        else: return mid
+    return -1
+```
+
+:rocket: [Run Code](https://repl.it/CWZi/2)

From 58d50b9d1d22b3cf8732ba67842c531045490d11 Mon Sep 17 00:00:00 2001
From: Daksh Shah <dakshshah96@gmail.com>
Date: Wed, 22 Jun 2016 22:45:52 +0300
Subject: [PATCH 2/2] Big-O suggestion implemented

---
 Algorithms-Binary-Search.md | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/Algorithms-Binary-Search.md b/Algorithms-Binary-Search.md
index 0f0b301bb..e8ce33133 100644
--- a/Algorithms-Binary-Search.md
+++ b/Algorithms-Binary-Search.md
@@ -35,15 +35,10 @@ BinarySearch(A[0..N-1], value) {
 
 ## Complexity
 
-```
-Worst case performance: O(log n)
-
-Best case performance: O(1)
-
-Average case performance: O(log n)
-
-Worst case space complexity: O(1) for iterative; O(log n) for recursive.
-```
+- Worst case performance: **O(log n)**
+- Best case performance: **O(1)**
+- Average case performance: **O(log n)**
+- Worst case space complexity: **O(1)** for iterative; **O(log n)** for recursive.
 
 ## C++ Implementation