Index
A
- abstract / Developing abstract data types
- abstract data type (ADT)
- about / Developing abstract data types
- developing / Developing abstract data types
- C++ classes, applying to build user-defined ADTs / Applying C++ classes to build user-defined ADTs
- templates, playing with / Playing with templates
- function templates / Function templates
- class templates / Class templates
- Standard Template Library / Standard Template Library
- algorithm
- analyzing / Analyzing the algorithm
- asymptotic analysis / Asymptotic analysis
- worst case analysis / Worst, average, and best cases
- average case analysis / Worst, average, and best cases
- best case analysis / Worst, average, and best cases
- Big-O / Big Theta, Big-O, and Big Omega
- Big Theta / Big Theta, Big-O, and Big Omega
- Big Omega / Big Theta, Big-O, and Big Omega
- recursive method / Recursive method
- amortized analysis / Amortized analysis
- technical requirements / Technical requirements
- Greedy algorithms / Greedy algorithms
- divide and conquer algorithms / Divide and conquer algorithms
- dynamic рrоgrаmmіng / Dynamic programming
- brute-force algorithms / Brute-force algorithms
- rаndоmіzеd algorithm / Randomized algorithms
- backtracking algorithms / Backtracking algorithms
- amortized analysis / Amortized analysis
- anagram
- creating / Rearranging a word to create an anagram
- array / Getting closer to an array
- asymptotic analysis / Asymptotic analysis
- average case analysis / Worst, average, and best cases
B
- back / Building a Queue ADT
- backtracking algorithms
- about / Backtracking algorithms
- furniture, arranging in new house / Arranging furniture in a new house
- tic-tac-toe, playing / Playing tic-tac-toe
- balanced BST (AVL) ADT
- building / Building a balanced BST (AVL) ADT
- nodes, rotating / Rotating nodes
- key, inserting / Inserting a new key
- key, removing / Removing a given key
- implementing / Implementing AVL ADT
- begin() / Using std::string for more flexibility features
- best case analysis / Worst, average, and best cases
- Big-O / Big Theta, Big-O, and Big Omega
- Big Omega / Big Theta, Big-O, and Big Omega
- Big Theta / Big Theta, Big-O, and Big Omega
- binary heap ADT
- building / Building a binary heap ADT
- empty state, checking / Checking if the heap is empty
- element, inserting / Inserting a new element into the heap
- element's maximum value, fetching / Fetching the element's maximum value
- maximum element, removing / Removing the maximum element
- implementing, as priority queue / Implementing a binary heap as a priority queue
- binary search algorithm
- about / Binary search
- developing / Developing binary search algorithm
- implementing / Implementing binary search algorithm
- binary search tree ADT
- building / Building a binary search tree ADT
- key, inserting / Inserting a new key into a BST
- traversing / Traversing a BST in order
- key existence, searching / Finding out whether a key exists in a BST
- minimum key value, retrieving / Retrieving the minimum and maximum key values
- maximum key value, retrieving / Retrieving the minimum and maximum key values
- key successor, searching / Finding out the successor of a key in a BST
- predecessor, searching of key / Finding out the predecessor of a key in a BST
- node, removing based on given key / Removing a node based on a given key
- implementing / Implementing the BST ADT
- binary string
- constructing / Constructing a string from binary digits
- decimal, converting / Converting decimal to binary string
- converting, to decimal / Converting binary string to decimal
- binary tree ADT
- building / Building a binary tree ADT
- brace-initialization / Defining the variables using fundamental data types
- brute-force algorithms
- about / Brute-force algorithms
- brute-force search and sort / Brute-force search and sort
- strength / Strengths and weaknesses of brute-force algorithms
- weaknesses / Strengths and weaknesses of brute-force algorithms
- bubble sort algorithm / Bubble sort
C
- C++
- about / Introduction to basic C++
- code, creating / Creating your first code in C++
- code development experience, enhancing with IDE / Enhancing code development experience with IDE
- variables, defining with fundamental data types / Defining the variables using fundamental data types
- code flow, controlling / Controlling the flow of the code
- conditional statement / Conditional statement
- loop statement / Loop statement
- variable capability, leveraging with advanced data types / Leveraging the variable capability using advanced data types
- CAPTCHA / Applications of randomized algorithms
- class templates / Class templates
- collision / Collision handling
- collision handling technique
- separate chaining / Collision handling
- open addressing / Collision handling
- conditional statement / Conditional statement
- copy initialization / Defining the variables using fundamental data types
- counting sort algorithm / Counting sort
D
- data types
- used, for leveraging variable capability / Leveraging the variable capability using advanced data types
- Dequeue ADT
- building / Building a Deque ADT
- value, fetching / Fetching a value from a Deque
- element, enqueuing / Enqueueing an element into the Deque ADT
- element, dequeuing / Dequeuing an element from the Deque ADT
- consuming / Consuming the Deque ADT
- direct initialization / Defining the variables using fundamental data types
- divide and conquer algorithms
- about / Divide and conquer algorithms
- Binary Search / Divide and conquer algorithms
- Quicksort / Divide and conquer algorithms
- Merge sort / Divide and conquer algorithms
- selection problems, solving / Solving selection problems
- matrix multiplication calculations, solving / Solving matrix multiplication calculations
- double-ended queue (dequeue) / Building a Queue ADT, Building a Deque ADT
- Doubly Linked List
- building / Building the Doubly Linked List ADT
- Node data type, refactoring / Refactoring the Node<T> data type
- operations, refactoring / Refactoring several operations in the LinkedList ADT
- element, removing / Removing an element
- element, inserting / Inserting an element
- consuming / Consuming the DoublyLinkedList ADT
- dynamic рrоgrаmmіng
- about / Dynamic programming
- Fibonacci numbers / Fibonacci numbers
- coin-change problem, solving / Dynamic programming and the coin-change problem
E
- end() / Using std::string for more flexibility features
- enqueue / Building a Queue ADT
- enum (enumeration) / Leveraging the variable capability using advanced data types
- exponential search algorithm
- about / Exponential search
- developing / Developing exponential search algorithm
- ExponentialSearch() function, invoking / Invoking the ExponentialSearch() function
F
- First In First Out (FIFO) / Building a Queue ADT
- front / Building a Queue ADT
- function object / Standard Template Library
- function templates / Function templates
- functor / Standard Template Library
- fundamental data types
- used, for defining variables / Defining the variables using fundamental data types
G
- getline() / Using std::string for more flexibility features
- Greedy аlgоrіthmѕ
- about / Greedy algorithms
- coin-changing problem, solving / Solving the coin-changing problem
- Huffman coding algorithm, applying / Applying the Huffman coding algorithm
H
- hash function / Big data in small cells
- HashTable ADT
- applying, separate chaining technique used / Applying a HashTable ADT using a separate chaining technique in the code
- applying, linear probing technique used / Applying an HashTable ADT using a linear probing technique in the code
- hash tables
- technical requirement / Technical requirement
- about / Getting acquainted with hash tables
- data type, constructing / Big data in small cells
- data, storing in / Storing data in a hash table
- collision handling / Collision handling
- Huffman coding algorithm
- applying / Applying the Huffman coding algorithm
- Huffman tree
- building / Applying the Huffman coding algorithm
I
- insertion sort / Insertion sort
- integrated development environment (IDE)
- code development experience, enhancing / Enhancing code development experience with IDE
- interface / Applying C++ classes to build user-defined ADTs
- interpolation search
- about / Interpolation search
- developing / Developing interpolation search algorithm
- applying / Applying interpolation search algorithm
J
- jump search algorithm
- about / Jump search
- developing / Developing jump search algorithm
- applying / Applying jump search algorithm
K
- keyword / Function templates
L
- Last In First Out (LIFO) / Building a Stack ADT
- linear probing technique
- used, for applying HashTable ADT / Applying an HashTable ADT using a linear probing technique in the code
- linear search algorithm
- about / Linear search
- developing / Developing a linear search algorithm
- implementing / Implementing the linear search algorithm
- linked list
- about / Building a Singly Linked List ADT
- applying, with STL / Applying List and LinkedList using STL
- list
- about / Building a List ADT
- applying, with STL / Applying List and LinkedList using STL
- List ADT
- building / Building a List ADT
- item, fetching / Fetching an item in the List
- item, inserting into List class / Inserting an item into the List ADT
- index, searching from selected item / Finding out the index of a selected item in the List ADT
- item, removing from List class / Removing an item from the List ADT
- consuming / Consuming a List ADT
- loop statement / Loop statement
M
- merge sort / Merge sort
N
- node / Introduction to node
O
- one-dimensional array / Getting closer to an array
- open addressing technique
- implementing / Implementing the open addressing technique
- linear probing / Implementing the open addressing technique
- quadratic probing / Implementing the open addressing technique
- double hashing / Implementing the open addressing technique
- Insert() operation, developing / Developing the Insert() operation
- Search() operation, developing / Developing a Search() operation
- Remove() operation, developing / Developing the Remove() operation
- IsEmpty() operation, developing / Developing an IsEmpty() operation
- PrintHashTable() operation, developing / Developing a PrintHashTable() operation
- linear probing technique, used for applying HashTable ADT / Applying an HashTable ADT using a linear probing technique in the code
P
- palindrome
- detecting / Detecting whether a word is a palindrome
- partitioning / Quick sort
- pattern / Pattern searching
- pattern searching / Pattern searching
- pivot / Quick sort
- pop_back() / Using std::string for more flexibility features
- power set / Generating subsequences from a string
- predecessor
- about / Finding out the successor of a key in a BST
- searching, of key in BST / Finding out the predecessor of a key in a BST
- pruning / Arranging furniture in a new house
- push_back() / Using std::string for more flexibility features
Q
- Queue ADT
- building / Building a Queue ADT
- value, obtaining / Getting a value from Queue ADT
- element, inserting / Inserting an element into the Queue ADT
- element, removing / Removing an element from the Queue ADT
- consuming / Consuming the Queue ADT
- quick sort algorithm / Quick sort
R
- radix sort algorithm / Radix sort
- rbegin() / Using std::string for more flexibility features
- recursive method / Recursive method
- Regular Expression (RegEx) / Pattern searching
- rend() / Using std::string for more flexibility features
- rаndоmіzеd algorithm
- about / Randomized algorithms
- rаndоm algоrіthm classification / Rаndоm algorіthm classification
- Las Vegas / Rаndоm algorіthm classification
- Monte Carlo / Rаndоm algorіthm classification
- random number generators / Random number generators
- applications / Applications of randomized algorithms
- α–β рrunіng / Playing tic-tac-toe
S
- selection sort / Selection sort
- separate chaining technique
- about / Implementing a separate chaining technique
- implementing / Implementing a separate chaining technique
- hash key, generating / Generating a hash key
- Insert() operation, developing / Developing an Insert() operation
- Search() operation, developing / Developing a Search() operation
- Remove() operation, developing / Developing a Remove() operation
- IsEmpty() operation, developing / Developing an IsEmpty() operation
- used, for applying HashTable ADT / Applying a HashTable ADT using a separate chaining technique in the code
- Singly Linked List
- building / Building a Singly Linked List ADT
- item, fetching in LinkedList class / Fetching an item in the LinkedList class
- item, inserting in LinkedList class / Inserting an item in the LinkedList class
- index, obtaining of selected item / Getting the index of the selected item in the LinkedList
- item, removing from LinkedList class / Removing an item from the LinkedList ADT
- LinkedList ADT, consuming / Consuming the LinkedList ADT
- size() / Using std::string for more flexibility features
- skewed left / Building a binary search tree ADT
- skewed right BST / Building a binary search tree ADT
- Stack ADT
- building / Building a Stack ADT
- item value, fetching / Fetching the item's value in the Stack ADT
- pushing / Pushing the items of the Stack ADT
- popping / Popping the items from the Stack ADT
- consuming / Consuming a Stack ADT
- example / Another example of Stack ADT implementation
- Standard Template Library (STL)
- about / Standard Template Library, Using std::string for more flexibility features
- used, for applying List / Applying List and LinkedList using STL
- used, for applying LinkedList / Applying List and LinkedList using STL
- std list / std::list
- std vector / std::vector
- string
- about / String in C++
- constructing, as character array / Constructing a string using character array
- std string, using / Using std::string for more flexibility features
- sublist search algorithm
- about / Sublist search
- developing / Designing sublist search algorithm
- performing / Performing sublist search algorithm
- subsequence string
- about / Subsequence string
- subsequences, generating from string / Generating subsequences from a string
- checking / Checking whether a string is a subsequence of another string
- successor
- searching, in BST / Finding out the successor of a key in a BST
T
- ternary search algorithm
- about / Ternary search
- developing / Developing ternary search algorithm
- applying / Applying the ternary search algorithm
- tic-tac-toe
- playing / Playing tic-tac-toe
- transposition table / Playing tic-tac-toe
- tеrmіnаl position / Playing tic-tac-toe
U
- user-defined ADTs
- building, by C++ classes application / Applying C++ classes to build user-defined ADTs
V
- variables
- defining, with fundamental data types / Defining the variables using fundamental data types
- leveraging, with advanced data types / Leveraging the variable capability using advanced data types
- vector / std::vector
W
- word
- playing with / Playing with words
- rearranging, to create anagram / Rearranging a word to create an anagram
- palindrome, detecting / Detecting whether a word is a palindrome
- worst case analysis / Worst, average, and best cases