Insertion sort code added

Author: me-shaon

Sorting/Bubble Sort/README.md

@@ -6,3 +6,20 @@ It is called Bubble sort, because *with each iteration the smaller element in th
 
 Sorting takes place by stepping through all the data items one-by-one in pairs and comparing adjacent data items and swapping each pair that is out of order.
 ![bubble sort demonstration](bubble-sort.png)
+
+
+---
+**A visualization on the algorithm:**
+
+Starting from the beginning of the list, compare every adjacent pair, swap their position if they are not in the right order (the latter one is smaller than the former one). After each iteration, one less element (the last one) is needed to be compared until there are no more elements left to be compared.
+
+![Bubble sort gif](https://upload.wikimedia.org/wikipedia/commons/c/c8/Bubble-sort-example-300px.gif)
+
+####Complexity Analysis
+- Worst Case - O(n<sup>2</sup>)
+- Average Case - O(n<sup>2</sup>)
+- Best Case - O(n)
+### More on this topic
+- http://en.wikipedia.org/wiki/Bubble_sort
+- http://quiz.geeksforgeeks.org/bubble-sort/
+- https://www.topcoder.com/community/data-science/data-science-tutorials/sorting/

Sorting/Insertion Sort/Insertion.java

@@ -0,0 +1,26 @@
+public class Insertion 
+{
+	//Following function will sort the array in Increasing (ascending) order
+    void sort(int arr[])
+    {
+        int i, current_value, j;
+
+        int n = arr.length;
+
+        for (i = 1; i < n; i++)
+        {
+            current_value = arr[i];
+            j = i-1;
+
+            /* Move elements of arr[0..i-1], that are
+                greater than current_value, to one position ahead
+                of their current position */
+            while (j >= 0 && arr[j] > current_value)
+            {
+                arr[j+1] = arr[j];
+                j = j-1;
+            }
+            arr[j+1] = current_value;
+        }
+    }
+}

Sorting/Insertion Sort/Main.java

@@ -0,0 +1,21 @@
+public class Main 
+{
+	// Prints the array 
+    private static void printList(int arr[])
+    {
+        int n = arr.length;
+        for (int i=0; i<n; ++i)
+            System.out.print(arr[i] + " ");
+        System.out.println();
+    }
+    
+	public static void main(String[] args) 
+	{
+		Bubble insertion = new Insertion();
+        int arr[] = {64, 34, 25, 12, 22, 11, 90};
+        insertion.sort(arr);
+        System.out.println("Sorted array");
+        printList(arr);
+	}
+
+}

Sorting/Insertion Sort/README.md

@@ -0,0 +1,19 @@
+# Insertion Sort
+
+**Insertion sort** does exactly what you would expect: it inserts each element of the array into its proper position, leaving progressively larger stretches of the array sorted. What this means in practice is that the sort iterates down an array, and the part of the array already covered is in order; then, the current element of the array is inserted into the proper position at the head of the array, and the rest of the elements are moved down, using the space just vacated by the element inserted as the final space.
+
+![Insertion Sort](insertion_sort.jpg)
+
+
+#####A visualization on Insertion Sort
+![Insertion sort demonstration](https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif)
+
+
+####Complexity Analysis
+- Worst Case - О(n<sup>2</sup>) comparisons, swaps
+- Average Case - О(n<sup>2</sup>) comparisons, swaps
+- Best Case - O(n) comparisons, O(1) swaps
+### More on this topic
+- https://en.wikipedia.org/wiki/Insertion_sort
+- http://quiz.geeksforgeeks.org/insertion-sort/
+- https://www.topcoder.com/community/data-science/data-science-tutorials/sorting/

Sorting/Insertion Sort/insertion_sort.jpg

@@ -0,0 +1,12 @@
+#Sorting
+
+>A sorting algorithm is an algorithm that puts elements of a list in a certain order. The most-used orders are numerical order and lexicographical order. Efficient sorting is important for optimizing the use of other algorithms (such as search and merge algorithms) which require input data to be in sorted lists; it is also often useful for canonicalizing data and for producing human-readable output. [wikipedia](https://en.wikipedia.org/wiki/Sorting_algorithm)
+
+
+
+###Useful Links:
+- [Nice animated visualization of sorting algorithms](https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html)
+- [Sorting visualization](https://visualgo.net/sorting)
+- [betterexplained.com article on Sorting algorithms](https://betterexplained.com/articles/sorting-algorithms/)
+- [Topcoder article](https://www.topcoder.com/community/data-science/data-science-tutorials/sorting/)
+- [Comparison of Sorting algorithms](https://en.wikipedia.org/wiki/Sorting_algorithm#Comparison_of_algorithms)