bubble sort basic implemetation

Author: rohan-paul

Hash_Table/generic_hash_table_implementation.js

@@ -2,88 +2,79 @@ function Node(element) {
     this.element = element;
     this.next = null;
     this.previous = null;
- }
+   }
 
- function LList() {
+  // The only property stored in a linked list is a node to represent the head of the list and the head  node starts with its next property set to null.
+
+   function LList() {
     this.head = new Node("head");
     this.find = find;
     this.insert = insert;
     this.display = display;
     this.remove = remove;
-    this.findLast = findLast;
-    this.dispReverse = dispReverse;
- }
-
- function dispReverse() {
-    var currNode = this.head;
-    currNode = this.findLast();
-    while (!(currNode.previous == null)) {
-       console.log(currNode.element);
-       currNode = currNode.previous;
-    }
- }
-
- function findLast() {
-    var currNode = this.head;
-    while (!(currNode.next == null)) {
-       currNode = currNode.next;
-    }
-    return currNode;
- }
+   }
 
- function remove(item) {
+   function remove(item) {
     var currNode = this.find(item);
     if (!(currNode.next == null)) {
-        currNode.previous.next = currNode.next;
-        currNode.next.previous = currNode.previous;
-        currNode.next = null;
-        currNode.previous = null;
+      currNode.previous.next = currNode.next;
+      currNode.next.previous = currNode.previous;
+      currNode.next = null;
+      currNode.previous = null;
     }
- }
+   }
 
- // findPrevious is no longer needed
- /*function findPrevious(item) {
-    var currNode = this.head;
-    while (!(currNode.next == null) &&
-            (currNode.next.element != item)) {
-       currNode = currNode.next;
-    }
-    return currNode;
- }*/
-
- function display() {
+  // function to display the elements of a linked list. Starts by hooking into the linked list by assigning the head of the list to a new node. Then it loops through the linked list printing the the next.element, till the current node’s next property is set to null, i.e. the last node has been reached.
+   function display() {
     var currNode = this.head;
     while (!(currNode.next == null)) {
        console.log(currNode.next.element);
        currNode = currNode.next;
     }
- }
+   }
+
+  // A helper function to find a particular node.
+   function find(item) {
+    var currNode = this.head; //  create a new node and assign it as the head node.
+
+  // Keep looping through the linked list with  the next property, while the value of the current node’s element property is not equal to the data we are searching for. And on success, the function returns the node storing the data. If the data is not found, the function returns null.
 
- function find(item) {
-    var currNode = this.head;
     while (currNode.element != item) {
        currNode = currNode.next;
     }
     return currNode;
- }
+   }
 
- function insert(newElement, item) {
+
+  // function to insert a new node, after a particular node say node X, first find X using find(). Then set new node’s next property to the value of the next property of X . Then set X's next property to reference to the new node that I just inserted.
+
+   function insert(newElement, item) {
     var newNode = new Node(newElement);
     var current = this.find(item);
     newNode.next = current.next;
     newNode.previous = current;
     current.next = newNode;
- }
+   }
+
+
+   var cities = new LList();
+   cities.insert("Bill", "head");
+   cities.insert("Steve", "Bill");
+   cities.insert("Paul", "Steve");
+   cities.insert("Woz", "Paul");
+
+   cities.display();
+   cities.remove("Steve");
+   console.log("**After removal**");
+   cities.display();
 
+/* OUTPUT: -
 
- var cities = new LList();
- cities.insert("Conway", "head");
- cities.insert("Russellville", "Conway");
- cities.insert("Carlisle", "Russellville");
- cities.insert("Alma", "Carlisle");
- cities.display();
- console.log();
- cities.remove("Carlisle");
- cities.display();
- console.log();
- cities.dispReverse();
+  Bill
+  Steve
+  Paul
+  Woz
+  **After removal**
+  Bill
+  Paul
+  Woz */

Hash_Table/hashmap_interview_question.js

@@ -0,0 +1,83 @@
+/* https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/
+
+Given a linked list, remove the nth node from the end of list and return its head.
+
+For example,
+
+   Given linked list: 1->2->3->4->5, and n = 2.
+
+   After removing the second node from the end, the linked list becomes 1->2->3->5.
+Note: Given n will always be valid. Try to do this in one pass. */
+
+/*
+A> In order to remove a node from a linked list, we need to find the node that is just before the node we want to remove. Once we find that node, we change its next property to no longer reference the removed node. But, the previous node is modified to point to the node after the removed node. So the key line of code will be
+
+	prevNode.next = prevNode.next.next
+
+	We are just skipping over the node we want to remove and linking the “previous” node with the node just after the one we are removing.
+
+
+B> The nth node from the end will be (list.length - n + 1)-th node from the begining of the Linked List.
+
+	 For example:
+
+	 1-> 2 -> 3 -> 4 -> 5 -> 6 -> 7
+
+	 To return 2nd node from the end(n = 2), we need to return 6th (7 - 2 + 1) node from beginning which is node '6'.
+
+http://www.ideserve.co.in/learn/find-nth-node-from-the-end-of-linked-list
+
+C> So the problem could be simply reduced to another one : Remove the (L - n + 1)th node from the beginning in the list , where L is the list length.
+
+D> First we will add an auxiliary dummy or fake head node which in the below program I am naming as "currentNode", which points to the list head. The “dummy” node is used to simplify some corner cases such as a list with only one node, or removing the head of the list. The key step is we have to relink next pointer of the (L - n)th node to the (L - n + 2)th node and we are done.
+
+*/
+
+var removeNthFromEnd = function(head, n) {
+	var list = [],
+		currentNode = head;
+
+	while(currentNode.next !== null) {
+		list.push(currentNode);
+		currentNode = currentNode.next;
+	}
+	list.push(currentNode);
+
+// Now we have to deal with 3 cases about the initial position of the node-to-be-removed.
+
+/* Case-1 >> When the node-to-be-removed is somewhere in between the last and first nodes of the linked-list.
+
+ A) The link of the node before the removed node is redirected to point to the node the removed node is pointing to.
+
+  B) But now the total length of the list has been reduced by one after removal of the n-th node, so the The new n-th node from the end will be (list.length - n + 1 - 1 )-th node from the beginning of the Linked List i.e. (list.length -n )-th node.
+
+  C) And the node previous to the removed node will be ((list.length -n + 1) - 1 - 1)-th node, i.e. (list.length - n - 1)-th node.
+
+  D) So, now, I have to link the node before the removed node to be redirected to point to the node after the removed node, which will be (list.length -n + 1)-th node.
+
+  D) So I do, list[list.length - n - 1].next = list[list.length -n + 1]
+So, to remove the current element from the list, all we have to do is link previous.next with current.next . This way, the current element will be lost in the computer memory and will be available to be cleaned by the garbage collector.
+  */
+
+	if (list.length -n - 1 >= 0 && list.length -n + 1 < list.length) {
+		list[list.length - n - 1].next = list[list.length -n + 1];
+		return list[0];
+	}
+
+/* Case-2 >> If the node-to-be-removed was the first node of the Linked-list.
+That is, after removal the position of the previous-node to the removed-node will be negative.
+In this case, if the node-removed was the only node of the linked list then for the head of the list, return an empty array if list.length is <=1. ELSE,
+If the length is more than one, then return the index 1 element for the head. */
+	if(list.length - n - 1 < 0) {
+		return list.length <=1 ? [] : list[1]
+	}
+
+/* Case - 3 >> If the node-to-be-removed was the last node of the Linked-list.
+That is, after removal the previous node becomes the last node of the Linked-list, then just point its next-node to null.*/
+
+	if (list.length - n + 1 >= list.length) {
+		list[list.length - n - 1 ].next = null;
+		return list[0];
+	}
+
+}

Hash_Table/remove_duplicates_from_array_returning_only_unique_elements.js

@@ -0,0 +1,39 @@
+let arr = Array.from({length: 20}, () => Math.floor(Math.random() * 20))
+console.log(arr);
+
+// swap helper function
+swap = (arr, i, j) => {
+  let temp = arr[i];
+  arr[i] = arr[j];
+  arr[j] = temp;
+}
+
+// Necessary warning :) :) - this is a super basic implementation  to understand the principle behind bubble sort (going through all comparisons) but there's huge room for performance improvement on this.
+
+bubbleSortBasicAscending = (arr) => {
+
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = 1; j < arr.length; j++) {
+      if (arr[j] < arr[j - 1]) {
+        swap(arr, j, j-1);
+      }
+    }
+  }
+  return arr;
+}
+
+console.log(bubbleSortBasicAscending(arr));
+
+bubbleSortBasicDescending = (arr) => {
+
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = 1; j < arr.length; j++) {
+      if (arr[j] > arr[j - 1]) {
+        swap(arr, j, j-1);
+      }
+    }
+  }
+  return arr;
+}
+
+console.log(bubbleSortBasicDescending(arr));

Linked-List/generic-Linked-list.js

@@ -24,8 +24,8 @@
 
 	}
 
-	/* Two indices that start at the ends of the array being partitioned, then move toward each other, until they detect an inversion: a pair of elements, one greater than the pivot, one smaller, that are in the wrong order relative to each other. The inverted elements are then swapped. 
-	Here the numerical values of left and right is continually getting updated with each inner while loop. But only if the while loop condition gets satisfied. That is, when the while loop condition is unsatisfied, e.g. for the first inner while loop, when array[left] > array[pivot] which means we have found a misplaced pair. 
+	/* Two indices that start at the ends of the array being partitioned, then move toward each other, until they detect an inversion: a pair of elements, one greater than the pivot, one smaller, that are in the wrong order relative to each other. The inverted elements are then swapped.
+	Here the numerical values of left and right is continually getting updated with each inner while loop. But only if the while loop condition gets satisfied. That is, when the while loop condition is unsatisfied, e.g. for the first inner while loop, when array[left] > array[pivot] which means we have found a misplaced pair.
 
 	That is, although the left <= right (which is being made sure by the outer while loop) the actual elements are not sorted. Meaning a left side element is larger in value than the right side element. So, the code execution then jumps out of the inner while loop and goes right in to execute the swap function.
 	*/
@@ -53,20 +53,9 @@
 
 	/******************* Testing Hoare algorithm *********************/
 
-	function getRandomInt(min, max) {
-		return Math.floor(Math.random() * (max - min + 1)) + min;
-		// By adding 1, I am making the maximum inclusive ( the minimum is inclusive anyway). Because, the Math.random() function returns a floating-point, pseudo-random number in the range from 0 inclusive up to but not including 1
-	}
-
-	var arr = [];
-
-	for (var i = 0; i < 10; i++) { //initialize a random integer unsorted array
-		arr.push(getRandomInt(1, 100));
-	}
 
-	console.log("Unsorted array: ");
+	let arr = Array.from({length : 20}, () => Math.floor(Math.random() * 20));
 	console.log(arr); //printing unsorted array
 
 	arr = quicksortHoare(arr, 0, arr.length - 1);
-	console.log("Sorted array: ");
 	console.log(arr);

Linked-List/leetcode-remove-nt--list.js

@@ -43,18 +43,32 @@ function partitionLomuto(array, left, right) {
 
 function getRandomInt(min, max) {
 	return Math.floor(Math.random() * (max - min + 1)) + min;
-	// By adding 1, I am making the maximum inclusive ( the minimum is inclusive anyway). Because, the Math.random() function returns a floating-point, pseudo-random number in the range from 0 inclusive up to but not including 1
 }
 
-var arr = [];
-
-for (var i = 0; i < 10; i++) { //initialize a random integer unsorted array
-	arr.push(getRandomInt(1, 100));
-}
-
-console.log("Unsorted array: ");
+let arr = Array.from({length : 20}, () => Math.floor(Math.random() * 20));
 console.log(arr); //printing unsorted array
 
 arr = quicksortLomuto(arr, 0, arr.length - 1);
-console.log("Sorted array: ");
-console.log(arr);
+console.log(arr);
+
+
+/* Explanation of < Math.floor(Math.random() * (max - min + 1)) + min >
+
+By adding 1, I am making the maximum inclusive ( the minimum is inclusive anyway). Because, the Math.random() function returns a floating-point, pseudo-random number in the range from 0 inclusive up to but not including 1. the formula can generate the correct amount of numbers but they always start at 0 because the range from Math.random starts from 0. https://teamtreehouse.com/community/need-an-explanation
+
+Math.random() returns a number from 0 to 1, not including one. Flooring this number will always result in a zero.
+
+If you multiply this float by the max prior to flooring, you will get numbers all the way up to the maximum, including those below the minimum, but not the maximum itself. Say you have 10 as the maximum, you cannot get a 10.
+
+In order to rule out those below the minimum, you subtract the minimum from the maximum. In order to include the maximum, you add one. This is all multiplied by the random floating point number between 0 and 1.
+
+At that point, we aren't quite there. You will be receiving numbers based on the range between the minimum and maximum as explained above. Adding the minimum back in, post-randomizing, ensure that you have numbers that are between the minimum and the maximum.
+
+TLDR: The range of numbers (i.e. the number of numbers between min and max) is defined by those within the floor method's parentheses. The minimum added at the end ensures these numbers are between the desired minimum and maximum.
+
+By subtracting the minimum number from the maximum, you define the range. Say you have minimum of 5 and a maximum of 20, you will get the range of 15. There are 15 possible numbers that you could select at random between these bounds.
+
+Paul-Note - So, if I dont add Min of 5, the formulae will give me all the random numbers between 0 and 15. But I want between 5 and 20. So thats why I add back the min.
+
+Another great visual explanation at - https://stackoverflow.com/questions/1527803/generating-random-whole-numbers-in-javascript-in-a-specific-range
+ */

Sorting/bubble-sort-basic.js

@@ -1,15 +1,15 @@
-// sorting the below array with quick sorting
-
 /*The algorithm for Quicksort is:
 1. Pick a pivot element that divides the list into two sublists.
 
 2. Reorder the list so that all elements less than the pivot element are placed before
 the pivot and all elements greater than the pivot are placed after it.
 
 3. Repeat steps 1 and 2 on both the list with smaller elements and the list of larger
-elements.*/
+elements.
+
+4. Quicksort is a divide and conquer algorithm in the style of merge sort. The basic idea is to find a “pivot” item in the array to compare all other items against, then shift items such that all of the items before the pivot are less than the pivot value and all the items after the pivot are greater than the pivot value. After that, recursively perform the same operation on the items before and after the pivot. */
 
-// basic implementation, where pivot is the first element, without usuing swap function and partition function.
+// basic recursive implementation, where pivot is the first element, without using swap function and partition function.
 
 function quickSortBasic(array) {
   if(array.length < 2) {
@@ -27,29 +27,21 @@ function quickSortBasic(array) {
       lesserArray.push(array[i]);
     }
   }
-
+// Now, recursively perform the same operation on the items before and after the pivot.
   return quickSortBasic(lesserArray).concat(pivot, quickSortBasic(greaterArray));
 }
 
-
 /******************* Testing Quick sort algorithm *********************/
 
 // Returns a random integer between min (inclusive) and max (inclusive). Using Math.round() will give a non-uniform distribution, which we dont want in this case.
 
 function getRandomInt(min, max) {
   return Math.floor(Math.random() * (max - min + 1)) + min;
-  // By adding 1, I am making the maximum inclusive ( the minimum is inclusive anyway). Because, the Math.random() function returns a floating-point, pseudo-random number in the range from 0 inclusive up to but not including 1
 }
 
-var arr = [];
-
-for (var i = 0; i < 10; i++) { //initialize a random integer unsorted array
-  arr.push(getRandomInt(1, 100));
-}
+let arr = Array.from({length : 20}, () => Math.floor(Math.random() * 20));
 
-console.log("Unsorted array: ");
 console.log(arr); //printing unsorted array
 
 arr = quickSortBasic(arr, 0, arr.length - 1);
-console.log("Sorted array: ");
-console.log(arr);
+console.log(arr);