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

Graphs and Dynamic Programming

In this section, we have discussed advanced graph algorithms and DP as distinctly different topics, but as is often the case, they can be used concurrently depending on the type of problem we are trying to solve and the nature of the graph. Several problems commonly associated with graphs are identified as NP-complete (graph coloring and the vertex cover problem, to name two examples) and can, under the right circumstances, be solved with dynamic programming. However, most of these topics are outside the scope of this book (and are actually worthy of having entire books dedicated specifically to their analysis).

However, one problem in graph theory is particularly well suited to the DP approach, and fortunately, it is one we are already very familiar with: the shortest-path problem. In fact, in Chapter 7, Graph Algorithms II, we actually discussed an algorithm that's commonly categorized under the DP umbrella, despite the fact that we never identified it...

Previous Section
End of Section 6
Next Section