Index

A

Access queue

Access stacks

Algorithm

Boyer–Moore string search

KMP string search

Rabin–Karp search

AND operator

Arrays

access

deletion

exercises

matrix rotation

path finding

spiral print

tic-tac-toe check

functional array methods

helper functions

insertion

iteration

K-sorted arrays

largest value

median of two sorted arrays

multidimensional arrays

.slice() function

smallest value

Ascending-Order sort

.atob() function

AVL trees

deletion

double rotation

rotate left right

rotate right left

insertion

result

single rotation

rotate left

rotate right

tree balancing

B

Base64 encoding

Big-O notation

coefficient rule

complexities

fundamental rules

master theorem

O(n) algorithm

polynomial rule

product rule

recurrence relations

sum rule

Binary heap

max-heap

percolation

bubble up/down

implementation

max-heap structure

min-heap structure

Binary search algorithm

Binary search trees (BSTs)

deletion

insertion

nth distance, root

result

search

Binary tree

Bioinformatics

Bit manipulation

Bitwise operators

AND

left shift

NOT

OR

right shift

XOR

zero-fill right shift

Bottom variable declaration

Boyer–Moore string search

Breadth-first search (BFS)

end node

graph

level-order traversal

search algorithm

start node

undirected graph

btoa() function

Bubble sorting

C

Caching

LFU ( see Least frequently used (LFU) caching)

LRU ( see Least recently used (LRU) caching)

spatial locality

temporal locality

Coefficient rule

Coin change

Constructor

Count sort

Cyclical graph

D

Deletion, queue

Deletion stacks

Dense graph

Depth-first search (DFS)

graph

post-order tree traversal

time complexity

dequeuing

Descending-Order sort

Dijkstra’s algorithm

_extractMin method

fibonacci heap

shortest path

stage 1

stage 2

Directed graphs

adding vertex

edges property

origin vertex

removing vertex

Divide-and-conquer method

Doubly linked list

deletion, head

deletion, tail

insertion, head

insertion, tail

nodes

search

Dynamic programming (DP)

coin change

edit (Levenshtein) distance

Knapsack problem

longest common subsequence

motivations

rules

E

Edit (Levenshtein) distance

Encoding

Encryption

enqueuing

F

Fibonacci sequence

First in, first out (FIFO)

Functional array methods

filter

map

reduce

G

Graphs

applications

cyclical

definition

degree of vertex

dense

edge

sparse

vertex

weighted edges

Graph traversal

BFS

DFS

techniques

H

Hashtables

get() function

implementation

double-hashing

linear probing

quadratic probing

localStorage

put() function

technique

prime numbers

probing

rehashing/double-hashing

Heaps

binary heap ( see Binary heap)

indices

max-heap

complete implementation

sorting

min-heap

complete implementation

sorting

node index summary

operations summary

relationship

sorting

ascending-order

descending-order

Heap sort

Helper functions

.concat()

.length property

.slice(begin,end)

.splice(begin,size,element1,element2…)

spread operator

I

In-order traversal

Insertion

queue

sort

stacks

insideIf variable

isSuperSet function

Iteration

forEach()

for ( in )

for ( of )

for (variables, condition, modification)

J

Jagged array

JavaScript

block scope

functional scope

global scope

infinity

integer division

maximums

minimums

Number.EPSILON

object property

objects

primality test

true/false checking

=== vs == type

K

Knapsack problem

Knuth–Morris–Pratt string search

L

Last in, first out (LIFO)

Least frequently used (LFU) caching

doubly linked list

get implementation

hash tables

hybrid systems

set implementation

usage

Least recently used (LRU) caching

doubly linked list

get implementation

set implementation

.length property

Level-order traversal

Linear probing

Linear search

Linked list

Longest common subsequence

M

Matrix rotation

Max-Heap

Memoization

Memory leaks

delete operator

DOM elements

global window object

Mergesort

Min-Heap

root node

structure

Mirror trees

Multidimensional arrays

N

NOT operator

Number operations

addition

division

multiplication

subtraction

Number system

O

Optimal substructure

OR operator

P

Pascal’s triangle

Path finding

Peek queue

Peek stacks

Polynomial rule

.pop() method

Post-order traversal

Pre-order traversal

Primality test

Prime factorization

Prime number hashing

Probing hashing technique

Product rule

Prototypal inheritance

Public-key encryption

.push(element) method

Q

Quadratic probing

Queue

access

deletion

FIFO

insertion

peek

search

Quickselect

Quicksort

R

Rabin–Karp search

application

fingerprint

Random number generation

Recursion

base case

divide-and-conquer method

exercises

decimal to binary conversion

flatten an object

palindrome

permutations, array

fibonacci sequence

iterative solution

recursive solution

tail recursion

Pascal’s triangle

Recursive call stack memory

Recursive functions

Regular expressions

regexes

any numeric characters

floating numeric characters

only alphanumeric characters

only numeric characters

query string

.replace(string, replaceString)

Root node

RSA encryption

S

Searching

binary

linear

stacks

Search queue

Secure sockets layer (SSL)

Selection sorting

Set

definition

operation

utility functions

.shift() method

Singly linked list

deletion, head

deletion, value

head

insertion

node removal

reverse

search

.slice() function

Sortable stack

Sorting

bubble

count

insertion

mergesort

quickselect

quicksort

selection

built-in sort() method

Sparse graph

Spatial locality

Spiral print

Stack overflow

Stacks

access

deletion

insertion

LIFO

peek

search

String primitive

access

comparison

decomposition

replace

search

String shortening

Sum rule

T

Tail recursive function

Temporal locality

Tic-tac-toe check

Topological sort

Tree traversal

in-order

level-order

post-order

pre-order

Trie (prefix Tree)

U

Unbalanced binary search tree

Undirected graphs

adjacency list

adjacency matrix

edges and vertices

adding

removing

nondirectional edges

V, W

Variable

types

Variable hoisting

X, Y, Z

XOR operator