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

Summary

We covered three major graph problems in this chapter: first, the graph traversal problem for which two solutions were introduced, breadth-first search (BFS) and depth-first search (DFS). Second, we revisited the minimum spanning tree (MST) problem and solved it using Prim's algorithm. We also compared it with Kruskal's algorithm and discussed the conditions under which one should be preferred over the other. Finally, we introduced the single-source shortest path problem, which finds a minimum-cost shortest path in graphs, and covered Dijkstra's shortest path algorithm.

However, Dijkstra's algorithm only works for graphs with positive edge weights. In the next chapter, we shall seek to relax this constraint and introduce a shortest path algorithm that can handle negative edge weights. We shall also generalize the shortest path problem to find the shortest paths between all the pairs of vertices in graphs.

Previous Section
End of Chapter 6
Next Chapter