Insertion, Linear Search, Quicksort and Selection Added

Insertion, Linear Search, Quicksort and Selection algorithms added.

Author: thewillyhuman

BubbleSort/readme.md renamed to Bubblesort/readme.md

@@ -0,0 +1,86 @@
+# Insertion Sort
+
+Goal: Sort an array from low to high (or high to low).
+
+You are given an array of numbers and need to put them in the right order. The insertion sort algorithm works as follows:
+
+- Put the numbers on a pile. This pile is unsorted.
+- Pick a number from the pile. It doesn't really matter which one you pick, but it's easiest to pick from the top of the pile. 
+- Insert this number into a new array. 
+- Pick the next number from the unsorted pile and also insert that into the new array. It either goes before or after the first number you picked, so that now these two numbers are sorted.
+- Again, pick the next number from the pile and insert it into the array in the proper sorted position.
+- Keep doing this until there are no more numbers on the pile. You end up with an empty pile and an array that is sorted.
+
+That's why this is called an "insertion" sort, because you take a number from the pile and insert it in the array in its proper sorted position. 
+
+## An example
+
+Let's say the numbers to sort are `[ 8, 3, 5, 4, 6 ]`. This is our unsorted pile.
+
+Pick the first number, `8`, and insert it into the new array. There is nothing in that array yet, so that's easy. The sorted array is now `[ 8 ]` and the pile is `[ 3, 5, 4, 6 ]`.
+
+Pick the next number from the pile, `3`, and insert it into the sorted array. It should go before the `8`, so the sorted array is now `[ 3, 8 ]` and the pile is reduced to `[ 5, 4, 6 ]`.
+
+Pick the next number from the pile, `5`, and insert it into the sorted array. It goes in between the `3` and `8`. The sorted array is `[ 3, 5, 8 ]` and the pile is `[ 4, 6 ]`.
+
+Repeat this process until the pile is empty.
+
+## In-place sort
+
+The above explanation makes it seem like you need two arrays: one for the unsorted pile and one that contains the numbers in sorted order.
+
+But you can perform the insertion sort *in-place*, without having to create a separate array. You just keep track of which part of the array is sorted already and which part is the unsorted pile.
+
+Initially, the array is `[ 8, 3, 5, 4, 6 ]`. The `|` bar shows where the sorted portion ends and the pile begins:
+
+	[| 8, 3, 5, 4, 6 ]
+
+This shows that the sorted portion is empty and the pile starts at `8`.
+
+After processing the first number, we have:
+
+	[ 8 | 3, 5, 4, 6 ]
+
+The sorted portion is `[ 8 ]` and the pile is `[ 3, 5, 4, 6 ]`. The `|` bar has shifted one position to the right.
+
+This is how the content of the array changes during the sort:
+
+	[| 8, 3, 5, 4, 6 ]
+	[ 8 | 3, 5, 4, 6 ]
+	[ 3, 8 | 5, 4, 6 ]
+	[ 3, 5, 8 | 4, 6 ]
+	[ 3, 4, 5, 8 | 6 ]
+	[ 3, 4, 5, 6, 8 |]
+
+In each step, the `|` bar moves up one position. As you can see, the beginning of the array up to the `|` is always sorted. The pile shrinks by one and the sorted portion grows by one, until the pile is empty and there are no more unsorted numbers left.
+
+## How to insert
+
+At each step you pick the top-most number from the unsorted pile and insert it into the sorted portion of the array. You must put that number in the proper place so that the beginning of the array remains sorted. How does that work?
+
+Let's say we've already done the first few elements and the array looks like this:
+
+	[ 3, 5, 8 | 4, 6 ]
+
+The next number to sort is `4`. We need to insert that into the sorted portion `[ 3, 5, 8 ]` somewhere. 
+
+Here's one way to do this: Look at the previous element, `8`. 
+
+	[ 3, 5, 8, 4 | 6 ]
+	        ^
+	        
+Is this greater than `4`? Yes it is, so the `4` should come before the `8`. We swap these two numbers to get:
+
+	[ 3, 5, 4, 8 | 6 ]
+	        <-->
+	       swapped
+
+We're not done yet. The new previous element, `5`, is also greater than `4`. We also swap these two numbers:
+
+	[ 3, 4, 5, 8 | 6 ]
+	     <-->
+	    swapped
+
+Again, look at the previous element. Is `3` greater than `4`? No, it is not. That means we're done with number `4`. The beginning of the array is sorted again.
+
+This was a description of the inner loop of the insertion sort algorithm, which you'll see in the next section. It inserts the number from the top of the pile into the sorted portion by swapping numbers.

Insertionsort/readme.md

@@ -0,0 +1,13 @@
+# Linear Search
+
+Goal: Find a particular value in an array.
+
+We have an array of generic objects. With linear search, we iterate over all the objects in the array and compare each one to the object we're looking for. If the two objects are equal, we stop and return the current array index. If not, we continue to look for the next object as long as we have objects in the array.
+
+## An example
+
+Let's say we have an array of numbers `[5, 2, 4, 7]` and we want to check if the array contains the number `2`.
+
+We start by comparing the first number in the array, `5`, to the number we're looking for, `2`. They are obviously not the same, and so we continue to the next array element.
+
+We compare the number `2` from the array to our number `2` and notice they are equal. Now we can stop our iteration and return 1, which is the index of the number `2` in the array.

Linearsearch/readme.md

@@ -0,0 +1,11 @@
+# Quicksort
+ 
+Goal: Sort an array from low to high (or high to low).
+ 
+Quicksort is one of the most famous algorithms in history. It was invented way back in 1959 by Tony Hoare, at a time when recursion was still a fairly nebulous concept.
+ 
+Here's how it works. When given an array, `quicksort()` splits it up into three parts based on a "pivot" variable. Here, the pivot is taken to be the element in the middle of the array (later on you'll see other ways to choose the pivot).
+
+All the elements less than the pivot go into a new array called `less`. All the elements equal to the pivot go into the `equal` array. And you guessed it, all elements greater than the pivot go into the third array, `greater`. This is why the generic type `T` must be `Comparable`, so we can compare the elements with `<`, `==`, and `>`.
+
+Once we have these three arrays, `quicksort()` recursively sorts the `less` array and the `greater` array, then glues those sorted subarrays back together with the `equal` array to get the final result.

Quicksort/readme.md

@@ -0,0 +1,55 @@
+# Selection Sort
+
+Goal: To sort an array from low to high (or high to low).
+
+You are given an array of numbers and need to put them in the right order. The selection sort algorithm divides the array into two parts: the beginning of the array is sorted, while the rest of the array consists of the numbers that still remain to be sorted.
+
+	[ ...sorted numbers... | ...unsorted numbers... ]
+
+This is similar to [insertion sort](../Insertion%20Sort/), but the difference is in how new numbers are added to the sorted portion.
+
+It works as follows:
+
+- Find the lowest number in the array. You must start at index 0, loop through all the numbers in the array, and keep track of what the lowest number is.
+- Swap the lowest number with the number at index 0. Now, the sorted portion consists of just the number at index 0.
+- Go to index 1.
+- Find the lowest number in the rest of the array. This time you start looking from index 1. Again you loop until the end of the array and keep track of the lowest number you come across.
+- Swap  the lowest number with the number at index 1. Now, the sorted portion contains two numbers and extends from index 0 to index 1.
+- Go to index 2.
+- Find the lowest number in the rest of the array, starting from index 2, and swap it with the one at index 2. Now, the array is sorted from index 0 to 2; this range contains the three lowest numbers in the array.
+- And continue until no numbers remain to be sorted.
+
+It is called a "selection" sort because at every step you search through the rest of the array to select the next lowest number.
+
+## An example
+
+Suppose the numbers to sort are `[ 5, 8, 3, 4, 6 ]`. We also keep track of where the sorted portion of the array ends, denoted by the `|` symbol.
+
+Initially, the sorted portion is empty:
+
+	[| 5, 8, 3, 4, 6 ]
+
+Now we find the lowest number in the array. We do that by scanning through the array from left to right, starting at the `|` bar. We find the number `3`.
+
+To put this number into the sorted position, we swap it with the number next to the `|`, which is `5`:
+
+	[ 3 | 8, 5, 4, 6 ]
+	  *      *
+
+The sorted portion is now `[ 3 ]` and the rest is `[ 8, 5, 4, 6 ]`.
+
+Again, we look for the lowest number, starting from the `|` bar. We find `4` and swap it with `8` to get:
+
+	[ 3, 4 | 5, 8, 6 ]
+	     *      *
+
+With every step, the `|` bar moves one position to the right. We again look through the rest of the array and find `5` as the lowest number. There is no need to swap `5` with itself, and we simply move forward:
+
+	[ 3, 4, 5 | 8, 6 ]
+	        *
+
+This process repeats until the array is sorted. Note that everything to the left of the `|` bar is always in sorted order and always contains the lowest numbers in the array. Finally, we end up with:
+
+	[ 3, 4, 5, 6, 8 |]
+
+The selection sort is an *in-place* sort because everything happens in the same array without using additional memory. You can also implement this as a *stable* sort so that identical elements do not get swapped around relative to each other (note that the version given below is not stable).