# What this book covers

*Chapter 1*, *Python Data Types and Structures*, introduces the basic data types and structures in Python. It will provide an overview of several built-in data structures available in Python that are pivotal for understanding the internals of data structures.

*Chapter 2*, *Introduction to Algorithm Design*, provides details about algorithm design issues and techniques. This chapter will compare different analyzing algorithms via running time and computation complexity, which will tell us which ones perform better than others for a given problem.

*Chapter 3*, *Algorithm Design Techniques and Strategies*, covers various important data structure design paradigms such as greedy algorithms, dynamic programming, divide-and-conquer. We will learn to create data structures via a number of primary principles, such as robustness, adaptability and reusability, and learn to separate structure from a function.

*Chapter 4*, *Linked Lists*, covers linked lists, which are one of the most common data structures and are often used to implement other structures, such as stacks and queues. In this chapter, we describe linked lists, their operation, and implementation. We compare their behavior to arrays and discuss the relative advantages and disadvantages of each.

*Chapter 5*, *Stacks and Queues*, describes stack and queue data structures in detail. It also discusses the behavior and demonstrates some implementations of these linear data structures. We give examples of typical real-life example applications.

*Chapter 6*, *Trees*, considers how trees form the basis of many of the most important advanced data structures. In this chapter we look at how to implement a binary tree. We will examine how to traverse trees and retrieve and insert values.

*Chapter 7*, *Heaps and Priority Queues*, looks into priority queues as important data structures and shows how to implement them using heap.

*Chapter 8*, *Hash Tables*, describes symbol tables, gives some typical implementations, and discusses various applications. We will look at the process of hashing, give an implementation of a hash table, and discuss the various design considerations.

*Chapter 9*, *Graphs and Algorithms*, looks at some of the more specialized structures, including graphs and spatial structures. We will learn to represent data through nodes and vertices and create structures such as directed and undirected graphs. We will also learn different algorithms for minimum spanning trees such as Prim’s algorithm and Kruskal’s algorithm.

*Chapter 10*, *Searching*, discusses the most common searching algorithms including, binary search and interpolation searching algorithms. We also give examples of their use for various data structures. Searching a data structure is a fundamental task and there are a number of approaches.

*Chapter 11*, *Sorting*, looks at the most common approaches to sorting. This will include bubble sort, insertion sort, selection sort, quick sort, and heap sort algorithms with detailed explanations, along with their Python implementations.

*Chapter 12*, *Selection Algorithms*, discusses how selection algorithms are commonly used to find the i^{th} smallest element from the list. It is an important operation related to sorting algorithms, and broadly related to the data structures and algorithms.

*Chapter 13*, *String Matching Algorithms*, covers basic concepts and definitions related to strings. In this chapter, various string and pattern matching algorithms are discussed in detail such as the naïve approach, and the **Knuth-Morris-Pratt** (**KMP**) and Boyer-Moore pattern matching algorithms.

*Appendix*, *Answers to the Questions*, provides answers to the exercises at the end of each chapter. Please feel free to check the appendix at the end of the book.

There is also bonus content available online related to tree algorithms at https://static.packt-cdn.com/downloads/9781801073448_Bonus_Content.pdf.