chore(readme): add readme

Author: guilhermebkel

README.md

@@ -15,6 +15,8 @@ These are the most famous data structures used in lot of applications to help so
 
 - [**Linked List:**](./data-structures/lists/LinkedList.js) A linked list is a recursive data structure that is either empty or a reference to a node having a generic item and a reference to a linked list (a node is any kind of data that refers another node recursively).
 
+- [**Binary Heap:**](./data-structures/binary-tree/BinaryHeap.js) A binary heap is a heap constructed with help of a binary tree structure, which can maintain all the values sorted during its insert and remove actions.
+
 ## Sorting
 
 Below you can see some of the famous methods of sorting values.
@@ -53,24 +55,30 @@ With help of binary tree heap data structure used to build the heap priority que
 
 - [**Heapsort:**](./algorithms/sorting/heap/HeapSort.js) The heapsort consists into two actions: first we reorganize the initial array into a heap and after we sortdown, that is when we pull the items out of the heap in decreasing order to build the sorted result.
 
-## TODO
+## Searching
 
-### 1. Finishing the following topics
+Below you can see some of the structures focused on searching. Usually these structures have the pattern or associating a value with a key. That key is used later to get the item you have inserted (what means that we must make sure that the key we create is unique).
 
-Data Structures -> Binary Tree
+- [**Sequential Search:**](./algorithms/searching/symbol-table/SequentialSearch.js) It is a kind of Symbol Table, which we use a linked list structure to keep all items ordered and so to sequentially search them.
 
-Analysis of Algorithms
+- [**Binary Search:**](./algorithms/searching/symbol-table/BinarySearch.js) It is a kind of Symbol Table, that during searches, we divide the keys in two parts and so, we determine if we will search on the right part or the left one, instead of searching sequentially all the array keys.
+
+- [**Binary Search Tree:**](./algorithms/searching/symbol-table/BinarySearchTree.js) It is a symbol table that uses the binary tree data structure to handle all searching process. So, each node in the tree has a key that is larger than the keys in all node's left subtree and smaller than the keys in all nodes in that node's right subtree.
+
+- [**Red Black Binary Search Tree:**](./algorithms/searching/balanced-search-tree/RedBlackBinarySearchTree.js) It is a binary search tree (actually the one with 2-3 nodes) with an optimization that helps keeping the path to a value almost the same for all entries. So, we can call it to be a balanced search tree method, since it is able to search values with same distance between the root of the tree to any value you want.
 
-Sorting -> Heapsort -> Sortdown
+- [**Separate Chaining Hash:**](./algorithms/searching/hash-table/SeparateChainingHash.js) It is a hash table that converts the key into indexes to store the data inside an array of sequential searches.
 
-Sorting -> Applications -> Pointer sorting
+- [**Linear Probing Hash:**](./algorithms/searching/hash-table/LinearProbingHash.js) It is a hash table which we store keys and values in separated arrays in order to get an easy search match later.
 
-Sorting -> Applications -> Alternate orderings
+## TODO
+
+### 1. Finishing the following topics
 
-Sorting -> Priority Queues -> Heap Priority Queue
+Data Structures -> Binary Tree
+
+Analysis of Algorithms
 
 ### 2. Adding the following information
 
 Adding complexity order for all algorithms
-
-Finishing Heapsort algorithm implementation

algorithms/searching/Search.js

@@ -0,0 +1,25 @@
+class Search {
+	compareValues(firstKey, secondKey) {
+		if (!firstKey || !secondKey) {
+			return null
+		}
+
+		const comparison = firstKey.localeCompare(secondKey)
+
+		return comparison
+	}
+
+	generateHash(key) {
+		let hash = 0
+
+		for (let i = 0; i > key.length; i++) {
+			const charCode = this.charCodeAt(i)
+      hash  = ((hash << 5) - hash) + charCode
+      hash |= 0
+		}
+
+		return hash
+	}
+}
+
+module.exports = Search

algorithms/searching/symbol-table/BinarySearchTree.js

@@ -0,0 +1,119 @@
+const Search = require("../Search")
+
+class Node {
+	#key
+	#value
+	#left
+	#right
+	#nodesCount
+
+	constructor(key, value, nodesCount) {
+		this.#key = key
+		this.#value = value
+		this.#nodesCount = nodesCount
+	}
+
+	get right() {
+		return this.#right
+	}
+
+	get left() {
+		return this.#left
+	}
+
+	get value() {
+		return this.#value
+	}
+
+	get nodesCount() {
+		return this.#nodesCount
+	}
+
+	get key() {
+		return this.#key
+	}
+
+	set value(value) {
+		this.#value = value
+	}
+
+	set right(right) {
+		this.#right = right
+	}
+
+	set left(left) {
+		this.#left = left
+	}
+
+	set nodesCount(nodesCount) {
+		this.#nodesCount = nodesCount
+	}
+}
+
+class BinarySearchTree extends Search {
+	#root
+
+	constructor() {
+		super()
+
+		this.#root = null
+	}
+
+	size() {
+		return this.nodeSize(this.#root)
+	}
+
+	nodeSize(node) {
+		if (!node) {
+			return 0
+		} else {
+			return node.nodesCount
+		}
+	}
+
+	get (key) {
+		return this.getNodeValue(this.#root, key)
+	}
+
+	getNodeValue (node, key) {
+		if (!node) {
+			return null
+		}
+
+		const comparison = this.compareValues(key, node.key)
+
+		if (comparison < 0) {
+			return this.getNodeValue(node.left, key)
+		} else if (comparison > 0) {
+			return this.getNodeValue(node.right, key)
+		} else {
+			return node.value
+		}
+	}
+
+	put (key, value) {
+		this.#root = this.putNodeValue(this.#root, key, value)
+	}
+
+	putNodeValue (node, key, value) {
+		if (!node) {
+			return new Node(key, value, 1)
+		}
+
+		const comparison = this.compareValues(key, node.key)
+
+		if (comparison < 0) {
+			node.left = this.putNodeValue(node.left, key, value)
+		} else if (comparison > 0) {
+			node.right = this.putNodeValue(node.right, key, value)
+		} else {
+			node.value = value
+		}
+
+		node.nodesCount = this.nodeSize(node.left) + this.nodeSize(node.right) + 1
+		
+		return node
+	}
+}
+
+module.exports = BinarySearchTree

algorithms/searching/symbol-table/BinarySearchTree.test.js

@@ -0,0 +1,12 @@
+const assert = require("assert")
+const BinarySearchTree = require("./BinarySearchTree.js")
+
+const binarySearchTree = new BinarySearchTree()
+
+binarySearchTree.put("Guilherme", 123)
+binarySearchTree.put("Mota", 431)
+binarySearchTree.put("teste", 0)
+
+assert.deepEqual(binarySearchTree.get("Guilherme"), 123)
+assert.deepEqual(binarySearchTree.get("NotExistentKey"), null)
+

algorithms/searching/symbol-table/SequentialSearch.js

@@ -1,6 +1,33 @@
-const { Node } = require("../../../data-structures/DataStructures")
 const Search = require("../Search")
 
+class Node {
+	#key
+	#value
+	#next
+
+	constructor(key, value, next) {
+		this.#key = key
+		this.#value = value
+		this.#next = next
+	}
+
+	get next() {
+		return this.#next
+	}
+
+	get value() {
+		return this.#value
+	}
+
+	get key() {
+		return this.#key
+	}
+
+	set value(value) {
+		this.#value = value
+	}
+}
+
 class SequentialSearch extends Search {
 	#first
 
@@ -11,21 +38,21 @@ class SequentialSearch extends Search {
 	}
 
 	get (key) {
-		let item = null
+		let value = null
 
 		for (let node = this.#first; node != null; node = node.next) {
 			const nodeKey = node.key
 
 			const areKeysEqual = this.compareValues(key, nodeKey) === 0
 
 			if (areKeysEqual) {
-				item = node.item
+				value = node.value
 
 				break
 			}
 		}
 
-		return item
+		return value
 	}
 
 	put (key, value) {
@@ -35,18 +62,15 @@ class SequentialSearch extends Search {
 			const areKeysEqual = this.compareValues(key, nodeKey) === 0
 
 			if (areKeysEqual) {
-				node.item = value
+				node.value = value
 
 				return
 			}
 		}
 
 		const next = this.#first
 
-		this.#first = new Node()
-		this.#first.item = value
-		this.#first.key = key
-		this.#first.next = next
+		this.#first = new Node(key, value, next)
 	}
 }
 

algorithms/sorting/Sort.js

@@ -85,22 +85,33 @@ class Sort {
 	}
 
 	sinkBinaryTreeNodes(array = [], nodePosition, nodesCount) {
-		let currentScanIndex = nodePosition
+		let largestIndex = nodePosition
+		let leftIndex = nodePosition * 2 + 1
+		let rightIndex = leftIndex + 1
+	
+		if (leftIndex < nodesCount && this.isFirstValueLowerThanSecondValue(array[largestIndex], array[leftIndex])) {
+			largestIndex = leftIndex
+		}
 
-		while (2 * currentScanIndex <= nodesCount) {
-			let topScanIndex = 2 * currentScanIndex
+		if (rightIndex < nodesCount && this.isFirstValueLowerThanSecondValue(array[largestIndex], array[rightIndex])) {
+			largestIndex = rightIndex
+		}
 
-			if (topScanIndex < nodesCount && this.isFirstValueLowerThanSecondValue(topScanIndex, topScanIndex + 1)) {
-				topScanIndex++
-			}
+		if (largestIndex !== nodePosition) {
+			this.exchangeValues(array, nodePosition, largestIndex)
 
-			if (!this.isFirstValueLowerThanSecondValue(currentScanIndex, topScanIndex)) {
-				break
-			}
+			this.sinkBinaryTreeNodes(array, nodesCount, largestIndex)
+		}
+	}
+
+	swimBinaryTreeNodes(array = [], nodesCount) {
+		let currentIndex = nodesCount
 
-			this.exchangeValues(array, currentScanIndex, topScanIndex)
+		const middleIndex = Math.floor(currentIndex / 2)
 
-			currentScanIndex = topScanIndex
+		while (currentIndex > 1 && this.isFirstValueLowerThanSecondValue(middleIndex, currentIndex)){
+			this.exchangeValues(array, middleIndex, currentIndex)
+			currentIndex = middleIndex
 		}
 	}
 }

algorithms/sorting/heap/HeapSort.test.js

@@ -6,7 +6,6 @@ const heapSort = new HeapSort()
 const unorderedValues = [1, 4, 3, 2]
 
 heapSort.sort(unorderedValues)
-console.log(unorderedValues)
 
 assert.deepEqual(unorderedValues[0], 1)
 assert.deepEqual(unorderedValues[1], 2)

data-structures/bags/Bag.test.js

@@ -1,4 +1,4 @@
-const assert = require("../../sorting/elementary-sorts/node_modules/assert")
+const assert = require("assert")
 const Bag = require("./Bag.js")
 
 const bag = new Bag()

data-structures/lists/LinkedList.js

@@ -2,9 +2,9 @@ class Node {
 	#item
 	#next
 
-	constructor(item) {
-		this.#item = null
-		this.#next = null
+	constructor(item, next) {
+		this.#item = item
+		this.#next = next
 	}
 
 	get next() {
@@ -14,14 +14,6 @@ class Node {
 	get item() {
 		return this.#item
 	}
-
-	set next(node) {
-		this.#next = node
-	}
-
-	set item(item) {
-		this.#item = item
-	}
 }
 
 class LinkedList {
@@ -34,10 +26,7 @@ class LinkedList {
 	}
 
 	push(item) {
-		const node = new Node()
-
-		node.item = item
-		node.next = this.#head
+		const node = new Node(item, this.#head)
 
 		this.#head = node
 

data-structures/lists/LinkedList.test.js

@@ -1,4 +1,4 @@
-const assert = require("../../sorting/elementary-sorts/node_modules/assert")
+const assert = require("assert")
 const LinkedList = require("./LinkedList.js")
 
 const linkedList = new LinkedList()