organizing the project and updating few README.md files

Author: rohan-paul

README.md

@@ -0,0 +1,8 @@
+My implementations and solutions of classic and popular algorithms and data structures.
+
+I have put my notes and references for each algorithm and data structure in its own separate README.md file.
+
+### Algorithms and Data Structure by Topic
+
+* **Sorting**
+  * [Bubble Sort](Sorting/Bubble-Sort)

Sorting/Bubble-Sort/README.md

@@ -0,0 +1,25 @@
+# Bubble Sort
+
+When people first start learning sorting algorithms, they usually learn the bubble sort algorithm first, because it is the simplest of all the sorting algorithms. However, it is one of the worst-case sorting algorithms with respect to runtime. The bubble sort algorithm compares every two adjacent items and swaps them if the first one is bigger than the second one. It has this name because the items tend to move up into the correct order, like bubbles rising to the surface.
+bubble-sort should not be used for larger arrays, can be used for smaller ones for its simplicity.
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/c/c8/Bubble-sort-example-300px.gif)
+
+## Complexity
+
+| Name                  | Best            | Average             | Worst               | Memory    | Stable    | Comments  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Bubble sort**       | n               | n<sup>2</sup>       | n<sup>2</sup>       | 1         | Yes       |           |
+
+
+## MOST IMPORTANT POINT OF BUBBLE SORT (And base of my solution SOLUTION-3 ) :-
+
+A> After the whole first pass is done, (i.e. after the first for loop for i = 0 is run , which also means, for each of i = 0 all the values of the nested for loop for j = 0 to j = arr.length - 1 is run) - The
+
+See this for pictorial representation - http://codingmiles.com/sorting-algorithms-bubble-sort-using-javascript/
+
+B> In other words, after the first pass, the biggest elements is placed at its correct position.
+
+C) And this IS THE PRINCIPLE BASED ON WHICH I CAN IMPROVE THE ALGO BY REDUCING THE NO OF PASSES FOR THE INNER NESTED FOR LOOP EACH TIME - Meaning, for the second loop of i = 1 pass, I actually no more have to compare the right-most element. As I know the right-most element is the biggest and has been placed at its correct right-most position.
+
+D) Then for for the next loop i=2, I can reduce the no of comarison for the nested for loop by 2, because I know, that the biggest 2 element has already been placed to the farthest right side.

Sorting/bubble-sort-Loiane-Book/bubble-sort--optimized.js renamed to Sorting/Bubble-Sort/bubble-sort-Loiane-Book/bubble-sort--optimized.js

@@ -1,21 +1,3 @@
-/* When people first start learning sorting algorithms, they usually learn the bubble sort algorithm first, because it is the simplest of all the sorting algorithms. However, it is one of the worst-case sorting algorithms with respect to runtime. The bubble sort algorithm compares every two adjacent items and swaps them if the first one is bigger than the second one. It has this name because the items tend to move up into the correct order, like bubbles rising to the surface.
-bubble-sort should not be used for larger arrays, can be used for smaller ones for its simplicity.
-
-
-MOST IMPORTANT POINT OF BUBBLE SORT (And base of my solution SOLUTION-3 ) :-
-
-A> After the whole first pass is done, (i.e. after the first for loop for i = 0 is run , which also means, for each of i = 0 all the values of the nested for loop for j = 0 to j = arr.length - 1 is run) - The
-
-See this for pictorial representation - http://codingmiles.com/sorting-algorithms-bubble-sort-using-javascript/
-
-B> In other words, after the first pass, the biggest elements is placed at its correct position.
-
-C) And this IS THE PRINCIPLE BASED ON WHICH I CAN IMPROVE THE ALGO BY REDUCING THE NO OF PASSES FOR THE INNER NESTED FOR LOOP EACH TIME - Meaning, for the second loop of i = 1 pass, I actually no more have to compare the right-most element. As I know the right-most element is the biggest and has been placed at its correct right-most position.
-
-D) Then for for the next loop i=2, I can reduce the no of comarison for the nested for loop by 2, because I know, that the biggest 2 element has already been placed to the farthest right side.
-
-*/
-
 let arr = Array.from({ length: 20}, () => Math.floor(Math.random() * 20))
 // console.log(arr);
 var array1 = [9, 2, 5, 6, 4, 3, 7, 10, 1, 8];
@@ -50,7 +32,7 @@ bubbleSortBasicAscending1 = (arr) => {
   return arr;
 }
 
-console.log(bubbleSortBasicAscending1(array1));
+// console.log(bubbleSortBasicAscending1(array1));
 
 // Now the same solution but starting the nested loop from 0-th index instead of 1 (as above) and going upto (arr.length - 1) instead of arr.length. And so the previous solution, I was comparing < if (arr[j] < arr[j - 1]) > and here I shall compare arr[j + 1] < arr[j] . And thats why I am running the loop upto (arr.length - 1) because inside I will take care of the element arr[j+1]
 // Learning JavaScript Data Structures and Algorithms-Loiane.pdf - Page - 225
@@ -81,7 +63,7 @@ bubbleSortBasicDescending = (arr) => {
   return arr;
 }
 
-console.log(bubbleSortBasicDescending(array1));
+// console.log(bubbleSortBasicDescending(array1));
 
 /* SOLUTION - 2 - A more optimal solution, by reducing some of the loop execution.
 So, here, I only do the loops and swaps for the cases when I find a mis-placed element, i.e. larger-element placed before smaller in an ascending sort
@@ -91,7 +73,8 @@ And each time there's something to swap the do-while loop will continue, and the
 */
 bubbleSortAscending_Improved = arr => {
 
-  let swapped;
+  // A flag that holds whether the swapping happened or not
+  let swapped = false;
 
   do {
     swapped = false;