mirror of
https://github.com/TheAlgorithms/JavaScript.git
synced 2025-07-04 07:29:47 +08:00
style: Fixed most styles (according to standardjs)
This commit is contained in:
@ -1,5 +1,5 @@
|
||||
function decimalToBinary (num) {
|
||||
var bin = []
|
||||
const bin = []
|
||||
while (num > 0) {
|
||||
bin.unshift(num % 2)
|
||||
num >>= 1 // basically /= 2 without remainder if any
|
||||
|
@ -1,12 +1,12 @@
|
||||
function hexStringToRGB (hexString) {
|
||||
var r = hexString.substring(0, 2)
|
||||
var g = hexString.substring(2, 4)
|
||||
var b = hexString.substring(4, 6)
|
||||
let r = hexString.substring(0, 2)
|
||||
let g = hexString.substring(2, 4)
|
||||
let b = hexString.substring(4, 6)
|
||||
|
||||
r = parseInt(r, 16)
|
||||
g = parseInt(g, 16)
|
||||
b = parseInt(b, 16)
|
||||
var obj = { r, g, b }
|
||||
const obj = { r, g, b }
|
||||
|
||||
return obj
|
||||
}
|
||||
|
@ -1,4 +1,4 @@
|
||||
var values = {
|
||||
const values = {
|
||||
I: 1,
|
||||
V: 5,
|
||||
X: 10,
|
||||
|
@ -10,7 +10,7 @@
|
||||
|
||||
// class LinkedList and constructor
|
||||
// Creates a LinkedList
|
||||
var LinkedList = (function () {
|
||||
const LinkedList = (function () {
|
||||
function LinkedList () {
|
||||
// Length of linklist and head is null at start
|
||||
this.length = 0
|
||||
@ -19,7 +19,7 @@ var LinkedList = (function () {
|
||||
|
||||
// class node (constructor)
|
||||
// Creating Node with element's value
|
||||
var Node = (function () {
|
||||
const Node = (function () {
|
||||
function Node (element) {
|
||||
this.element = element
|
||||
this.next = null
|
||||
@ -39,12 +39,12 @@ var LinkedList = (function () {
|
||||
|
||||
// Creates a node and adds it to linklist
|
||||
LinkedList.prototype.add = function (element) {
|
||||
var node = new Node(element)
|
||||
const node = new Node(element)
|
||||
// Check if its the first element
|
||||
if (this.head === null) {
|
||||
this.head = node
|
||||
} else {
|
||||
var currentNode = this.head
|
||||
let currentNode = this.head
|
||||
|
||||
// Loop till there is node present in the list
|
||||
while (currentNode.next) {
|
||||
@ -60,8 +60,8 @@ var LinkedList = (function () {
|
||||
|
||||
// Removes the node with the value as param
|
||||
LinkedList.prototype.remove = function (element) {
|
||||
var currentNode = this.head
|
||||
var previousNode
|
||||
let currentNode = this.head
|
||||
let previousNode
|
||||
|
||||
// Check if the head node is the element to remove
|
||||
if (currentNode.element === element) {
|
||||
@ -88,8 +88,8 @@ var LinkedList = (function () {
|
||||
|
||||
// Returns the index of the element passed as param otherwise -1
|
||||
LinkedList.prototype.indexOf = function (element) {
|
||||
var currentNode = this.head
|
||||
var index = -1
|
||||
let currentNode = this.head
|
||||
let index = -1
|
||||
|
||||
while (currentNode) {
|
||||
index++
|
||||
@ -106,8 +106,8 @@ var LinkedList = (function () {
|
||||
|
||||
// Returns the element at an index
|
||||
LinkedList.prototype.elementAt = function (index) {
|
||||
var currentNode = this.head
|
||||
var count = 0
|
||||
let currentNode = this.head
|
||||
let count = 0
|
||||
while (count < index) {
|
||||
count++
|
||||
currentNode = currentNode.next
|
||||
@ -118,11 +118,11 @@ var LinkedList = (function () {
|
||||
// Adds the element at specified index
|
||||
LinkedList.prototype.addAt = function (index, element) {
|
||||
index--
|
||||
var node = new Node(element)
|
||||
const node = new Node(element)
|
||||
|
||||
var currentNode = this.head
|
||||
var previousNode
|
||||
var currentIndex = 0
|
||||
let currentNode = this.head
|
||||
let previousNode
|
||||
let currentIndex = 0
|
||||
|
||||
// Check if index is out of bounds of list
|
||||
if (index > this.length) {
|
||||
@ -153,9 +153,9 @@ var LinkedList = (function () {
|
||||
// Removes the node at specified index
|
||||
LinkedList.prototype.removeAt = function (index) {
|
||||
index--
|
||||
var currentNode = this.head
|
||||
var previousNode
|
||||
var currentIndex = 0
|
||||
let currentNode = this.head
|
||||
let previousNode
|
||||
let currentIndex = 0
|
||||
|
||||
// Check if index is present in list
|
||||
if (index < 0 || index >= this.length) {
|
||||
@ -181,8 +181,8 @@ var LinkedList = (function () {
|
||||
|
||||
// Function to view the LinkedList
|
||||
LinkedList.prototype.view = function () {
|
||||
var currentNode = this.head
|
||||
var count = 0
|
||||
let currentNode = this.head
|
||||
let count = 0
|
||||
while (count < this.length) {
|
||||
count++
|
||||
console.log(currentNode.element)
|
||||
@ -195,7 +195,7 @@ var LinkedList = (function () {
|
||||
}())
|
||||
|
||||
// Implementation of LinkedList
|
||||
var linklist = new LinkedList()
|
||||
const linklist = new LinkedList()
|
||||
linklist.add(2)
|
||||
linklist.add(5)
|
||||
linklist.add(8)
|
||||
|
@ -8,7 +8,7 @@
|
||||
// Functions: push, pop, peek, view, length
|
||||
|
||||
// Creates a stack constructor
|
||||
var Stack = (function () {
|
||||
const Stack = (function () {
|
||||
function Stack () {
|
||||
// The top of the Stack
|
||||
this.top = 0
|
||||
@ -29,7 +29,7 @@ var Stack = (function () {
|
||||
}
|
||||
|
||||
this.top--
|
||||
var result = this.stack[this.top]
|
||||
const result = this.stack[this.top]
|
||||
this.stack = this.stack.splice(0, this.top)
|
||||
return result
|
||||
}
|
||||
@ -46,14 +46,14 @@ var Stack = (function () {
|
||||
|
||||
// To see all the elements in the stack
|
||||
Stack.prototype.view = function () {
|
||||
for (var i = 0; i < this.top; i++) { console.log(this.stack[i]) }
|
||||
for (let i = 0; i < this.top; i++) { console.log(this.stack[i]) }
|
||||
}
|
||||
|
||||
return Stack
|
||||
}())
|
||||
|
||||
// Implementation
|
||||
var myStack = new Stack()
|
||||
const myStack = new Stack()
|
||||
|
||||
myStack.push(1)
|
||||
myStack.push(5)
|
||||
|
@ -11,7 +11,7 @@
|
||||
*/
|
||||
|
||||
// class Node
|
||||
var Node = (function () {
|
||||
const Node = (function () {
|
||||
// Node in the tree
|
||||
function Node (val) {
|
||||
this.value = val
|
||||
@ -67,7 +67,7 @@ var Node = (function () {
|
||||
}())
|
||||
|
||||
// class Tree
|
||||
var Tree = (function () {
|
||||
const Tree = (function () {
|
||||
function Tree () {
|
||||
// Just store the root
|
||||
this.root = null
|
||||
@ -103,7 +103,7 @@ var Tree = (function () {
|
||||
}())
|
||||
|
||||
// Implementation of BST
|
||||
var bst = new Tree()
|
||||
const bst = new Tree()
|
||||
bst.addValue(6)
|
||||
bst.addValue(3)
|
||||
bst.addValue(9)
|
||||
|
@ -1,4 +1,4 @@
|
||||
var TrieNode = function TrieNode (key, parent) {
|
||||
const TrieNode = function TrieNode (key, parent) {
|
||||
this.key = key
|
||||
this.count = 0
|
||||
this.children = Object.create(null)
|
||||
@ -20,7 +20,7 @@ Trie.findAllWords = function (root, word, output) {
|
||||
if (root.count > 0) {
|
||||
if (typeof output === 'object') { output.push({ word: word, count: root.count }) }
|
||||
}
|
||||
var key
|
||||
let key
|
||||
for (key in root.children) {
|
||||
word += key
|
||||
this.findAllWords(root.children[key], word, output)
|
||||
@ -34,9 +34,9 @@ Trie.prototype.insert = function (word) {
|
||||
this.root.count += 1
|
||||
return
|
||||
}
|
||||
var node = this.root
|
||||
var len = word.length
|
||||
var i
|
||||
let node = this.root
|
||||
const len = word.length
|
||||
let i
|
||||
for (i = 0; i < len; i++) {
|
||||
if (node.children[word.charAt(i)] === undefined) { node.children[word.charAt(i)] = new TrieNode(word.charAt(i), node) }
|
||||
node = node.children[word.charAt(i)]
|
||||
@ -46,9 +46,9 @@ Trie.prototype.insert = function (word) {
|
||||
|
||||
Trie.prototype.findPrefix = function (word) {
|
||||
if (typeof word !== 'string') return null
|
||||
var node = this.root
|
||||
var len = word.length
|
||||
var i
|
||||
let node = this.root
|
||||
const len = word.length
|
||||
let i
|
||||
// After end of this loop node will be at desired prefix
|
||||
for (i = 0; i < len; i++) {
|
||||
if (node.children[word.charAt(i)] === undefined) return null // No such prefix exists
|
||||
@ -69,9 +69,9 @@ Trie.prototype.remove = function (word, count) {
|
||||
return
|
||||
}
|
||||
|
||||
var child = this.root
|
||||
var len = word.length
|
||||
var i, key
|
||||
let child = this.root
|
||||
const len = word.length
|
||||
let i, key
|
||||
// child: node which is to be deleted
|
||||
for (i = 0; i < len; i++) {
|
||||
key = word.charAt(i)
|
||||
@ -93,9 +93,9 @@ Trie.prototype.remove = function (word, count) {
|
||||
}
|
||||
|
||||
Trie.prototype.findAllWords = function (prefix) {
|
||||
var output = []
|
||||
const output = []
|
||||
// find the node with provided prefix
|
||||
var node = this.findPrefix(prefix)
|
||||
const node = this.findPrefix(prefix)
|
||||
// No such prefix exists
|
||||
if (node === null) return output
|
||||
Trie.findAllWords(node, prefix, output)
|
||||
@ -104,7 +104,7 @@ Trie.prototype.findAllWords = function (prefix) {
|
||||
|
||||
Trie.prototype.contains = function (word) {
|
||||
// find the node with given prefix
|
||||
var node = this.findPrefix(word)
|
||||
const node = this.findPrefix(word)
|
||||
// No such word exists
|
||||
if (node === null || node.count === 0) return false
|
||||
return true
|
||||
@ -112,7 +112,7 @@ Trie.prototype.contains = function (word) {
|
||||
|
||||
Trie.prototype.findOccurences = function (word) {
|
||||
// find the node with given prefix
|
||||
var node = this.findPrefix(word)
|
||||
const node = this.findPrefix(word)
|
||||
// No such word exists
|
||||
if (node === null) return 0
|
||||
return node.count
|
||||
@ -120,7 +120,7 @@ Trie.prototype.findOccurences = function (word) {
|
||||
|
||||
// To test
|
||||
(function demo () {
|
||||
var x = new Trie()
|
||||
const x = new Trie()
|
||||
x.insert('sheldon')
|
||||
x.insert('hello')
|
||||
x.insert('anyword')
|
||||
|
@ -5,13 +5,13 @@
|
||||
The namespace LinearAlgebra contains useful classes and functions for dealing with
|
||||
linear algebra under JavaScript.
|
||||
*/
|
||||
var LinearAlgebra;
|
||||
let LinearAlgebra;
|
||||
(function (LinearAlgebra) {
|
||||
/*
|
||||
class: Vector
|
||||
This class represents a vector of arbitrary size and operations on it.
|
||||
*/
|
||||
var Vector = /** @class */ (function () {
|
||||
const Vector = /** @class */ (function () {
|
||||
// constructor
|
||||
function Vector (N, comps) {
|
||||
if (comps === undefined) {
|
||||
@ -19,7 +19,7 @@ var LinearAlgebra;
|
||||
}
|
||||
this.components = new Array(N)
|
||||
if (comps.length === 0) {
|
||||
for (var i = 0; i < N; i++) {
|
||||
for (let i = 0; i < N; i++) {
|
||||
this.components[i] = 0.0
|
||||
}
|
||||
} else {
|
||||
@ -37,8 +37,8 @@ var LinearAlgebra;
|
||||
}
|
||||
// computes the eulidean length.
|
||||
Vector.prototype.eulideanLength = function () {
|
||||
var sum = 0
|
||||
for (var i = 0; i < this.components.length; i++) {
|
||||
let sum = 0
|
||||
for (let i = 0; i < this.components.length; i++) {
|
||||
sum += this.components[i] * this.components[i]
|
||||
}
|
||||
return Math.sqrt(sum)
|
||||
@ -59,9 +59,9 @@ var LinearAlgebra;
|
||||
// vector addition
|
||||
Vector.prototype.add = function (other) {
|
||||
if (this.size() === other.size()) {
|
||||
var SIZE = this.size()
|
||||
var ans = new Vector(SIZE)
|
||||
for (var i = 0; i < SIZE; i++) {
|
||||
const SIZE = this.size()
|
||||
const ans = new Vector(SIZE)
|
||||
for (let i = 0; i < SIZE; i++) {
|
||||
ans.changeComponent(i, (this.components[i] + other.component(i)))
|
||||
}
|
||||
return ans
|
||||
@ -72,9 +72,9 @@ var LinearAlgebra;
|
||||
// vector subtraction
|
||||
Vector.prototype.sub = function (other) {
|
||||
if (this.size() === other.size()) {
|
||||
var SIZE = this.size()
|
||||
var ans = new Vector(SIZE)
|
||||
for (var i = 0; i < SIZE; i++) {
|
||||
const SIZE = this.size()
|
||||
const ans = new Vector(SIZE)
|
||||
for (let i = 0; i < SIZE; i++) {
|
||||
ans.changeComponent(i, (this.components[i] - other.component(i)))
|
||||
}
|
||||
return ans
|
||||
@ -84,10 +84,10 @@ var LinearAlgebra;
|
||||
}
|
||||
// dot-product
|
||||
Vector.prototype.dot = function (other) {
|
||||
var sum = 0
|
||||
let sum = 0
|
||||
if (other.size() === this.size()) {
|
||||
var SIZE = other.size()
|
||||
for (var i = 0; i < SIZE; i++) {
|
||||
const SIZE = other.size()
|
||||
for (let i = 0; i < SIZE; i++) {
|
||||
sum += this.components[i] * other.component(i)
|
||||
}
|
||||
return sum
|
||||
@ -97,18 +97,18 @@ var LinearAlgebra;
|
||||
}
|
||||
// scalar multiplication
|
||||
Vector.prototype.scalar = function (s) {
|
||||
var SIZE = this.size()
|
||||
var ans = new Vector(SIZE)
|
||||
for (var i = 0; i < SIZE; i++) {
|
||||
const SIZE = this.size()
|
||||
const ans = new Vector(SIZE)
|
||||
for (let i = 0; i < SIZE; i++) {
|
||||
ans.changeComponent(i, (this.components[i] * s))
|
||||
}
|
||||
return ans
|
||||
}
|
||||
// returns a string representation of this vector.
|
||||
Vector.prototype.toString = function () {
|
||||
var ans = '('
|
||||
var SIZE = this.components.length
|
||||
for (var i = 0; i < SIZE; i++) {
|
||||
let ans = '('
|
||||
const SIZE = this.components.length
|
||||
for (let i = 0; i < SIZE; i++) {
|
||||
if (i < SIZE - 1) {
|
||||
ans += this.components[i] + ','
|
||||
} else {
|
||||
@ -121,7 +121,7 @@ var LinearAlgebra;
|
||||
// the One is on position 'pos'
|
||||
Vector.prototype.createUnitBasis = function (pos) {
|
||||
if (pos >= 0 && pos < this.components.length) {
|
||||
for (var i = 0; i < this.components.length; i++) {
|
||||
for (let i = 0; i < this.components.length; i++) {
|
||||
if (i === pos) {
|
||||
this.components[i] = 1.0
|
||||
} else {
|
||||
@ -135,20 +135,20 @@ var LinearAlgebra;
|
||||
}
|
||||
// normalizes this vector and returns it.
|
||||
Vector.prototype.norm = function () {
|
||||
var SIZE = this.size()
|
||||
var quotient = 1.0 / this.eulideanLength()
|
||||
for (var i = 0; i < SIZE; i++) {
|
||||
const SIZE = this.size()
|
||||
const quotient = 1.0 / this.eulideanLength()
|
||||
for (let i = 0; i < SIZE; i++) {
|
||||
this.components[i] = this.components[i] * quotient
|
||||
}
|
||||
return this
|
||||
}
|
||||
// returns true if the vectors are equal otherwise false.
|
||||
Vector.prototype.equal = function (other) {
|
||||
var ans = true
|
||||
var SIZE = this.size()
|
||||
var EPSILON = 0.001
|
||||
let ans = true
|
||||
const SIZE = this.size()
|
||||
const EPSILON = 0.001
|
||||
if (SIZE === other.size()) {
|
||||
for (var i = 0; i < SIZE; i++) {
|
||||
for (let i = 0; i < SIZE; i++) {
|
||||
if (Math.abs(this.components[i] - other.component(i)) > EPSILON) {
|
||||
ans = false
|
||||
}
|
||||
@ -164,8 +164,8 @@ var LinearAlgebra;
|
||||
// -------------- global functions ---------------------------------
|
||||
// returns a unit basis vector of size N with a One on position 'pos'
|
||||
function unitBasisVector (N, pos) {
|
||||
var ans = new Vector(N)
|
||||
for (var i = 0; i < N; i++) {
|
||||
const ans = new Vector(N)
|
||||
for (let i = 0; i < N; i++) {
|
||||
if (i === pos) {
|
||||
ans.changeComponent(i, 1.0)
|
||||
} else {
|
||||
@ -177,8 +177,8 @@ var LinearAlgebra;
|
||||
LinearAlgebra.unitBasisVector = unitBasisVector
|
||||
// returns a random vector with integer components (between 'a' and 'b') of size N.
|
||||
function randomVectorInt (N, a, b) {
|
||||
var ans = new Vector(N)
|
||||
for (var i = 0; i < N; i++) {
|
||||
const ans = new Vector(N)
|
||||
for (let i = 0; i < N; i++) {
|
||||
ans.changeComponent(i, (Math.floor((Math.random() * b) + a)))
|
||||
}
|
||||
return ans
|
||||
@ -186,8 +186,8 @@ var LinearAlgebra;
|
||||
LinearAlgebra.randomVectorInt = randomVectorInt
|
||||
// returns a random vector with floating point components (between 'a' and 'b') of size N.
|
||||
function randomVectorFloat (N, a, b) {
|
||||
var ans = new Vector(N)
|
||||
for (var i = 0; i < N; i++) {
|
||||
const ans = new Vector(N)
|
||||
for (let i = 0; i < N; i++) {
|
||||
ans.changeComponent(i, ((Math.random() * b) + a))
|
||||
}
|
||||
return ans
|
||||
@ -198,7 +198,7 @@ var LinearAlgebra;
|
||||
class: Matrix
|
||||
This class represents a matrix of arbitrary size and operations on it.
|
||||
*/
|
||||
var Matrix = /** @class */ (function () {
|
||||
const Matrix = /** @class */ (function () {
|
||||
// constructor for zero-matrix or fix number matrix.
|
||||
function Matrix (row, col, comps) {
|
||||
if (comps === undefined) {
|
||||
@ -206,9 +206,9 @@ var LinearAlgebra;
|
||||
}
|
||||
if (comps.length === 0) {
|
||||
this.matrix = []
|
||||
var rowVector = []
|
||||
for (var i = 0; i < row; i++) {
|
||||
for (var j = 0; j < col; j++) {
|
||||
let rowVector = []
|
||||
for (let i = 0; i < row; i++) {
|
||||
for (let j = 0; j < col; j++) {
|
||||
rowVector[j] = 0
|
||||
}
|
||||
this.matrix[i] = rowVector
|
||||
@ -238,10 +238,10 @@ var LinearAlgebra;
|
||||
}
|
||||
// returns a string representation of this matrix.
|
||||
Matrix.prototype.toString = function () {
|
||||
var ans = ''
|
||||
for (var i = 0; i < this.rows; i++) {
|
||||
let ans = ''
|
||||
for (let i = 0; i < this.rows; i++) {
|
||||
ans += '|'
|
||||
for (var j = 0; j < this.cols; j++) {
|
||||
for (let j = 0; j < this.cols; j++) {
|
||||
if (j < this.cols - 1) {
|
||||
ans += this.matrix[i][j] + ','
|
||||
} else {
|
||||
@ -257,7 +257,7 @@ var LinearAlgebra;
|
||||
}
|
||||
// returns the dimension rows x cols as number array
|
||||
Matrix.prototype.dimension = function () {
|
||||
var ans = []
|
||||
const ans = []
|
||||
ans[0] = this.rows
|
||||
ans[1] = this.cols
|
||||
return ans
|
||||
@ -266,9 +266,9 @@ var LinearAlgebra;
|
||||
Matrix.prototype.add = function (other) {
|
||||
if (this.rows === other.dimension()[0] &&
|
||||
this.cols === other.dimension()[1]) {
|
||||
var ans = new Matrix(this.rows, this.cols)
|
||||
for (var i = 0; i < this.rows; i++) {
|
||||
for (var j = 0; j < this.cols; j++) {
|
||||
const ans = new Matrix(this.rows, this.cols)
|
||||
for (let i = 0; i < this.rows; i++) {
|
||||
for (let j = 0; j < this.cols; j++) {
|
||||
ans.changeComponent(i, j, (this.matrix[i][j] + other.component(i, j)))
|
||||
}
|
||||
}
|
||||
@ -279,12 +279,12 @@ var LinearAlgebra;
|
||||
}
|
||||
// returns true if the matrices are equal, otherwise false.
|
||||
Matrix.prototype.equal = function (other) {
|
||||
var ans = true
|
||||
var EPSILON = 0.001
|
||||
let ans = true
|
||||
const EPSILON = 0.001
|
||||
if (this.rows === other.dimension()[0] &&
|
||||
this.cols === other.dimension()[1]) {
|
||||
for (var i = 0; i < this.rows; i++) {
|
||||
for (var j = 0; j < this.cols; j++) {
|
||||
for (let i = 0; i < this.rows; i++) {
|
||||
for (let j = 0; j < this.cols; j++) {
|
||||
if (Math.abs(this.matrix[i][j] - other.component(i, j)) > EPSILON) {
|
||||
ans = false
|
||||
}
|
||||
@ -297,9 +297,9 @@ var LinearAlgebra;
|
||||
}
|
||||
// matrix-scalar multiplication
|
||||
Matrix.prototype.scalar = function (c) {
|
||||
var ans = new Matrix(this.rows, this.cols)
|
||||
for (var i = 0; i < this.rows; i++) {
|
||||
for (var j = 0; j < this.cols; j++) {
|
||||
const ans = new Matrix(this.rows, this.cols)
|
||||
for (let i = 0; i < this.rows; i++) {
|
||||
for (let j = 0; j < this.cols; j++) {
|
||||
ans.changeComponent(i, j, (this.matrix[i][j] * c))
|
||||
}
|
||||
}
|
||||
|
@ -63,7 +63,7 @@ const FibonacciDpWithoutRecursion = (number) => {
|
||||
const table = []
|
||||
table.push(1)
|
||||
table.push(1)
|
||||
for (var i = 2; i < number; ++i) {
|
||||
for (let i = 2; i < number; ++i) {
|
||||
table.push(table[i - 1] + table[i - 2])
|
||||
}
|
||||
return table
|
||||
|
@ -5,7 +5,7 @@
|
||||
* have been searched.
|
||||
*/
|
||||
function SearchArray (searchNum, ar) {
|
||||
var position = Search(ar, searchNum)
|
||||
const position = Search(ar, searchNum)
|
||||
if (position !== -1) {
|
||||
console.log('The element was found at ' + (position + 1))
|
||||
} else {
|
||||
@ -15,13 +15,13 @@ function SearchArray (searchNum, ar) {
|
||||
|
||||
// Search “theArray” for the specified “key” value
|
||||
function Search (theArray, key) {
|
||||
for (var n = 0; n < theArray.length; n++) {
|
||||
for (let n = 0; n < theArray.length; n++) {
|
||||
if (theArray[n] === key) { return n }
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
var ar = [1, 2, 3, 4, 5, 6, 7, 8, 9]
|
||||
const ar = [1, 2, 3, 4, 5, 6, 7, 8, 9]
|
||||
SearchArray(3, ar)
|
||||
SearchArray(4, ar)
|
||||
SearchArray(11, ar)
|
||||
|
@ -23,7 +23,7 @@ function gnomeSort (items) {
|
||||
|
||||
// Implementation of gnomeSort
|
||||
|
||||
var ar = [5, 6, 7, 8, 1, 2, 12, 14]
|
||||
const ar = [5, 6, 7, 8, 1, 2, 12, 14]
|
||||
// Array before Sort
|
||||
console.log(ar)
|
||||
gnomeSort(ar)
|
||||
|
@ -50,7 +50,7 @@ function heapSort (items) {
|
||||
|
||||
// Implementation of heapSort
|
||||
|
||||
var ar = [5, 6, 7, 8, 1, 2, 12, 14]
|
||||
const ar = [5, 6, 7, 8, 1, 2, 12, 14]
|
||||
// Array before Sort
|
||||
console.log(ar)
|
||||
heapSort(ar)
|
||||
|
@ -5,9 +5,9 @@
|
||||
* the correct position and expand sorted part one element at a time.
|
||||
*/
|
||||
function insertionSort (unsortedList) {
|
||||
var len = unsortedList.length
|
||||
for (var i = 1; i < len; i++) {
|
||||
var tmp = unsortedList[i] // Copy of the current element.
|
||||
const len = unsortedList.length
|
||||
for (let i = 1; i < len; i++) {
|
||||
const tmp = unsortedList[i] // Copy of the current element.
|
||||
/* Check through the sorted part and compare with the number in tmp. If large, shift the number */
|
||||
for (var j = i - 1; j >= 0 && (unsortedList[j] > tmp); j--) {
|
||||
// Shift the number
|
||||
@ -19,6 +19,6 @@ function insertionSort (unsortedList) {
|
||||
}
|
||||
}
|
||||
|
||||
var arr = [5, 3, 1, 2, 4, 8, 3, 8]
|
||||
const arr = [5, 3, 1, 2, 4, 8, 3, 8]
|
||||
insertionSort(arr)
|
||||
console.log(arr)
|
||||
|
@ -28,12 +28,12 @@ function introsort (array, compare) {
|
||||
* 0 if a is equal to b
|
||||
* 1 if a greater than b
|
||||
*/
|
||||
var defaultComparator = function (x, y) {
|
||||
const defaultComparator = function (x, y) {
|
||||
if (x === undefined && y === undefined) return 0
|
||||
if (x === undefined) return 1
|
||||
if (y === undefined) return -1
|
||||
var xString = toString(x)
|
||||
var yString = toString(y)
|
||||
const xString = toString(x)
|
||||
const yString = toString(y)
|
||||
if (xString < yString) return -1
|
||||
if (xString > yString) return 1
|
||||
return 0
|
||||
@ -75,8 +75,8 @@ function introsort (array, compare) {
|
||||
* [IIFE](https://en.wikipedia.org/wiki/Immediately_invoked_function_expression)
|
||||
*/
|
||||
return (function (array, comparator) {
|
||||
var swap = function (index1, index2) {
|
||||
var temp = array[index1]
|
||||
const swap = function (index1, index2) {
|
||||
const temp = array[index1]
|
||||
array[index1] = array[index2]
|
||||
array[index2] = temp
|
||||
}
|
||||
@ -85,14 +85,14 @@ function introsort (array, compare) {
|
||||
* If the length of array is less than
|
||||
* this then we simply perform insertion sort
|
||||
*/
|
||||
var THRESHOLD = 16
|
||||
const THRESHOLD = 16
|
||||
/**
|
||||
* @constant TUNEMAXDEPTH
|
||||
* Constant usec to increase or decrease value
|
||||
* of maxDepth
|
||||
*/
|
||||
var TUNEMAXDEPTH = 1
|
||||
var len = array.length
|
||||
const TUNEMAXDEPTH = 1
|
||||
const len = array.length
|
||||
/**
|
||||
* Return if array is only of length 1
|
||||
* Array of size 1 is always sorted
|
||||
@ -104,7 +104,7 @@ function introsort (array, compare) {
|
||||
* Calculate maxDepth = log2(len)
|
||||
* Taken from implementation in stdc++
|
||||
*/
|
||||
var maxDepth = Math.floor(Math.log2(len)) * TUNEMAXDEPTH
|
||||
const maxDepth = Math.floor(Math.log2(len)) * TUNEMAXDEPTH
|
||||
/**
|
||||
* The very first call to quicksort
|
||||
* this initiates sort routine
|
||||
@ -133,7 +133,7 @@ function introsort (array, compare) {
|
||||
heapSort(start, last)
|
||||
return
|
||||
}
|
||||
var pivot = (last + start) >> 1
|
||||
let pivot = (last + start) >> 1
|
||||
pivot = partition(start, last, pivot)
|
||||
quickSort(start, pivot, depth - 1)
|
||||
quickSort(pivot + 1, last, depth - 1)
|
||||
@ -148,8 +148,8 @@ function introsort (array, compare) {
|
||||
function partition (start, last, pivot) {
|
||||
swap(start, pivot)
|
||||
pivot = start
|
||||
var lo = start
|
||||
var hi = last
|
||||
let lo = start
|
||||
let hi = last
|
||||
while (true) {
|
||||
lo++
|
||||
while (comparator(array[lo], array[pivot]) <= 0 && lo !== last) {
|
||||
@ -175,7 +175,7 @@ function introsort (array, compare) {
|
||||
* @param {Number} last one more than last index of array to be sorted
|
||||
*/
|
||||
function insertionSort (start, last) {
|
||||
var i, j
|
||||
let i, j
|
||||
for (i = start + 1; i < last; i++) {
|
||||
j = i - 1
|
||||
while (j >= 0 && comparator(array[j], array[j + 1]) > 0) {
|
||||
@ -192,7 +192,7 @@ function introsort (array, compare) {
|
||||
* @param {Number} last one more than last index of array to be sorted
|
||||
*/
|
||||
function heapSort (start, last) {
|
||||
var x = (last + start) >> 1
|
||||
let x = (last + start) >> 1
|
||||
while (x - start >= 0) {
|
||||
heapify(x, start, last)
|
||||
x--
|
||||
@ -211,8 +211,8 @@ function introsort (array, compare) {
|
||||
* @param {Number} last one more than last index of segment that cur belongs to
|
||||
*/
|
||||
function heapify (cur, start, last) {
|
||||
var size = last - start
|
||||
var max, lt, rt
|
||||
const size = last - start
|
||||
let max, lt, rt
|
||||
cur = cur - start
|
||||
while (true) {
|
||||
max = cur
|
||||
@ -250,9 +250,9 @@ function introsort (array, compare) {
|
||||
(function demo () {
|
||||
const data = []
|
||||
const size = 1000000
|
||||
var i = 0
|
||||
var temp
|
||||
var c = function (a, b) {
|
||||
let i = 0
|
||||
let temp
|
||||
const c = function (a, b) {
|
||||
return a - b
|
||||
}
|
||||
for (i = 0; i < size; i++) {
|
||||
@ -260,7 +260,7 @@ function introsort (array, compare) {
|
||||
data.push(temp)
|
||||
}
|
||||
introsort(data, c)
|
||||
var faulty = false
|
||||
let faulty = false
|
||||
for (i = 1; i < size; i++) {
|
||||
if (data[i] < data[i - 1]) {
|
||||
faulty = true
|
||||
@ -283,8 +283,8 @@ function introsort (array, compare) {
|
||||
const data = []
|
||||
const data2 = []
|
||||
const size = 1000000
|
||||
var i = 0
|
||||
var temp
|
||||
let i = 0
|
||||
let temp
|
||||
for (i = 0; i < size; i++) {
|
||||
temp = Math.random() * Number.MAX_SAFE_INTEGER
|
||||
data.push(temp)
|
||||
@ -292,7 +292,7 @@ function introsort (array, compare) {
|
||||
}
|
||||
introsort(data)
|
||||
data2.sort()
|
||||
var faulty = false
|
||||
let faulty = false
|
||||
for (i = 1; i < size; i++) {
|
||||
if (data[i] !== data2[i]) {
|
||||
faulty = true
|
||||
|
@ -35,7 +35,7 @@
|
||||
*/
|
||||
|
||||
function merge (list1, list2) {
|
||||
var results = []
|
||||
const results = []
|
||||
|
||||
while (list1.length && list2.length) {
|
||||
if (list1[0] <= list2[0]) {
|
||||
@ -55,15 +55,15 @@ function merge (list1, list2) {
|
||||
function mergeSort (list) {
|
||||
if (list.length < 2) return list
|
||||
|
||||
var listHalf = Math.floor(list.length / 2)
|
||||
var subList1 = list.slice(0, listHalf)
|
||||
var subList2 = list.slice(listHalf, list.length)
|
||||
const listHalf = Math.floor(list.length / 2)
|
||||
const subList1 = list.slice(0, listHalf)
|
||||
const subList2 = list.slice(listHalf, list.length)
|
||||
|
||||
return merge(mergeSort(subList1), mergeSort(subList2))
|
||||
}
|
||||
|
||||
// Merge Sort Example
|
||||
var unsortedArray = [10, 5, 3, 8, 2, 6, 4, 7, 9, 1]
|
||||
var sortedArray = mergeSort(unsortedArray)
|
||||
const unsortedArray = [10, 5, 3, 8, 2, 6, 4, 7, 9, 1]
|
||||
const sortedArray = mergeSort(unsortedArray)
|
||||
|
||||
console.log('Before:', unsortedArray, 'After:', sortedArray)
|
||||
|
@ -17,16 +17,16 @@
|
||||
*/
|
||||
|
||||
function quickSort (items) {
|
||||
var length = items.length
|
||||
const length = items.length
|
||||
|
||||
if (length <= 1) {
|
||||
return items
|
||||
}
|
||||
var PIVOT = items[0]
|
||||
var GREATER = []
|
||||
var LESSER = []
|
||||
const PIVOT = items[0]
|
||||
const GREATER = []
|
||||
const LESSER = []
|
||||
|
||||
for (var i = 1; i < length; i++) {
|
||||
for (let i = 1; i < length; i++) {
|
||||
if (items[i] > PIVOT) {
|
||||
GREATER.push(items[i])
|
||||
} else {
|
||||
@ -34,7 +34,7 @@ function quickSort (items) {
|
||||
}
|
||||
}
|
||||
|
||||
var sorted = quickSort(LESSER)
|
||||
let sorted = quickSort(LESSER)
|
||||
sorted.push(PIVOT)
|
||||
sorted = sorted.concat(quickSort(GREATER))
|
||||
|
||||
@ -43,7 +43,7 @@ function quickSort (items) {
|
||||
|
||||
// Implementation of quick sort
|
||||
|
||||
var ar = [0, 5, 3, 2, 2]
|
||||
let ar = [0, 5, 3, 2, 2]
|
||||
// Array before Sort
|
||||
console.log(ar)
|
||||
ar = quickSort(ar)
|
||||
|
@ -10,29 +10,29 @@ function radixSort (items, RADIX) {
|
||||
RADIX = 10
|
||||
}
|
||||
|
||||
var maxLength = false
|
||||
var placement = 1
|
||||
let maxLength = false
|
||||
let placement = 1
|
||||
|
||||
while (!maxLength) {
|
||||
maxLength = true
|
||||
var buckets = []
|
||||
const buckets = []
|
||||
|
||||
for (var i = 0; i < RADIX; i++) {
|
||||
for (let i = 0; i < RADIX; i++) {
|
||||
buckets.push([])
|
||||
}
|
||||
|
||||
for (var j = 0; j < items.length; j++) {
|
||||
var tmp = items[j] / placement
|
||||
for (let j = 0; j < items.length; j++) {
|
||||
const tmp = items[j] / placement
|
||||
buckets[Math.floor(tmp % RADIX)].push(items[j])
|
||||
if (maxLength && tmp > 0) {
|
||||
maxLength = false
|
||||
}
|
||||
}
|
||||
|
||||
var a = 0
|
||||
for (var b = 0; b < RADIX; b++) {
|
||||
var buck = buckets[b]
|
||||
for (var k = 0; k < buck.length; k++) {
|
||||
let a = 0
|
||||
for (let b = 0; b < RADIX; b++) {
|
||||
const buck = buckets[b]
|
||||
for (let k = 0; k < buck.length; k++) {
|
||||
items[a] = buck[k]
|
||||
a++
|
||||
}
|
||||
@ -44,7 +44,7 @@ function radixSort (items, RADIX) {
|
||||
|
||||
// Implementation of radixSort
|
||||
|
||||
var ar = [5, 6, 7, 8, 1, 2, 12, 14]
|
||||
const ar = [5, 6, 7, 8, 1, 2, 12, 14]
|
||||
// Array before Sort
|
||||
console.log(ar)
|
||||
radixSort(ar)
|
||||
|
@ -2,7 +2,7 @@ import { selectionSort } from './SelectionSort'
|
||||
|
||||
describe('selectionSort', () => {
|
||||
it('expects to return the array sorted in ascending order', () => {
|
||||
var toSort = [5, 6, 7, 8, 1, 2, 12, 14]
|
||||
const toSort = [5, 6, 7, 8, 1, 2, 12, 14]
|
||||
const expected = [1, 2, 5, 6, 7, 8, 12, 14]
|
||||
|
||||
expect(selectionSort(toSort)).toEqual(expected)
|
||||
|
@ -4,16 +4,16 @@
|
||||
*
|
||||
*/
|
||||
function shellSort (items) {
|
||||
var interval = 1
|
||||
let interval = 1
|
||||
|
||||
while (interval < items.length / 3) {
|
||||
interval = interval * 3 + 1
|
||||
}
|
||||
|
||||
while (interval > 0) {
|
||||
for (var outer = interval; outer < items.length; outer++) {
|
||||
var value = items[outer]
|
||||
var inner = outer
|
||||
for (let outer = interval; outer < items.length; outer++) {
|
||||
const value = items[outer]
|
||||
let inner = outer
|
||||
|
||||
while (inner > interval - 1 && items[inner - interval] >= value) {
|
||||
items[inner] = items[inner - interval]
|
||||
@ -28,7 +28,7 @@ function shellSort (items) {
|
||||
|
||||
// Implementation of shellSort
|
||||
|
||||
var ar = [5, 6, 7, 8, 1, 2, 12, 14]
|
||||
const ar = [5, 6, 7, 8, 1, 2, 12, 14]
|
||||
// Array before Sort
|
||||
console.log(ar)
|
||||
shellSort(ar)
|
||||
|
@ -1,10 +1,10 @@
|
||||
|
||||
function TopologicalSorter () {
|
||||
var graph = {}
|
||||
var isVisitedNode
|
||||
var finishTimeCount
|
||||
var finishingTimeList
|
||||
var nextNode
|
||||
const graph = {}
|
||||
let isVisitedNode
|
||||
let finishTimeCount
|
||||
let finishingTimeList
|
||||
let nextNode
|
||||
|
||||
this.addOrder = function (nodeA, nodeB) {
|
||||
nodeA = String(nodeA)
|
||||
@ -18,7 +18,7 @@ function TopologicalSorter () {
|
||||
finishTimeCount = 0
|
||||
finishingTimeList = []
|
||||
|
||||
for (var node in graph) {
|
||||
for (const node in graph) {
|
||||
if (Object.prototype.hasOwnProperty.call(graph, node) && !isVisitedNode[node]) {
|
||||
dfsTraverse(node)
|
||||
}
|
||||
@ -34,7 +34,7 @@ function TopologicalSorter () {
|
||||
function dfsTraverse (node) {
|
||||
isVisitedNode[node] = true
|
||||
if (graph[node]) {
|
||||
for (var i = 0; i < graph[node].length; i++) {
|
||||
for (let i = 0; i < graph[node].length; i++) {
|
||||
nextNode = graph[node][i]
|
||||
if (isVisitedNode[nextNode]) continue
|
||||
dfsTraverse(nextNode)
|
||||
@ -49,7 +49,7 @@ function TopologicalSorter () {
|
||||
}
|
||||
|
||||
/* TEST */
|
||||
var topoSorter = new TopologicalSorter()
|
||||
const topoSorter = new TopologicalSorter()
|
||||
topoSorter.addOrder(5, 2)
|
||||
topoSorter.addOrder(5, 0)
|
||||
topoSorter.addOrder(4, 0)
|
||||
|
@ -18,7 +18,7 @@ Array.prototype.wiggleSort = function () {
|
||||
|
||||
// Implementation of wiggle sort
|
||||
|
||||
var arr = [3, 5, 2, 1, 6, 4]
|
||||
const arr = [3, 5, 2, 1, 6, 4]
|
||||
// Array before Wiggle Sort
|
||||
console.log(arr) // [3, 5, 2, 1, 6, 4]
|
||||
|
||||
|
@ -25,13 +25,13 @@ function traverseDFS (root) {
|
||||
}
|
||||
|
||||
function searchDFS (tree, value) {
|
||||
var stack = []
|
||||
const stack = []
|
||||
|
||||
stack.push(tree[0])
|
||||
|
||||
while (stack.length !== 0) {
|
||||
for (let i = 0; i < stack.length; i++) {
|
||||
var node = stack.pop()
|
||||
const node = stack.pop()
|
||||
|
||||
if (node.value === value) {
|
||||
return node
|
||||
@ -47,7 +47,7 @@ function searchDFS (tree, value) {
|
||||
return null
|
||||
}
|
||||
|
||||
var tree = [
|
||||
const tree = [
|
||||
{ value: 6, left: 1, right: 2 },
|
||||
{ value: 5, left: 3, right: 4 },
|
||||
{ value: 7, left: null, right: 5 },
|
||||
|
Reference in New Issue
Block a user