Index

A

• A* search algorithm
  • about / Further studies on the shortest paths algorithms
• acyclic graph
  • about / Graph terminology
• add method
  • about / The add method
• adjacency list
  • about / The adjacency list
• adjacency matrix
  • about / The adjacency matrix
• adjacent vertices / Graph terminology
• Aptana
  • about / Debugging and tools
  • URL / Debugging and tools
• arguments
  • about / Functions
• arithmetic operators
  • about / Operators
• arrays
  • about / Variables
  • creating / Creating and initializing arrays
  • initializing / Creating and initializing arrays
  • elements, removing from / Adding and removing elements
  • elements, adding in / Adding and removing elements
  • outputting, into string / Outputting the array into a string
  • references / Outputting the array into a string
• ASCII
  • URL / Creating a hash table
• ASCII table
  • URL / Sorting strings
• assignment operators
  • about / Operators
• AVL tree
  • about / More about binary trees

B

• balanced parentheses examples / Decimal to binary
• Bellman-Ford algorithm
  • about / Further studies on the shortest paths algorithms
• BFS
  • about / Graph traversals, Breadth-first search (BFS)
  • used, for searching shortest paths / Finding the shortest paths using BFS
  • shortest paths algorithms / Further studies on the shortest paths algorithms
• binary representation
  • decimal number, converting to / Decimal to binary
• binary search algorithm
  • about / Binary search
• binary search tree
  • BinarySearchTree class, creating / Creating the BinarySearchTree class
• BinarySearchTree class
  • creating / Creating the BinarySearchTree class
  • insert(key) method / Creating the BinarySearchTree class
  • search(key) method / Creating the BinarySearchTree class
  • inOrderTraverse method / Creating the BinarySearchTree class
  • preOrderTraverse method / Creating the BinarySearchTree class
  • postOrderTraverse method / Creating the BinarySearchTree class
  • min method / Creating the BinarySearchTree class
  • max method / Creating the BinarySearchTree class
  • remove(key) method / Creating the BinarySearchTree class
• binary tree
  • about / Binary tree and binary search tree
• bitwise operators
  • about / Operators
• body tag / JavaScript basics
• Booleans
  • about / Variables
• break statement / Conditional statements
• browser
  • used, for environment setup / The browser is enough
• BST
  • BinarySearchTree class, creating / Creating the BinarySearchTree class
  • about / Creating the BinarySearchTree class
  • working with / More about binary trees
• bubble sort algorithm
  • about / Bubble sort
  • improvement / Improved bubble sort

C

• case clause / Conditional statements
• circular linked list
  • about / Circular linked lists
• circular queue
  • about / The circular queue – Hot Potato
  • example / The circular queue – Hot Potato
• class
  • about / Object-oriented programming
• clear method
  • about / The add method, The remove and clear methods, The clear, size, keys, and getItems methods
• collisions
  • handling, between hash table / Handling collisions between hash tables
  • handling, with separate chaining technique / Separate chaining
  • handling, with linear probing technique / Linear probing
• comparison operators
  • about / Operators
• conditional statements
  • about / Conditional statements
  • if…else construct / Conditional statements
  • switch statement / Conditional statements
  • case clause / Conditional statements
  • break statement / Conditional statements
• connected graph
  • about / Graph terminology
• console.log method
  • about / Variables
• control structures
  • about / Control structures
  • conditional statements / Conditional statements
  • loops / Loops
• custom sorting / Custom sorting
• cycle
  • about / Graph terminology

D

• dates
  • about / Variables
• debugging
  • about / Debugging and tools
• decimal number
  • converting, to binary representation / Decimal to binary
• degree, vertices
  • about / Graph terminology
• delete operator / Operators
• DFS
  • about / Graph traversals, Depth-first search (DFS)
  • exploring / Exploring the DFS algorithm
  • used, for topological sorting / Topological sorting using DFS
• dictionary
  • about / Dictionaries
  • creating / Creating a dictionary
  • set method / The has and set methods
  • has method / The has and set methods
  • remove method / The remove method
  • get method / The get and values methods
  • values method / The get and values methods
  • getItems method / The clear, size, keys, and getItems methods
  • clear method / The clear, size, keys, and getItems methods
  • size method / The clear, size, keys, and getItems methods
  • keys method / The clear, size, keys, and getItems methods
  • Dictionary class, using / Using the Dictionary class
• Dictionary class
  • using / Using the Dictionary class
• difference operation
  • about / Set operations, Set difference
• Dijkstra's algorithm
  • about / Further studies on the shortest paths algorithms
• directed acyclic graph (DAG)
  • about / Topological sorting using DFS
• directed graph
  • about / Directed and undirected graphs
• djb2
  • about / Creating better hash functions
• doubly circular linked list
  • about / Circular linked lists
• doubly linked list
  • about / Doubly 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
• DoublyLinkedList class / Doubly linked lists
  • versus LinkedList class / Doubly linked lists
• do…while loop / Loops

E

• ECMAScript 5.1 / Creating a set
• edges
  • about / Creating the BinarySearchTree class
• elements
  • adding, in arrays / Adding and removing elements
  • removing, from arrays / Adding and removing elements
  • appending, to end of linked list / Appending elements to the end of the linked list
  • removing, from linked list / Removing elements from the linked list
• environment
  • setting up / Setting up the environment
  • setting up, browser used / The browser is enough
  • setting up, web servers (XAMPP) used / Using web servers (XAMPP)
  • setting up, JavaScript (Node.js) used / It's all about JavaScript (Node.js)
• equals operators (== and ===) / The equals operators (== and ===)
• every method / Iterator functions

F

• false value / Truthy and falsy
• filter method / Iterator functions
• Firebug add-on
  • URL, for installing / Setting up the environment
• Floyd-Warshall algorithm
  • about / Further studies on the shortest paths algorithms
• for loop
  • about / Loops
• functions
  • about / Variables, Functions

G

• getHead method
  • implementing / The isEmpty, size, and getHead methods
• getItems method
  • about / The clear, size, keys, and getItems methods
• get method
  • about / The get and values methods
• Google Developer Tools
  • about / The browser is enough
• graph
  • about / Graph terminology
  • terminology / Graph terminology
  • edges / Graph terminology
  • nodes / Graph terminology
  • vertices / Graph terminology
  • undirected graph / Directed and undirected graphs
  • directed graph / Directed and undirected graphs
  • representing / Representing a graph
• Graph class
  • creating / Creating the Graph class
• graph representation
  • adjacency matrix / The adjacency matrix
  • adjacency list / The adjacency list
  • incidence matrix / The incidence matrix
• graph traversals
  • about / Graph traversals
  • BFS / Graph traversals, Breadth-first search (BFS)
  • DFS / Graph traversals, Depth-first search (DFS)

H

• Hanoi tower examples / Decimal to binary
• has(value) method
  • about / The has (value) method
• hash functions
  • creating / Creating better hash functions
• hashing
  • about / The hash table
• hash set
  • versus hash table / Hash table versus hash set
• hash table
  • about / The hash table
  • creating / Creating a hash table
  • HashTable class, using / Using the HashTable class
  • versus hash set / Hash table versus hash set
  • collisions, handling between / Handling collisions between hash tables
• HashTable class
  • using / Using the HashTable class
• has method
  • about / The has and set methods
• head tag / JavaScript basics
• Heap tree
  • URL / More about binary trees
• Hot Potato game
  • about / The circular queue – Hot Potato
  • simulation, implementing / The circular queue – Hot Potato

I

• if…else construct / Conditional statements
• in-order traversal
  • about / In-order traversal
• incidence matrix
  • about / The incidence matrix
• indexOf method / Searching
  • implementing / The indexOf method
  • about / Searching algorithms
• insertion sort algorithm
  • about / Insertion sort
• insertNode function / Inserting a key in a tree
• intersection operation
  • about / Set operations, Set intersection
• isEmpty method
  • implementing / The isEmpty, size, and getHead methods
• iterator functions
  • about / Iterator functions
  • every / Iterator functions
  • some / Iterator functions
  • map / Iterator functions
  • filter / Iterator functions
  • reduce / Iterator functions

J

• JavaScript (Node.js)
  • used, for environment setup / It's all about JavaScript (Node.js)
• JavaScript array methods
  • about / References for JavaScript array methods
  • concat / References for JavaScript array methods
  • every / References for JavaScript array methods
  • filter / References for JavaScript array methods
  • forEach / References for JavaScript array methods
  • join / References for JavaScript array methods
  • indexOf / References for JavaScript array methods
  • lastIndexOf / References for JavaScript array methods
  • map / References for JavaScript array methods
  • reverse / References for JavaScript array methods
  • slice / References for JavaScript array methods
  • some / References for JavaScript array methods
  • sort / References for JavaScript array methods
  • toString / References for JavaScript array methods
  • valueOf / References for JavaScript array methods
• JavaScript basics
  • about / JavaScript basics
  • variables / Variables
  • operators / Operators
  • true value / Truthy and falsy
  • false value / Truthy and falsy
  • equals operators (== and ===) / The equals operators (== and ===)
• JavaScript garbage collector
  • reference link / Removing elements from the linked list
• join method / Outputting the array into a string

K

• key
  • inserting, in tree / Inserting a key in a tree
• keys method
  • about / The clear, size, keys, and getItems methods

L

• lastIndexOf method / Searching
• leaf node
  • removing / Removing a leaf node
• linear probing
  • about / Linear probing
  • put method / The put method
  • get method / The get method
  • remove method / The remove method
• linked list
  • creating / Creating a linked list
  • elements, appending to end of / Appending elements to the end of the linked list
  • elements, removing from / Removing elements from the linked list
  • element, inserting at any position / Inserting an element at any position
• LinkedList class
  • about / Creating a linked list
  • versus DoublyLinkedList class / Doubly linked lists
• Lo-Dash library
  • URL / Outputting the array into a string
• logical operators
  • about / Operators
• loops
  • about / Loops
  • for loop / Loops
  • while loop / Loops
  • do…while loop / Loops

M

• map
  • about / Dictionaries
• map method / Iterator functions
• merge function
  • about / Merge sort
• merge sort algorithm
  • about / Merge sort
• methods, LinkedList class
  • append(element) / Creating a linked list, Appending elements to the end of the linked list
  • insert(position, element) / Creating a linked list, Inserting an element at any position
  • remove(element) / Creating a linked list, Removing elements from the linked list
  • indexOf(element) / Creating a linked list, The indexOf method
  • removeAt(position) / Creating a linked list
  • isEmpty() / Creating a linked list, The isEmpty, size, and getHead methods
  • size() / Creating a linked list, The isEmpty, size, and getHead methods
  • toString() / Creating a linked list, The toString method
• methods, queue
  • enqueue(element(s)) / Creating a queue
  • dequeue() / Creating a queue
  • front() / Creating a queue
  • isEmpty() / Creating a queue
  • size() / Creating a queue
• methods, stack
  • push(element(s)) / Creating a stack
  • pop() / Creating a stack
  • peek() / Creating a stack
  • isEmpty() / Creating a stack
  • clear() / Creating a stack
  • size() / Creating a stack
• minNode method
  • about / Searching for minimum and maximum values
• multi-dimensional arrays
  • about / Two-dimensional and multi-dimensional arrays
• multiple arrays
  • joining / Joining multiple arrays

N

• node
  • removing / Removing a node
  • leaf node, removing / Removing a leaf node
  • removing, with left/right child / Removing a node with a left or right child
  • removing, with with two children / Removing a node with two children
• Node.js
  • URL / It's all about JavaScript (Node.js)
• null
  • about / Variables
• numbers
  • about / Variables

O

• object
  • about / Object-oriented programming
• object-oriented programming (OOP)
  • about / Object-oriented programming
• objects
  • about / Variables
• operators
  • about / Operators
  • arithmetic / Operators
  • assignment / Operators
  • comparison / Operators
  • logical / Operators
  • bitwise / Operators
  • typeof / Operators
  • delete / Operators

P

• partition process, quick sort algorithm
  • about / Quick sort, The partition process
• path
  • about / Graph terminology
• pop method / Creating a stack
• post-order traversal
  • about / Post-order traversal
• pre-order traversal
  • about / Pre-order traversal
• printTitle function / Object-oriented programming
• priority queue
  • about / The priority queue
  • example / The priority queue
• push method / Creating a stack

Q

• queue
  • creating / Creating a queue
• Queue class
  • about / The complete Queue class
  • using / Using the Queue class
• quick sort algorithm
  • about / Quick sort
  • partition process / The partition process
  • executing / Quick sort in action

R

• Red-Black tree
  • about / More about binary trees
  • URL / More about binary trees
• reduce method / Iterator functions
• regular expressions
  • about / Variables
• remove method
  • about / The add method, The remove and clear methods, The remove method
• return statement / Functions
• root / Trees terminology
• rooted trees
  • about / Exploring the DFS algorithm

S

• script tag / JavaScript basics
• searching algorithms
  • about / Searching algorithms
  • sequential search / Sequential search
  • binary search / Binary search
• searching methods
  • about / Searching and sorting
  • indexOf method / Searching
  • lastIndexOf method / Searching
• search method
  • about / Searching algorithms
• selection sort algorithm
  • about / Selection sort
• separate chaining
  • about / Separate chaining
  • put method / The put method
  • get method / The get method
  • remove method / The remove method
• sequential search
  • about / Sequential search
• set
  • creating / Creating a set
  • has(value) method / The has (value) method
  • add method / The add method
  • remove method / The remove and clear methods
  • clear method / The remove and clear methods
  • size method / The size method
  • values method / The values method
  • Set class, using / Using the Set class
• Set class
  • URL, for implementation / Creating a set
  • using / Using the Set class
• set method
  • about / The has and set methods
• set operations
  • union / Set operations, Set union
  • intersection / Set operations, Set intersection
  • difference / Set operations, Set difference
  • subset / Set operations, Subset
• shortest paths
  • searching, BFS used / Finding the shortest paths using BFS
• shortest paths algorithms
  • Dijkstra's algorithm / Further studies on the shortest paths algorithms
  • Bellman-Ford algorithm / Further studies on the shortest paths algorithms
  • A* search algorithm / Further studies on the shortest paths algorithms
  • Floyd-Warshall algorithm / Further studies on the shortest paths algorithms
• simple path
  • about / Graph terminology
• size method
  • implementing / The isEmpty, size, and getHead methods
  • about / The size method, The clear, size, keys, and getItems methods
• some method / Iterator functions
• sorting algorithms
  • about / Sorting algorithms
  • bubble sort / Bubble sort
  • selection sort / Selection sort
  • insertion sort / Insertion sort
  • merge sort / Merge sort
  • quick sort / Quick sort
• sorting method
  • about / Searching and sorting
  • custom sorting / Custom sorting
• sparse graphs
  • about / The adjacency matrix
• stack
  • creating / Creating a stack
• Stack class
  • additional helper methods, implementing / Creating a stack
  • implementing / The complete Stack class
  • using / Using the Stack class
• string
  • array, outputting into / Outputting the array into a string
• strings
  • about / Variables
  • sorting / Sorting strings
• strongly connected graph
  • about / Directed and undirected graphs
• Sublime Text
  • about / Debugging and tools
  • URL / Debugging and tools
• subset operation
  • about / Set operations, Subset
• swapQuickStort function
  • about / The partition process
• switch statement / Conditional statements

T

• toNumber method / The equals operators (== and ===)
• tools
  • about / Debugging and tools
  • Aptana / Debugging and tools
  • WebStorm / Debugging and tools
  • Sublime Text / Debugging and tools
• topological sorting
  • with DFS / Topological sorting using DFS
  • about / Topological sorting using DFS
• toPrimitive method / The equals operators (== and ===)
• toString method / Outputting the array into a string
  • implementing / The toString method
• traversing
  • about / Tree traversal
• tree
  • terminology / Trees terminology
  • binary tree / Binary tree and binary search tree
  • BST / Binary tree and binary search tree
  • key, inserting / Inserting a key in a tree
  • values, searching / Searching for values in a tree
  • minimum values, searching / Searching for minimum and maximum values
  • maximum values, searching / Searching for minimum and maximum values
  • specific value, searching / Searching for a specific value
  • node, removing / Removing a node
• tree traversal
  • about / Tree traversal
  • in-order traversal / In-order traversal
  • pre-order traversal / Pre-order traversal
  • post-order traversal / Post-order traversal
• true value / Truthy and falsy
• two-dimensional array
  • about / Two-dimensional and multi-dimensional arrays
• typeof operator / Operators

U

• undefined
  • about / Variables
• Underscore library
  • URL / Outputting the array into a string
• undirected graph
  • about / Directed and undirected graphs
• union operation
  • about / Set operations, Set union
• unweighted graph
  • about / Directed and undirected graphs

V

• values method
  • about / The values method, The get and values methods
• variables
  • about / Variables
• variable scope
  • about / Variable scope
• visitor pattern
  • URL / In-order traversal

W

• web servers (XAMPP)
  • used, for environment setup / Using web servers (XAMPP)
• WebStorm
  • about / Debugging and tools
  • URL / Debugging and tools
• weighted graph
  • about / Directed and undirected graphs
• while loop
  • about / Loops

X

• XAMPP
  • URL, for installing / Using web servers (XAMPP)