Minor changes

Author: msdundar

.gitignore

@@ -0,0 +1 @@
+.DS_Store

1-binary-search/README.md

@@ -1,21 +1,23 @@
 # Binary Search
 
-- Binary search is a divide-and-conquer algorithm; its input is a **sorted** list of elements. If an element you're looking for is in that list, binary search returns the position **where it's located**. Otherwise, binary search returns **null**.
+- Binary search is an example of the famous divide-and-conquer algorithm; its input is a **sorted** list of elements. If an element you're looking for is in that list, binary search returns the position of the item. Otherwise, it returns **null**.
 
-- We can only conduct binary search with ordered lists, such as alphabetically ordered phone list, ordered list of numbers etc.
+- You can only conduct binary search in ordered lists.
 
-- In general, for any list of n, binary search will take **log<sub>2</sub>n** steps to run in the worst case, whereas simple search will take **n** steps.
+- In general, for any list of `n`, binary search will take **log<sub>2</sub>n** steps to run in the worst case, whereas simple search will take **n** steps.
 
   ![logarithms](images/logarithms.png)
 
-In this book, when I talk about running time in Big O notation (explained a little later), log always means log<sub>2</sub>.
+In the documents, log always means log<sub>2</sub>.
 
 ## Running Time
 
 | Running Time | Log(n) vs n |
 | ------------ | ----------- |
 | ![running-time](images/running-time.png) | ![log-n](images/log-n.png) |
 
-The key idea is that when binary search makes an incorrect guess, the portion of the array that contains reasonable guesses is reduced by at least half. If the reasonable portion had 32 elements, then an incorrect guess cuts it down to have at most 16. Binary search halves the size of the reasonable portion upon every incorrect guess.
+When binary search makes an incorrect guess, the portion of the array that contains reasonable guesses is reduced by at least half. If the reasonable portion had 32 elements, then an incorrect guess cuts it down to have at most 16. Binary search halves the size of the reasonable portion upon every incorrect guess.
+
+## Interesting Fact
 
 > According to 'Programming Pearls', only 10% of professional programmers are able to implement binary search in their code. They can explain it very well, but coding it is a challenge for them.

10-hash-tables/.DS_Store

@@ -1,14 +1,14 @@
 # Big-o-notation
 
-- Big-o-notation is special notation that tells you how fast an algorithm is.
+- Big-o-notation is a special notation that tells you how fast an algorithm is.
 
-- Simple search needs to check each element, so it will take **n** operations. The run tme in Big O notation is **O(n)**.
+- Simple search needs to check each element, so it will take **n** operations. The run time in Big O notation is **O(n)**.
 
 - Binary search needs **log(n)** operations to check a list of size n. Running time in Big O notation is **O(log n)**.
 
-- Big O will not tell you anything about how long it will take, it will only tell you how fast the algorithm grows.
+- Big O will not tell you anything about how long it will take, it will only tell you how fast the algorithm grows, in other words how your algorithm scales.
 
-- Big O always considers the worst case. If we are lucky, we can find the value that we are searching for even in the first try, but Big(O) always considers the worst case. Omega(n) considers the best case, and Theta(n) considers the average case.
+- Big O always considers the worst case. If you are lucky, you can find the value that we you searching for even in the first try, but Big(O) always considers the worst case. Omega(n) considers the best case, and Theta(n) considers the average case.
 
   ![big-o-notation](images/big-o-notation.png)
 
@@ -18,7 +18,7 @@
 - O(n), also known as linear time. Simple search.
 - O(n * log<sub>n</sub>). A fast sorting algorithm like quicksort.
 - O(n<sup>2</sup>). A slow sorting algorithm like selection sort.
-- 0(n!). A really slow algorithm like traveling salesperson.
+- O(n!). A really slow algorithm like traveling salesperson.
 
 ## Summary