Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Hands-On Data Structures and Algorithms with Python – Third Edition - Third Edition

By : Dr. Basant Agarwal

4.8 (26)

Hands-On Data Structures and Algorithms with Python – Third Edition

4.8 (26)

By: Dr. Basant Agarwal

Overview of this book

Choosing the right data structure is pivotal to optimizing the performance and scalability of applications. This new edition of Hands-On Data Structures and Algorithms with Python will expand your understanding of key structures, including stacks, queues, and lists, and also show you how to apply priority queues and heaps in applications. You’ll learn how to analyze and compare Python algorithms, and understand which algorithms should be used for a problem based on running time and computational complexity. You will also become confident organizing your code in a manageable, consistent, and scalable way, which will boost your productivity as a Python developer. By the end of this Python book, you’ll be able to manipulate the most important data structures and algorithms to more efficiently store, organize, and access data in your applications.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

Free Chapter

Python Data Types and Structures

Python Data Types and Structures

Introducing Python 3.10

Installing Python

Setting up a Python development environment

Overview of data types and objects

Basic data types

Complex data types

Python’s collections module

Summary

Introduction to Algorithm Design

Introduction to Algorithm Design

Introducing algorithms

Performance analysis of an algorithm

Asymptotic notation

Amortized analysis

Composing complexity classes

Computing the running time complexity of an algorithm

Summary

Exercises

Algorithm Design Techniques and Strategies

Algorithm Design Techniques and Strategies

Algorithm design techniques

Recursion

Divide and conquer

Dynamic programming

Greedy algorithms

Summary

Exercises

Linked Lists

Linked Lists

Arrays

Introducing linked lists

Singly linked lists

Doubly linked lists

Circular lists

Practical applications of linked lists

Summary

Exercise

Stacks and Queues

Stacks and Queues

Stacks

Queues

Summary

Exercises

Trees

Trees

Terminology

Binary trees

Binary search trees

Summary

Exercises

Heaps and Priority Queues

Heaps and Priority Queues

Heaps

Priority queues

Summary

Exercises

Hash Tables

Hash Tables

Introducing hash tables

Resolving collisions

Implementing hash tables

Symbol tables

Summary

Exercise

Graphs and Algorithms

Graphs and Algorithms

Graphs

Graph representations

Graph traversals

Other useful graph methods

Summary

Exercises

Searching

Searching

Introduction to searching

Linear search

Jump search

Binary search

Interpolation search

Exponential search

Choosing a search algorithm

Summary

Exercise

Sorting

Sorting

Technical requirements

Sorting algorithms

Bubble sort algorithms

Insertion sort algorithm

Selection sort algorithm

Quicksort algorithm

Implementation of quicksort

Timsort algorithm

Summary

Exercise

Selection Algorithms

Selection Algorithms

Technical requirements

Selection by sorting

Randomized selection

Deterministic selection

Summary

Exercise

String Matching Algorithms

String Matching Algorithms

Technical requirements

String notations and concepts

Pattern matching algorithms

The brute force algorithm

The Rabin-Karp algorithm

The Knuth-Morris-Pratt algorithm

The Boyer-Moore algorithm

Summary

Exercise

Other Books You May Enjoy

Other Books You May Enjoy

Index

Index

Appendix: Answers to the Questions

Chapter 2: Introduction to Algorithm Design

Chapter 3: Algorithm Design Techniques and Strategies

Chapter 4: Linked Lists

Chapter 5: Stacks and Queues

Chapter 6: Trees

Chapter 7: Heaps and Priority Queues

Chapter 8: Hash Tables

Chapter 9: Graphs and Algorithms

Chapter 10: Searching

Chapter 11: Sorting

Chapter 12: Selection Algorithm

Chapter 13: String Matching Algorithms

Customer Reviews

4.8 (26)

5 star

80.8%

4 star

15.4%

3 star

3.8%

2 star

0%

1 star

0%

Chapter 7: Heaps and Priority Queues

Question 1

What will be the time complexity for deleting an arbitrary element from the min-heap?

Solution

To delete any element from the heap, we first have to search the element that is to be deleted, and then we delete the element.

Total time complexity = Time for searching the element + Deleting the element

= O(n) + O(log n)

= O(n)

Question 2

What will be the time complexity for finding the k^th smallest element from the min-heap?

Solution

The k^th element can be found out from the min-heap by performing delete operations k times. For each delete operation, the time complexity is O(logn). So, the total time complexity for finding out the k^th smallest element will be O(klogn).

Question 3

What will be the time complexity to make a max-heap that combines two max-heap each of size n?

Solution

O(n).

Since the time complexity of creating a heap from n elements is O(n), creating a heap of 2n...

Visually different images

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Hands-On Data Structures and Algorithms with Python – Third Edition

Search

Your notes and bookmarks