Index
A
- Adelson-Velskii and Landi’s tree (AVL tree)
- about / Adelson-Velskii and Landi’s tree (AVL tree)
- balancing factor / Height of a node and the balancing factor
- height of node / Height of a node and the balancing factor
- balancing operations / Balancing operations– AVL rotations
- node, inserting / Inserting a node in the AVL tree
- node, removing / Removing a node from the AVL tree
- adjacency list / The adjacency list
- adjacency matrix / The adjacency matrix
- adjacent vertices / Graph terminology
- algorithms / Having fun with algorithms
- array destructuring / Enhanced object properties
- arrays
- using / Why should we use arrays?
- creating / Creating and initializing arrays
- initializing / Creating and initializing arrays
- elements, accessing / Accessing elements and iterating an array
- iterating / Accessing elements and iterating an array
- in TypeScript / Arrays in TypeScript
- arrow functions / Set union
- ASCII table
- reference / Sorting strings
- associative array / The dictionary data structure
- Asynchronous Module Definition (AMD) / Modules
- Atom
- reference / Debugging and tools
- AVL rotations
- about / Balancing operations– AVL rotations
- single rotation to the right / Left-left case: single rotation to the right
- single rotation to the left / Right-right case: single rotation to the left
- double rotation to the right / Left-right case: double rotation to the right
- double rotation to the left / Right-left case – double rotation to the left
B
- Babel
- Babel.js
- using / Using Babel.js
- reference / Using Babel.js
- backtracking algorithms
- about / Backtracking algorithms
- Rat in a Maze / Rat in a Maze
- Sudoku Solver problem / Sudoku Solver
- balance factor / Height of a node and the balancing factor
- base case / Understanding recursion
- base converter algorithm / The base converter algorithm
- big O notation
- about / Big O notation, Understanding big O notation
- O(1) / O(1)
- O(n) / O(n)
- O(n2) / O(n2)
- complexities, comparing / Comparing complexities
- reference / Comparing complexities
- NP-completeness theory / Introduction to the NP-completeness theory
- binary heap
- data structure / The binary heap data structure
- binary search algorithm / The binary search
- binary search tree (BST)
- about / The binary and binary search trees
- key, inserting / Inserting a key into the BST
- BinarySearchTree class
- binary tree / The binary and binary search trees
- breadth-first search (BFS)
- about / Graph traversals, Breadth-first search (BFS)
- used, for finding shortest path / Finding the shortest paths using BFS
- Browserify / Running ES2015 modules in the browser
- bubble down operation / Extracting the minimum or maximum value from the heap
- bubble sort algorithm
- about / The bubble sort
- improved bubble sort / The improved bubble sort
- bubble up operation / Inserting a value into the heap
- bucket sort algorithm / The bucket sort
C
- callback function / Functional versus imperative programming
- call stack / The call stack
- cascade down operation / Extracting the minimum or maximum value from the heap
- cascade up operation / Inserting a value into the heap
- Chrome
- reference / Debugging with VSCode
- circular linked lists
- about / Circular linked lists
- new element, inserting at any position / Inserting a new element at any position
- elements, removing from any position / Removing elements from any position
- circular queue / The circular queue – Hot Potato
- class field proposal
- reference / ECMAScript class field proposal
- CodeChef
- reference / Having fun with algorithms
- Coderbyte
- reference / Having fun with algorithms
- collisions, handling between hash tables
- about / Handling collisions between hash tables
- separate chaining technique / Separate chaining
- linear probing technique / Linear probing
- compatibility table / The compatibility table
- complexity comparison, big O notation
- about / Comparing complexities
- data structures / Data structures
- graphs / Graphs
- sorting algorithms / Sorting Algorithms
- Searching Algorithms / Searching Algorithms
- const keyword
- variable scope / Variables scope with let and const
- control structures
- about / Control structures
- conditional statements / Conditional statements
- loops / Loops
- counting sort algorithm / The counting sort
D
- databases / Set operations
- dataset
- structuring / Structuring a dataset
- data structure, binary heap
- MinHeap class, creating / Creating the MinHeap class
- creating / Creating the MaxHeap class
- debugging / Debugging and tools
- default parameter functionality / Creating the Dictionary class
- degree / Graph terminology
- depth-first search (DFS) algorithm
- about / Graph traversals, Depth-first search (DFS)
- exploring / Exploring the DFS algorithm
- used, for topological sorting / Topological sorting using DFS
- deque / Creating the StackLinkedList class
- Deque class
- creating / Creating the Deque class
- elements, adding at front / Adding elements to the front of the deque
- using / Using the Deque class
- deque data structure / The deque data structure
- deques
- used, for problem solving / Solving problems using queues and deques
- dictionary
- about / The dictionary data structure
- key existence, verifying / Verifying whether a key exists in the dictionary
- key, setting / Setting a key and value in the dictionary and the ValuePair class
- ValuePair class / Setting a key and value in the dictionary and the ValuePair class
- value, removing / Removing a value from the dictionary
- value, retrieving / Retrieving a value from the dictionary
- values method / The keys, values, and valuePairs methods
- keys method / The keys, values, and valuePairs methods
- each ValuePair, iterating, with forEach / Iterating each ValuePair of the dictionary with forEach
- clear method / The clear, size, isEmpty, and toString methods
- size method / The clear, size, isEmpty, and toString methods
- isEmpty method / The clear, size, isEmpty, and toString methods
- toString method / The clear, size, isEmpty, and toString methods
- Dictionary class, using / Using the Dictionary class
- Dictionary class
- creating / Creating the Dictionary class
- Dijkstra's algorithm / Dijkstra's algorithm, Greedy algorithms
- directed acyclic graph (DAG) / Topological sorting using DFS
- directed graph / Directed and undirected graphs
- divide and conquer algorithm
- divide / Divide and conquer
- conquer / Divide and conquer
- combine / Divide and conquer
- binary search / Binary search
- double-ended queue / The deque data structure
- doubly linked lists
- about / Doubly linked lists
- element, inserting at any position / Inserting a new element at any position
- elements, removing from any position / Removing elements from any position
- Duck Typing / Interfaces
- dynamic programming (DP)
- about / Dynamic programming
- minimum coin change problem / The minimum coin change problem
- knapsack problem / The knapsack problem
- longest common subsequence (LCS) / The longest common subsequence
- matrix chain multiplication / Matrix chain multiplication
E
- ECMAScript / ECMAScript or JavaScript?
- ECMAScript 6
- methods / ECMAScript 6 and new array functionalities
- iterating, for...of loop used / Iterating using the for...of loop
- @@iterator object, using / Using the @@iterator object
- array entries / Array entries, keys, and values
- keys / Array entries, keys, and values
- values / Array entries, keys, and values
- from method, using / Using the from method
- Array.of method, using / Using the Array.of method
- fill method, using / Using the fill method
- copyWithin method, using / Using the copyWithin method
- ECMAScript 2015
- find method / ECMAScript 2015 - the find and findIndex methods
- findIndex methods / ECMAScript 2015 - the find and findIndex methods
- ECMAScript 2015 (ES6) functionalities / Creating the LinkedList class
- ECMAScript 2015 Set class
- about / ECMAScript 2015 – the Set class
- reference / ECMAScript 2015 – the Set class
- operations / ES2015 Set class operations
- ECMAScript 2015 Set class operation
- about / ES2015 Set class operations
- union operation, simulating / Simulating the union operation
- intersection operation, simulating / Simulating the intersection operation
- difference operation, simulating / Simulating the difference operation
- spread operator, using / Using the spread operator
- ECMAScript 2015+ functionalities
- about / ECMAScript 2015+ functionalities
- let / let and const instead of var
- const / let and const instead of var
- template literals / Template literals
- arrow functions / Arrow functions
- default parameter, values for functions / Default parameter values for functions
- spread and rest operators, declaring / Declaring the spread and rest operators
- enhanced object properties / Enhanced object properties
- object-oriented programming with classes / Object-oriented programming with classes
- exponentiation operator / Exponentiation operator
- modules / Modules
- backward compatibility / ES2015+ backward compatibility
- ECMAScript 2016
- includes method, using / ECMAScript 2016 - using the includes method
- ECMAScript 2017 / The values method
- edges / Creating the Node and BinarySearchTree classes
- elements
- adding / Adding elements
- inserting, at end of array / Inserting an element at the end of the array
- push method, using / Using the push method
- inserting, in first position / Inserting an element in the first position
- unshift method, using / Using the unshift method
- removing / Removing elements
- removing, from end of array / Removing an element from the end of the array
- removing, from first position / Removing an element from the first position
- shift method, using / Using the shift method
- removing, from specific position / Adding and removing elements from a specific position
- adding, from specific position / Adding and removing elements from a specific position
- empty set / Structuring a dataset
- ES.Next / ES6, ES2015, ES7, ES2016, ES8, ES2017, and ES.Next
- ES6 / ES6, ES2015, ES7, ES2016, ES8, ES2017, and ES.Next
- ES7 / ES6, ES2015, ES7, ES2016, ES8, ES2017, and ES.Next
- ES8 / ES6, ES2015, ES7, ES2016, ES8, ES2017, and ES.Next
- ES2015
- about / ES6, ES2015, ES7, ES2016, ES8, ES2017, and ES.Next
- reference / The compatibility table
- ES2015 Map class
- about / The ES2015 Map class
- reference / The ES2015 Map class
- ES2015 modules
- reference / Modules
- running, in browser with Node.js / Running ES2015 modules in the browser and with Node.js
- executing, in browser / Running ES2015 modules in the browser
- ES2015 WeakMap class / The ES2015 WeakMap and WeakSet classes
- ES2015 WeakSet class / The ES2015 WeakMap and WeakSet classes
- ES2016 / ES6, ES2015, ES7, ES2016, ES8, ES2017, and ES.Next
- ES2016+
- reference / The compatibility table
- ES2017 / ES6, ES2015, ES7, ES2016, ES8, ES2017, and ES.Next
- ESLint
- reference / The has(element) method
- event loop / JavaScript task queues
- external nodes / Tree terminology
F
- factorial of number
- calculating / Calculating the factorial of a number
- iterative factorial / Iterative factorial
- Recursive factorial / Recursive factorial
- fibonacci function
- reference / Why use recursion? Is it faster?
- Fibonacci sequence
- about / The Fibonacci sequence
- Iterative Fibonacci / Iterative Fibonacci
- Recursive Fibonacci / Recursive Fibonacci
- Fibonacci with memoization / Fibonacci with memoization
- first in, first out (FIFO) / The queue data structure
- Fisher-Yates shuffle algorithm / The Fisher-Yates shuffle
- Floyd-Warshall algorithm / The Floyd-Warshall algorithm, Dynamic programming
- fractional knapsack problem / The knapsack problem
- functional programming (FP)
- about / Set union, Introduction to functional programming
- versus imperative programming / Functional versus imperative programming
- and ES2015+ / ES2015+ and functional programming
- JavaScript functional toolbox / The JavaScript functional toolbox – map, filter, and reduce
- reference / The JavaScript functional toolbox – map, filter, and reduce
- JavaScript functional libraries and data structures / JavaScript functional libraries and data structures
- functional programming paradigm / The keys, values, and valuePairs methods
G
- GitHub
- reference / Having fun with algorithms
- Google Developer Tools
- reference / Debugging and tools
- Graph class
- creating / Creating the Graph class
- graphs
- about / Graph terminology
- representing / Representing a graph
- adjacency matrix / The adjacency matrix
- adjacency list / The adjacency list
- incidence matrix / The incidence matrix
- graph traversal algorithms
- about / Graph traversals
- breadth-first search (BFS) / Breadth-first search (BFS)
- depth-first search (DFS) algorithm / Depth-first search (DFS)
- greedy algorithms
- about / Greedy algorithms
- min-coin change problem / The min-coin change problem
- fractional knapsack problem / The fractional knapsack problem
H
- HackerRank
- reference / Having fun with algorithms
- halting problem / Introduction to the NP-completeness theory
- hash function
- reference / Creating better hash functions
- hashing / The hash table
- hash table
- about / The hash table
- HashTable class, creating / Creating a HashTable class
- hash function, creating / Creating a hash function
- key and value, inserting / Putting a key and a value in the hash table
- value, retrieving / Retrieving a value from the hash table
- versus hash set / Hash table versus hash set
- collisions, handling / Handling collisions between hash tables
- better hash functions, creating / Creating better hash functions
- HashTable class
- creating / Creating a HashTable class
- value, removing / Removing a value from the hash table
- using / Using the HashTable class
- heapify operation / Extracting the minimum or maximum value from the heap
- heapify up operation / Inserting a value into the heap
- heap property / The binary heap data structure
- heap sort algorithm / The heap sort algorithm
I
- imperative programming / Introduction to functional programming
- incidence matrix / The incidence matrix
- Information Technology (IT) / JavaScript data structure and algorithms
- internal elements, data structure
- protecting / Protecting the internal elements of the data structure
- underscore naming convention / The underscore naming convention
- ES2015 classes with scoped symbols / ES2015 classes with scoped symbols
- ES2015 classes with WeakMap / ES2015 classes with WeakMap
- ECMAScript class field proposal / ECMAScript class field proposal
- internal nodes / Tree terminology
- International Collegiate Programming Contest (ICPC) / Having fun with algorithms
- interpolation search algorithm / The interpolation search
- intersection method
- about / Set intersection
- improving / Improving the intersection method
- issues, dynamic programming (DP)
- knapsack problem / Dynamic programming
- longest common subsequence / Dynamic programming
- matrix chain multiplication / Dynamic programming
- coin change / Dynamic programming
- all-pairs shortest paths in graph / Dynamic programming
- Iterative Fibonacci / Iterative Fibonacci
- iterator functions
- iteration, using every method / Iterating using the every method
- iteration, using some method / Iterating using the some method
- iteration, using forEach method / Iterating using forEach
- map and filter, using / Using map and filter
- reduce method, using / Using the reduce method
J
- JavaScript
- data structure and algorithms / JavaScript data structure and algorithms
- environment, setting up / Setting up the environment
- setup / The minimum setup to work with JavaScript
- web servers, using / Using web servers
- basics / JavaScript basics
- variables / Variables
- operators / Operators
- true and false value / Truthy and falsy
- equals operators (== and ===) / Functions of the equals operators (== and ===)
- control structures / Control structures
- functions / Functions
- object-oriented programming / Object-oriented programming in JavaScript
- selecting / ECMAScript or JavaScript?
- task queues / JavaScript task queues
- JavaScript array methods
- references / References for JavaScript array methods
- multiple arrays, joining / Joining multiple arrays
- iterator functions / Iterator functions
- ECMAScript 6 / ECMAScript 6 and new array functionalities
- sorting elements / Sorting elements
- searching method / Searching
- array, outputting into string / Outputting the array into a string
- JavaScript data structure and algorithm library
- JavaScript functional libraries
- Bilby.js, reference / JavaScript functional libraries and data structures
- Lazy.js, reference / JavaScript functional libraries and data structures
- Bacon.js, reference / JavaScript functional libraries and data structures
- Fn.js, reference / JavaScript functional libraries and data structures
- Functional.js, reference / JavaScript functional libraries and data structures
- Mori, reference / JavaScript functional libraries and data structures
- Underscode.js, reference / JavaScript functional libraries and data structures
- Ramda.js, reference / JavaScript functional libraries and data structures
- JavaScript functional toolbox
- map function / The JavaScript functional toolbox – map, filter, and reduce
- reduce function / The JavaScript functional toolbox – map, filter, and reduce
- filter function / The JavaScript functional toolbox – map, filter, and reduce
- JavaScript object based Stack class
- creating / Creating a JavaScript object-based Stack class
- elements, pushing to stack / Pushing elements to the stack
- empty state, verifying / Verifying whether the stack is empty and its size
- size, verifying / Verifying whether the stack is empty and its size
- elements, popping from stack / Popping elements from the stack
- stack top, peeking / Peeking the top of the stack and clearing it
- toString method, creating / Creating the toString method
K
- Kruskal's algorithm / Kruskal's algorithm, Greedy algorithms
L
- leaf / Tree terminology
- let keyword
- variable scope / Variables scope with let and const
- linear probing technique
- about / Linear probing
- put method, implementing / The put method
- get method, implementing / The get method
- remove method, implementing / The remove method
- linked list
- about / The linked list data structure
- LinkedList class, creating / Creating the LinkedList class
- elements, pushing to end / Pushing elements to the end of the linked list
- elements, removing from specific position / Removing elements from the linked list from a specific position
- looping through / Looping through the list until we get to the desired position
- remove method, refactoring / Refactoring the remove method
- element, instructing at any position / Inserting an element at any position
- indexOf method / The indexOf method: returning the position of an element
- element, removing / Removing an element from the linked list
- isEmpty method / The isEmpty, size, and getHead methods
- size method / The isEmpty, size, and getHead methods
- getHead methods / The isEmpty, size, and getHead methods
- toString method / The toString method
- Lo-Dash library
- reference / Outputting the array into a string
- longest common subsequence (LCS) / The longest common subsequence
M
- map / The dictionary data structure
- memoization / Fibonacci with memoization, The minimum coin change problem
- methods / Object-oriented programming in JavaScript
- MinHeap class
- creating / Creating the MinHeap class
- binary tree array representation / Binary tree array representation
- value, inserting into heap / Inserting a value into the heap
- sift up operation / The sift up operation
- minimum or maximum value, finding from heap / Finding the minimum or maximum value from the heap
- minimum or maximum value, extracting from heap / Extracting the minimum or maximum value from the heap
- minimum spanning tree (MST)
- about / Minimum spanning tree (MST)
- Prim's algorithm / Prim's algorithm
- Kruskal's algorithm / Kruskal's algorithm
- Mocha / Creating a JavaScript data structure and algorithm library
- multi-dimensional arrays / Two-dimensional and multi-dimensional arrays, Multi-dimensional arrays
- multisets (bags) / Multisets or bags
N
- node
- about / Tree terminology
- removing / Removing a node
- leaf node, removing / Removing a leaf node
- with left or right child, removing / Removing a node with a left or right child
- with two children, removing / Removing a node with two children
- Node.js
- download link / Node.js http-server
- ES2015 imports, using / Using native ES2015 imports in Node.js
- Node class
- non-distribution sort algorithm / The bubble sort
- NP (nondeterministic polynomial)- completeness theory
- about / Introduction to the NP-completeness theory
- reference / Introduction to the NP-completeness theory
- problems and heuristic algorithms / Impossible problems and heuristic algorithms
- NP-hard problem / Introduction to the NP-completeness theory
- null set / Structuring a dataset
O
- object-oriented programming
- about / Object-oriented programming in JavaScript
- with classes / Object-oriented programming with classes
- inheritance / Inheritance
- getters and setters, working with / Working with getters and setters
- operations, on sets
- union method / Set operations, Set union
- intersection method / Set operations, Set intersection
- difference method / Set operations, Set difference
- subset method / Set operations, Subset
P
- palindrome / Palindrome checker
- partition operation / The quick sort
- path / Graph terminology
- percolate down operation / Extracting the minimum or maximum value from the heap
- percolate up operation / Inserting a value into the heap
- pivot / The quick sort
- post-order traversal / Post-order traversal
- pre-order traversal / Pre-order traversal
- Prim's algorithm / Prim's algorithm, Greedy algorithms
- problem solving, with stack
- decimal numbers, converting to binary / Converting decimal numbers to binary
- Project Euler
- reference / Having fun with algorithms
- property shorthand / Enhanced object properties
- pure functions / Set union
Q
- queue
- data structure / The queue data structure
- about / The queue data structure, Creating the StackLinkedList class
- elements, enqueuing / Enqueuing elements to the queue
- elements, dequeuing / Dequeuing elements from the queue
- element, peeking from queue / Peeking the element from the front of the queue
- size, verifying / Verifying whether the queue is empty and its size
- empty state, verifying / Verifying whether the queue is empty and its size
- clearing / Clearing the queue
- method toString, creating / Creating the toString method
- used, for problem solving / Solving problems using queues and deques
- Queue class
- creating / Creating the Queue class
- using / Using the Queue class
- quick sort algorithm
- about / The quick sort
- partition process / The partition process
- using / The quick sort in action
R
- radix sort algorithm / The radix sort
- Rat in a Maze problem / Rat in a Maze
- recursion
- about / Understanding recursion
- using / Why use recursion? Is it faster?
- features / Why use recursion? Is it faster?
- Recursive factorial
- about / Recursive factorial
- call stack / The call stack
- JavaScript limitation, on call stack size / JavaScript limitation on the call stack size
- Recursive Fibonacci / Recursive Fibonacci
- Red-Black tree
- about / Red-Black tree
- node, inserting / Inserting a node in the Red-Black tree
- verifying, after insertion / Verifying the Red-Black tree properties after insertion
- rotations / Red-Black tree rotations
- RequireJS / Modules
- rest parameter
- reference / Declaring the spread and rest operators
S
- searching algorithms
- about / Searching algorithms
- sequential search algorithm / The sequential search
- binary search algorithm / The binary search
- interpolation search / The interpolation search
- self-balancing trees / Self-balancing trees, Red-Black tree
- separate chaining technique
- about / Separate chaining
- first method, implementing / The put method
- get method, implementing / The get method
- remove method / The remove method
- sequential search algorithm / The sequential search
- set
- about / Structuring a dataset
- creating / Creating a Set class
- set, creating
- has(element) method, creating / The has(element) method
- add method, creating / The add method
- delete method / The delete and clear methods
- clear method, using / The delete and clear methods
- size method, using / The size method
- values method, using / The values method
- Set class, using / Using the Set class
- shape property / The binary heap data structure
- shortest path algorithms
- Dijkstra's algorithm / Further study on the shortest paths algorithms, Dijkstra's algorithm
- Bellman-Ford algorithm / Further study on the shortest paths algorithms
- A* search algorithm / Further study on the shortest paths algorithms
- Floyd-Warshall algorithm / Further study on the shortest paths algorithms, The Floyd-Warshall algorithm
- about / Shortest path algorithms
- shorthand method names / Enhanced object properties
- shuffle algorithms
- about / Shuffle algorithms
- Fisher-Yates shuffle algorithm / The Fisher-Yates shuffle
- sift down operation (heapify) operation / The sift down operation (heapify)
- sink down operation / Extracting the minimum or maximum value from the heap
- sorted linked lists
- about / Sorted linked lists
- elements, inserting in order / Inserting elements in order
- sorting algorithms
- about / Sorting algorithms
- reference / Sorting algorithms
- bubble sort / The bubble sort
- selection sort / The selection sort
- insertion sort / The insertion sort
- merge sort / The merge sort
- quick sort / The quick sort
- counting sort / The counting sort
- bucket sort / The bucket sort
- radix sort / The radix sort
- sorting elements
- about / Sorting elements
- custom sorting / Custom sorting
- sorting strings / Sorting strings
- sparse graphs / The adjacency matrix
- Sphere Online Judge
- reference / Having fun with algorithms
- spread operator
- reference / Declaring the spread and rest operators
- SQL joins
- about / Set operations
- reference / Set operations
- stack
- about / The stack data structure, Creating the StackLinkedList class
- used, for problem solving / Solving problems using stacks
- stack data structure
- about / The stack data structure
- array-based Stack class, creating / Creating an array-based Stack class
- elements, pushing / Pushing elements to the stack
- elements, popping / Popping elements from the stack
- element, peeking from top / Peeking the element from the top of the stack
- empty state, verifying / Verifying whether the stack is empty
- elements, clearing / Clearing the elements of the stack
- Stack class, using / Using the Stack class
- StackLinkedList class
- creating / Creating the StackLinkedList class
- stack overflow error / JavaScript limitation on the call stack size
- stopping point / Understanding recursion
- Sublime Text
- reference / Debugging and tools
- subtree / Tree terminology
- Sudoku Solver problem / Sudoku Solver
- symbol table / The dictionary data structure
T
- tail call optimization
- Top Coder
- reference / Having fun with algorithms
- topological sorting (topsort or toposort) / Topological sorting using DFS
- trees
- data structure / The tree data structure
- terminology / Tree terminology
- values, searching / Searching for values in a tree
- maximum values, searching / Searching for minimum and maximum values
- minimum values, searching / Searching for minimum and maximum values
- specific value, searching / Searching for a specific value
- tree traversal
- about / Tree traversal
- in-order traversal / In-order traversal
- pre-order traversal / Pre-order traversal
- post-order traversal / Post-order traversal
- two-dimensional arrays
- about / Two-dimensional and multi-dimensional arrays
- elements, iterating / Iterating the elements of two-dimensional arrays
- TypedArray class / The TypedArray class
- TypeScript
- about / Introducing TypeScript
- type inference / Type inference
- interfaces / Interfaces
- interfaces, generics / Generics
- functionalities / Other TypeScript functionalities
- reference / Other TypeScript functionalities
- compile-time checking, in JavaScript files / TypeScript compile-time checking in JavaScript files
- arrays / Arrays in TypeScript
U
- Underscode.js
- undirected graph / Directed and undirected graphs
- Universal Module Definition (UMD) / ES2015+ backward compatibility
- up head operation / Inserting a value into the heap
- UVa Online Judge
- reference / Having fun with algorithms
V
- variables
- about / Variables
- scope variable / Scope variable
- Visual Studio Code
- reference / Debugging and tools
- used, for debugging / Debugging with VSCode
- about / Creating a JavaScript data structure and algorithm library
W
- Webpack
- Web Server for Chrome extension
- reference / Using web servers
- web servers
- Node.js http-server / Node.js http-server
- WebStorm
- reference / Debugging and tools
X
- XAMPP
- reference / Using web servers