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

The Bellman-Ford Algorithm (Part II) – Negative Weight Cycles

Consider the graph shown in the following figure:

Figure 7.2: Graph with a negative weight cycle

The edges highlighted in red indicate a negative weight cycle or a cycle in the graph where the combined edge weights produce a negative sum. In such a situation, this cycle would be considered repeatedly, and the final results would be skewed.

For the sake of comparison, consider a graph with only positive edge weights. A cycle in such a graph would never be considered in the solution because the shortest distance to the first node in the cycle would have been found already. To demonstrate this, imagine that the edge weight between nodes B and D in the preceding figure is positive. Starting from node A, the first iteration through the edges would determine that the shortest distance to node B is equal to 3. After two more iterations, we would also know the shortest distance from A to C (A —> B &...

Previous Section
End of Section 5
Next Section