docs(string): add algorithms for strings

Author: guilhermebkel

README.md

@@ -83,8 +83,31 @@ These ones use a key-value structure in which the key corresponds to an index on
 
 - [**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.
 
+## String
+
+String is necessary for almost all kind of communication, we deal with it in information processing, genomics, communication systems and programming systems. Being minded about that, we have the following algorithms:
+
+### String Sorting
+
+We have some sorting methods for string that take advantage of special properties of strings to develop sorts for string keys that are more efficient than the general-purpose sorts that we have seen above.
+
+- [**LSD String Sort:**](./algorithms/string/sorting/LSDStringSort.js) It is known as least-significant-digit string sort. It sorts an array of strings from left word letter to right using a key-indexed count array (so it means that it only sort fixed-length strings).
+
+- [**MSD String Sort:**](./algorithms/string/sorting/MSDStringSort.js) It is known as most-significant-digit string sort. We use key-indexed counting to sort the strings according to their first character, then, recursively sort the sub-arrays corresponding to each character. It is similar to LSD string sort, but, it can be done without a fixed-word length.
+
+- [**Three-way String Quicksort:**](./algorithms/string/sorting/ThreeWayStringQuickSort.js) It is an implementation of quicksort for strings, so it deals with partitioning the string array into sub-arrays while sorting it.
+
+### String Searching
+
+We can implement some search methods that can take benefits of using it into a string. Some of them are shown below:
+
+- [**Trie Symbol Table:**](./algorithms/string/searching/TrieSymbolTable.js) It is a basic symbol table that creates a search tree using the characters of the string keys that allow us to use the characters of the search key to guide the search.
+
+
 ## TODO
 
 - [TOPIC] Adding Analysis of Algorithms
 - [REFACTOR] Adding complexity order for all algorithms
 - [TOPIC] Graphs
+- [TOPIC/ALGORITHM] String -> String Sort -> LSD String Sort
+- [TOPIC/ALGORITHM] String -> String Sort -> MSD String Sort

algorithms/string/Char.js

@@ -0,0 +1,77 @@
+class Node {
+	#value
+	#next
+
+	constructor () {
+		this.#value = null
+		this.#next = []
+	}
+
+	get value() {
+		return this.#value
+	}
+
+	get next() {
+		return this.#next
+	}
+
+	set value(value) {
+		this.#value = value
+	}
+}
+
+class TrieSymbolTable {
+	#root
+
+	constructor () {
+		this.#root = null
+	}
+
+	#getNodeValue (node, key, d) {
+		if (!node) {
+			return null
+		}
+
+		if (d === key.length) {
+			return node
+		}
+
+		const letter = key.charAt(d)
+
+		return this.#getNodeValue(node.next[letter], key, d + 1)
+	}
+	
+	get (key) {
+		const node = this.#getNodeValue(this.#root, key, 0)
+
+		if (!node) {
+			return null
+		}
+
+		return node.value
+	}
+
+	#putNode (node, key, value, d) {
+		if (!node) {
+			node = new Node()
+		}
+
+		if (d === key.length) {
+			node.value = value
+
+			return node
+		}
+
+		const letter = key.charAt(d)
+
+		node.next[letter] = this.#putNode(node.next[letter], key, value, d + 1)
+
+		return node
+	}
+
+	put (key, value) {
+		this.#root = this.#putNode(this.#root, key, value, 0)
+	}
+}
+
+module.exports = TrieSymbolTable

algorithms/string/searching/TrieSymbolTable.js

@@ -0,0 +1,12 @@
+const assert = require("assert")
+const TrieSymbolTable = require("./TrieSymbolTable.js")
+
+const trieSymbolTable = new TrieSymbolTable()
+
+trieSymbolTable.put("Guilherme", "abc")
+trieSymbolTable.put("Mota", "eae")
+trieSymbolTable.put("teste", "oi")
+
+assert.deepEqual(trieSymbolTable.get("Guilherme"), "abc")
+assert.deepEqual(trieSymbolTable.get("NotExistentKey"), null)
+

algorithms/string/searching/TrieSymbolTable.test.js

@@ -0,0 +1,62 @@
+class LSDStringSort {
+	sort(wordArray, wordSize) {
+		const arraySize = wordArray.length
+
+		const R = 256
+
+		const auxiliaryArray = []
+		
+		for (let d = wordSize - 1; d >= 0; d--) {
+			const count = []
+
+			for (let i = 0; i < arraySize; i++) {
+				const word = wordArray[i]
+
+				if (!word) {
+					continue
+				}
+
+				const letter = word.charAt(d)
+
+				const countIndex = parseInt(letter, 16) + 1
+
+				if (!count[countIndex]) {
+					count[countIndex] = 0
+				}
+
+				count[countIndex]++
+
+			}
+
+			for (let r = 0; r < R; r++) {
+				count[r + 1] += count[r]
+			}
+
+			for (let i = 0; i < arraySize; i++) {
+				const word = wordArray[i]
+
+				if (!word) {
+					continue
+				}
+
+				const letter = word.charAt(d)
+
+				const countIndex = parseInt(letter, 16) + 1
+
+				if (!count[countIndex]) {
+					count[countIndex] = 0
+				}
+
+				auxiliaryArray[count[countIndex]] = wordArray[i]
+
+				count[countIndex]++
+			}
+
+			for (let i = 0; i < arraySize; i++) {
+				wordArray[i] = auxiliaryArray[i]
+			}
+		}
+	}
+}
+
+module.exports = LSDStringSort

algorithms/string/sorting/LSDStringSort.js

@@ -0,0 +1,30 @@
+const assert = require("assert")
+const LSDStringSort = require("./LSDStringSort.js")
+
+const lsdStringSort = new LSDStringSort()
+
+const unorderedValues = [
+	"4PGC938",
+	"2IYE230",
+	"3CIO720",
+	"1ICK750",
+	"1OHV845",
+	"4JZY524",
+	"1ICK750",
+	"3CIO720",
+	"1OHV845",
+	"1OHV845",
+	"2RLA629",
+	"2RLA629",
+	"3ATW723"
+]
+
+lsdStringSort.sort(unorderedValues, 7)
+
+console.log(unorderedValues)
+
+// assert.deepEqual(unorderedValues[0], 1)
+// assert.deepEqual(unorderedValues[1], 2)
+// assert.deepEqual(unorderedValues[2], 3)
+// assert.deepEqual(unorderedValues[3], 4)
+

algorithms/string/sorting/LSDStringSort.test.js

@@ -0,0 +1,22 @@
+const Char = require("../Char")
+const InsertionSort = require("../../sorting/elementary-sorts/InsertionSort")
+
+class MSDStringSort extends Char {
+	#radix
+	#M
+	#auxiliaryArray
+
+	constructor () {
+		this.#radix = 256
+		this.#M = 15
+		this.#auxiliaryArray = []
+	}
+
+	#sortBySubArrays (array, lowerIndex, higherIndex, d) {
+		if (higherIndex <= lowerIndex + this.#M) {
+			const insertionSort = new InsertionSort()
+		}
+	}
+}
+
+module.exports = MSDStringSort

algorithms/string/sorting/MSDStringSort.js

@@ -0,0 +1,46 @@
+const Sort = require("../../sorting/Sort")
+const Char = require("../Char")
+
+class ThreeWayStringQuickSort extends Char {
+	#sortHelper = new Sort()
+
+	sort(array = []) {
+		const arraySize = array.length
+
+		this.#sortBySubArrays(array, 0, arraySize - 1, 0)
+	}
+
+	#sortBySubArrays(array, lowerIndex, higherIndex, d) {
+		if (higherIndex <= lowerIndex) {
+			return
+		}
+
+		let lt = lowerIndex
+		let gt = higherIndex
+		let index = lowerIndex + 1
+
+		const value = this.charAt(array[lowerIndex], d)
+
+		while (index <= gt) {
+			const comparableValue = this.charAt(array[index], d)
+
+			if (comparableValue < value) {
+				this.#sortHelper.exchangeValues(array, lt++, index++)
+			} else if (comparableValue > value) {
+				this.#sortHelper.exchangeValues(array, index, gt--)
+			} else {
+				index++
+			}
+		}
+
+		this.#sortBySubArrays(array, lowerIndex, lt - 1, d)
+
+		if (value >= 0) {
+			this.#sortBySubArrays(array, lt, gt, d + 1)
+		}
+
+		this.#sortBySubArrays(array, gt + 1, higherIndex, d)
+	}
+}
+
+module.exports = ThreeWayStringQuickSort

algorithms/string/sorting/ThreeWayStringQuickSort.js

@@ -0,0 +1,21 @@
+const assert = require("assert")
+const ThreeWayStringQuickSort = require("./ThreeWayStringQuickSort.js")
+
+const threeWayStringQuickSort = new ThreeWayStringQuickSort()
+
+const unorderedValues = ["R", "B", "W", "W", "R", "W", "B", "R", "R", "W", "B", "R"]
+
+threeWayStringQuickSort.sort(unorderedValues)
+
+assert.deepEqual(unorderedValues[0], "B")
+assert.deepEqual(unorderedValues[1], "B")
+assert.deepEqual(unorderedValues[2], "B")
+assert.deepEqual(unorderedValues[3], "R")
+assert.deepEqual(unorderedValues[4], "R")
+assert.deepEqual(unorderedValues[5], "R")
+assert.deepEqual(unorderedValues[6], "R")
+assert.deepEqual(unorderedValues[7], "R")
+assert.deepEqual(unorderedValues[8], "W")
+assert.deepEqual(unorderedValues[9], "W")
+assert.deepEqual(unorderedValues[10], "W")
+assert.deepEqual(unorderedValues[11], "W")