Book Image

C++ Data Structures and Algorithm Design Principles

By : John Carey, Anil Achary, Shreyans Doshi, Payas Rajan
Book Image

C++ Data Structures and Algorithm Design Principles

By: John Carey, Anil Achary, Shreyans Doshi, Payas Rajan

Overview of this book

C++ is a mature multi-paradigm programming language that enables you to write high-level code with a high degree of control over the hardware. Today, significant parts of software infrastructure, including databases, browsers, multimedia frameworks, and GUI toolkits, are written in C++. This book starts by introducing C++ data structures and how to store data using linked lists, arrays, stacks, and queues. In later chapters, the book explains the basic algorithm design paradigms, such as the greedy approach and the divide-and-conquer approach, which are used to solve a large variety of computational problems. Finally, you will learn the advanced technique of dynamic programming to develop optimized implementations of several algorithms discussed in the book. By the end of this book, you will have learned how to implement standard data structures and algorithms in efficient and scalable C++ 14 code.

Related Content you might be interested in

Current Title:

Small book image
C++ Data Structures and Algorithm Design Principles
John Carey | Anil Achary | Shreyans Doshi | Payas Rajan
Oct, 2019 | 626 pages
Small book image
Beginning Java Data Structures and Algorithms
James Cutajar
Jul, 2018 | 202 pages
Small book image
PHP 7 Data Structures and Algorithms
Mizanur Rahman
May, 2017 | 340 pages
Small book image
Hands-On Data Structures and Algorithms with Python – Third Edition
Dr Basant Agarwal
Jul, 2022 | 496 pages
Table of Contents (11 chapters)
About the Book
About the Book
About the Authors
Learning Objectives
Audience
Approach
Hardware Requirements
Software Requirements
Installation and Setup
Installing the Code Bundle
Additional Resources
Free Chapter
1
1. Lists, Stacks, and Queues
1. Lists, Stacks, and Queues
Introduction
Contiguous Versus Linked Data Structures
std::array
std::vector
std::forward_list
Iterators
std::list
std::deque – Special Version of std::vector
Container Adaptors
Benchmarking
Summary
2
2. Trees, Heaps, and Graphs
2. Trees, Heaps, and Graphs
Introduction
Non-Linear Problems
Tree – It's Upside Down!
Variants of Trees
Heaps
Graphs
Summary
3
3. Hash Tables and Bloom Filters
3. Hash Tables and Bloom Filters
Introduction
Hash Tables
Collisions in Hash Tables
C++ Hash Tables
Bloom Filters
Summary
4
4. Divide and Conquer
4. Divide and Conquer
Introduction
Binary Search
Understanding the Divide-and-Conquer Approach
Sorting Using Divide and Conquer
C++ Standard Library Tools for Divide and Conquer
Dividing and Conquering at a Higher Abstraction Level – MapReduce
Summary
5
5. Greedy Algorithms
5. Greedy Algorithms
Introduction
Basic Greedy Algorithms
The Knapsack Problem(s)
The Vertex Coloring Problem
Summary
6
6. Graph Algorithms I
6. Graph Algorithms I
Introduction
The Graph Traversal Problem
Prim's MST Algorithm
Dijkstra's Shortest Path Algorithm
Summary
7
7. Graph Algorithms II
7. Graph Algorithms II
Introduction
Revisiting the Shortest Path Problem
The Bellman-Ford Algorithm
The Bellman-Ford Algorithm (Part II) – Negative Weight Cycles
Johnson's Algorithm
Strongly Connected Components
Kosaraju's Algorithm
Choosing the Right Approach
Summary
8
8. Dynamic Programming I
8. Dynamic Programming I
Introduction
What Is Dynamic Programming?
Memoization – The Top-Down Approach
Tabulation – the Bottom-Up Approach
Subset Sum Problem
Dynamic Programming on Strings and Sequences
Activity 21: Melodic Permutations
Summary
9
9. Dynamic Programming II
9. Dynamic Programming II
Introduction
An Overview of P versus NP
Reconsidering the Subset Sum Problem
The Knapsack Problem
Graphs and Dynamic Programming
Summary
Appendix
Appendix
Chapter 1: Lists, Stacks, and Queues
Chapter 2: Trees, Heaps, and Graphs
Chapter 3: Hash Tables and Bloom Filters
Chapter 4: Divide and Conquer
Chapter 5: Greedy Algorithms
Chapter 6: Graph Algorithms I
Chapter 7: Graph Algorithms II
Chapter 8: Dynamic Programming I
Chapter 9: Dynamic Programming II

C++ Hash Tables

As we mentioned previously, the lookup operation is quite frequent in most applications. However, we may not always encounter positive integers, which are quite easy to hash. You are likely to encounter strings most of the time. Consider the example of an English language dictionary that we considered earlier. We can store the dictionary data by using the words as keys and the word definitions as the values. Another example is the hospital records database we considered in Chapter 1, Lists, Stacks, and Queues, where the patients' names may be used as keys, and other related information could be stored as values.

The simple modulo function we used earlier to calculate the hash values of integers does not work for strings. An easy option is to calculate the modulo of the sum of the ASCII values of all the characters. However, all the permutations of characters in a string would be quite vast, and this would create a lot of collisions.

C++ provides a function called std:...

Previous Section
End of Section 5
Next Section