Data Structures Algorithms In Python 1st John

Canning Alan Broder download

https://ebookbell.com/product/data-structures-algorithms-in-
python-1st-john-canning-alan-broder-55621906

Explore and download more ebooks at ebookbell.com

Here are some recommended products that we believe you will be
interested in. You can click the link to download.

Data Structures Algorithms In Python 1st John Canning Alan Broder

https://ebookbell.com/product/data-structures-algorithms-in-
python-1st-john-canning-alan-broder-43812882

Data Structures And Algorithms In Python 1st Edition Michael T

Goodrich

https://ebookbell.com/product/data-structures-and-algorithms-in-
python-1st-edition-michael-t-goodrich-4178312

Data Structures And Algorithms In Python Beginners And Intermediate

Jain

https://ebookbell.com/product/data-structures-and-algorithms-in-
python-beginners-and-intermediate-jain-36687616

Data Structures And Algorithms In Python Michael T Goodrich

https://ebookbell.com/product/data-structures-and-algorithms-in-
python-michael-t-goodrich-49492894
Data Structures And Algorithms In Python Michael H Goldwasser

https://ebookbell.com/product/data-structures-and-algorithms-in-
python-michael-h-goldwasser-32715654

Data Structures And Algorithms In Python Goodrich Mt Tamassia R

https://ebookbell.com/product/data-structures-and-algorithms-in-
python-goodrich-mt-tamassia-r-4581952

Data Structures With Python Get Familiar With The Common Data
Structures And Algorithms In Python Dr Harsh Bhasin

https://ebookbell.com/product/data-structures-with-python-get-
familiar-with-the-common-data-structures-and-algorithms-in-python-dr-
harsh-bhasin-50687252

Data Structures With Python Get Familiar With The Common Data
Structures And Algorithms In Python Dr Harsh Bhasin

https://ebookbell.com/product/data-structures-with-python-get-
familiar-with-the-common-data-structures-and-algorithms-in-python-dr-
harsh-bhasin-49443880

A Commonsense Guide To Data Structures And Algorithms In Python Volume

1 Level Up Your Core Programming Skills Jay Wengrow

https://ebookbell.com/product/a-commonsense-guide-to-data-structures-
and-algorithms-in-python-volume-1-level-up-your-core-programming-
skills-jay-wengrow-57742868
 John Canning
Alan Broder
Robert Lafore

Data
Structures &
Algorithms
in Python

Boston • Columbus • New York • San Francisco • Amsterdam • Cape Town

Dubai • London • Madrid • Milan • Munich • Paris • Montreal • Toronto • Delhi • Mexico City
São Paulo • Sydney • Hong Kong • Seoul • Singapore • Taipei • Tokyo

9780134855684.indb 1 05/08/22 1:54 PM

 Many of the designations used by manufacturers and sellers to distinguish their Editor-in-Chief
products are claimed as trademarks. Where those designations appear in this book, and Mark Taub
the publisher was aware of a trademark claim, the designations have been printed with
initial capital letters or in all capitals. Director, ITP Product
The authors and publisher have taken care in the preparation of this book, but make Management
no expressed or implied warranty of any kind and assume no responsibility for errors or Brett Bartow
omissions. No liability is assumed for incidental or consequential damages in connec-
tion with or arising out of the use of the information or programs contained herein. Acquisitions Editor
For information about buying this title in bulk quantities, or for special sales opportuni- Kim Spenceley
ties (which may include electronic versions; custom cover designs; and content particu-
Development Editor
lar to your business, training goals, marketing focus, or branding interests), please
contact our corporate sales department at corpsales@pearsoned.com or Chris Zahn
(800) 382-3419.
Managing Editor
For government sales inquiries, please contact governmentsales@pearsoned.com. Sandra Schroeder
For questions about sales outside the U.S., please contact intlcs@pearson.com.
Project Editor
Visit us on the Web: informit.com/aw
Mandie Frank
Library of Congress Control Number: 2022910068
Copyright © 2023 Pearson Education, Inc. Copy Editor
All rights reserved. This publication is protected by copyright, and permission must be Chuck Hutchinson
obtained from the publisher prior to any prohibited reproduction, storage in a retrieval
Indexer
system, or transmission in any form or by any means, electronic, mechanical, photo-
copying, recording, or likewise. For information regarding permissions, request forms, Cheryl Lenser
and the appropriate contacts within the Pearson Education Global Rights & Permissions
Proofreader
Department, please visit www.pearson.com/permissions.
Barbara Mack
No patent liability is assumed with respect to the use of the information contained
herein. Although every precaution has been taken in the preparation of this book, the Editorial Assistant
publisher and author assume no responsibility for errors or omissions. Nor is any liability Cindy Teeters
assumed for damages resulting from the use of the information contained herein.
ISBN-13: 978-0-13-485568-4 Designer
ISBN-10: 0-13-485568-X Chuti Prasertsith
ScoutAutomatedPrintCode Compositor
codeMantra

9780134855684.indb 2 05/08/22 1:54 PM

 Contents at a Glance

1 Overview. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2 Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3 Simple Sorting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4 Stacks and Queues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
5 Linked Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
6 Recursion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
7 Advanced Sorting.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
8 Binary Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
9 2-3-4 Trees and External Storage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
10 AVL and Red-Black Trees.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
11 Hash Tables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
12 Spatial Data Structures.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
13 Heaps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665
14 Graphs.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705
15 Weighted Graphs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767
16 What to Use and Why.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813

Appendixes
A Running the Visualizations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833
B Further Reading. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 841
C Answers to Questions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 845

Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 859

9780134855684.indb 3 05/08/22 1:54 PM

 Table of Contents

1 Overview 1
What Are Data Structures and Algorithms?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Overview of Data Structures.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Overview of Algorithms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Some Definitions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Database. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Record. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Field. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Key. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Databases vs. Data Structures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Programming in Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Interpreter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Dynamic Typing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Sequences. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Looping and Iteration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Multivalued Assignment.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Importing Modules. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Functions and Subroutines. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
List Comprehensions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Object-Oriented Programming. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

2 Arrays 29
The Array Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Searching. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
The Duplicates Issue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Using Python Lists to Implement the Array Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Creating an Array. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Accessing List Elements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
A Better Array Class Implementation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
The OrderedArray Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Linear Search. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Binary Search. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

9780134855684.indb 4 05/08/22 1:54 PM

 Python Code for an OrderedArray Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Binary Search with the find() Method.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
The OrderedArray Class.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Advantages of Ordered Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Logarithms.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
The Equation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
The Opposite of Raising 2 to a Power. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Storing Objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
The OrderedRecordArray Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Big O Notation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Insertion in an Unordered Array: Constant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Linear Search: Proportional to N. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Binary Search: Proportional to log(N). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Don’t Need the Constant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
Why Not Use Arrays for Everything?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

3 Simple Sorting 75
How Would You Do It?.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Bubble Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Bubble Sort on the Football Players. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
The SimpleSorting Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Python Code for a Bubble Sort.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Invariants. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Efficiency of the Bubble Sort.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Selection Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Selection Sort on the Football Players. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
A Brief Description. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
A More Detailed Description.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
The Selection Sort in the SimpleSorting Visualization Tool. . . . . . . . . . . . . 85
Python Code for Selection Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Invariant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Efficiency of the Selection Sort.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Insertion Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Insertion Sort on the Football Players. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Partial Sorting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
The Marked Player. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
The Insertion Sort in the SimpleSorting Visualization Tool. . . . . . . . . . . . . 89
Python Code for Insertion Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

9780134855684.indb 5 05/08/22 1:54 PM

 vi Data Structures & Algorithms in Python

Invariants in the Insertion Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

Efficiency of the Insertion Sort.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Python Code for Sorting Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Stability. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Comparing the Simple Sorts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

4 Stacks and Queues 103

Different Structures for Different Use Cases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Storage and Retrieval Pattern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Restricted Access.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
More Abstract.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Stacks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
The Postal Analogy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
The Stack Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Python Code for a Stack. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Stack Example 1: Reversing a Word. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Stack Example 2: Delimiter Matching. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Efficiency of Stacks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Queues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
A Shifty Problem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
A Circular Queue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
The Queue Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Python Code for a Queue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Efficiency of Queues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Deques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Priority Queues.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
The PriorityQueue Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Python Code for a Priority Queue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Efficiency of Priority Queues.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
What About Search and Traversal?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Parsing Arithmetic Expressions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
Postfix Notation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Translating Infix to Postfix. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
The InfixCalculator Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Evaluating Postfix Expressions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

9780134855684.indb 6 05/08/22 1:54 PM

 Contents vii

5 Linked Lists 157

Links. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
References and Basic Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Relationship, Not Position. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
The LinkedList Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
The Search Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
The Delete Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
The New Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
The Other Buttons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
A Simple Linked List. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
The Basic Linked List Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Traversing Linked Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Insertion and Search in Linked Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Deletion in Linked Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Double-Ended Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Linked List Efficiency. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
Abstract Data Types and Objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
A Stack Implemented by a Linked List. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
A Queue Implemented by a Linked List. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
Data Types and Abstraction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
ADT Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
ADTs as a Design Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
Ordered Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Python Code for Ordered Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Efficiency of Ordered Linked Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
List Insertion Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Doubly Linked Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Insertion and Deletion at the Ends. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
Insertion and Deletion in the Middle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
Doubly Linked List as Basis for Deques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Circular Lists. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Iterators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Basic Iterator Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Other Iterator Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Iterators in Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

6 Recursion 229
Triangular Numbers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
Finding the nth Term Using a Loop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

9780134855684.indb 7 05/08/22 1:54 PM

 viii Data Structures & Algorithms in Python

Finding the nth Term Using Recursion.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

What’s Really Happening?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
Characteristics of Recursive Routines. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Is Recursion Efficient?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Mathematical Induction.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Factorials. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Anagrams.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
A Recursive Binary Search. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Recursion Replaces the Loop.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Divide-and-Conquer Algorithms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
The Tower of Hanoi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
The TowerofHanoi Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Moving Pyramids. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
The Recursive Implementation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
Sorting with mergesort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Merging Two Sorted Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Sorting by Merging. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
Merging Subranges. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
Testing the Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
The Mergesort Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
Efficiency of the mergesort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
Eliminating Recursion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
Recursion and Stacks.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
Simulating a Recursive Function: Triangular. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Rewriting a Recursive Procedure: mergesort.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Some Interesting Recursive Applications. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
Raising a Number to a Power. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
The Knapsack Problem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
Combinations: Picking a Team.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

7 Advanced Sorting 285

Shellsort.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Insertion Sort: Too Many Copies. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
N-Sorting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
Diminishing Gaps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
The AdvancedSorting Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

9780134855684.indb 8 05/08/22 1:54 PM

 Contents ix

Python Code for the Shellsort.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291

Other Interval Sequences.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
Efficiency of the Shellsort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
Partitioning. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
The Partition Process.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
The General Partitioning Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
Efficiency of the Partition Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
Quicksort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
The Basic Quicksort Algorithm.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
Choosing a Pivot Value. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
A First Quicksort Implementation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
Running Quicksort in the AdvancedSorting Visualization Tool. . . . . . 309
The Details.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
Degenerates to O(N2) Performance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Median-of-Three Partitioning.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
Handling Small Partitions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
The Full Quicksort Implementation.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
Removing Recursion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
Efficiency of Quicksort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
Radix Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
Algorithm for the Radix Sort.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
Designing a Radix Sort Program. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
Efficiency of the Radix Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Generalizing the Radix Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
Using a Counting Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
Timsort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Efficiency of Timsort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332

8 Binary Trees 335

Why Use Binary Trees?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
Slow Insertion in an Ordered Array. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
Slow Searching in a Linked List. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
Trees to the Rescue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
What Is a Tree?.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
Tree Terminology. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Root. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Path. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Parent.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338

9780134855684.indb 9 05/08/22 1:54 PM

 x Data Structures & Algorithms in Python

Child.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Sibling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Leaf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Subtree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Visiting.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Traversing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Levels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Keys. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Binary Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Binary Search Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
An Analogy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
How Do Binary Search Trees Work?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
The Binary Search Tree Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Representing the Tree in Python Code.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
Finding a Node. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
Using the Visualization Tool to Find a Node. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
Python Code for Finding a Node.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
Tree Efficiency. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Inserting a Node. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Using the Visualization Tool to Insert a Node.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
Python Code for Inserting a Node. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
Traversing the Tree.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
In-order Traversal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Pre-order and Post-order Traversals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
Python Code for Traversing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
Traversing with the Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
Traversal Order. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
Finding Minimum and Maximum Key Values. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
Deleting a Node.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
Case 1: The Node to Be Deleted Has No Children. . . . . . . . . . . . . . . . . . . . . . . . . 367
Case 2: The Node to Be Deleted Has One Child. . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Case 3: The Node to Be Deleted Has Two Children. . . . . . . . . . . . . . . . . . . . . . . 370
The Efficiency of Binary Search Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
Trees Represented as Arrays.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
Tree Levels and Size. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Printing Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
Duplicate Keys.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
The BinarySearchTreeTester.py Program. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
The Huffman Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
Character Codes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
Decoding with the Huffman Tree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
Creating the Huffman Tree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389

9780134855684.indb 10 05/08/22 1:54 PM

 Contents xi

Coding the Message. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391

Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397

9 2-3-4 Trees and External Storage 401

Introduction to 2-3-4 Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
What’s in a Name?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
2-3-4 Tree Terminology. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
2-3-4 Tree Organization.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
Searching a 2-3-4 Tree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
Insertion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
Node Splits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
Splitting the Root. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
Splitting on the Way Down. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
The Tree234 Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
The Random Fill and New Tree Buttons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
The Search Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
The Insert Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
Zooming and Scrolling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
Python Code for a 2-3-4 Tree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
The __Node Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
The Tree234 Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Traversal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
Deletion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
Efficiency of 2-3-4 Trees.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
Speed. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
Storage Requirements.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
2-3 Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Node Splits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
Promoting Splits to Internal Nodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
Implementation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
Efficiency of 2-3 Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
External Storage.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Accessing External Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439
Sequential Ordering. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
B-Trees.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
Indexing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
Complex Search Criteria.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
Sorting External Files. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453

9780134855684.indb 11 05/08/22 1:54 PM

 xii Data Structures & Algorithms in Python

Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460

10 AVL and Red-Black Trees 463

Our Approach to the Discussion.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
Balanced and Unbalanced Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
Degenerates to O(N). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
Measuring Tree Balance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
How Much Is Unbalanced?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
AVL Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
The AVLTree Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
Inserting Items with the AVLTree Visualization Tool. . . . . . . . . . . . . . . . . . . . . 472
Python Code for the AVL Tree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
The Efficiency of AVL Trees.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
Red-Black Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
Conceptual. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
Top-Down Insertion.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
Bottom-Up Insertion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488
Red-Black Tree Characteristics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488
Using the Red-Black Tree Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
Flipping a Node’s Color. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
Rotating Nodes.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
The Insert Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
The Search Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
The Delete Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
The Erase & Random Fill Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
Experimenting with the Visualization Tool.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
Experiment 1: Inserting Two Red Nodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
Experiment 2: Rotations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
Experiment 3: Color Swaps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
Experiment 4: An Unbalanced Tree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
More Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
The Red-Black Rules and Balanced Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Null Children. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Rotations in Red-Black Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497
Subtrees on the Move. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497
Inserting a New Node.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
Preview of the Insertion Process. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
Color Swaps on the Way Down.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
Rotations After the Node Is Inserted. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501

9780134855684.indb 12 05/08/22 1:54 PM

 Contents xiii

Rotations on the Way Down.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505

Deletion.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
The Efficiency of Red-Black Trees.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
2-3-4 Trees and Red-Black Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Transformation from 2-3-4 to Red-Black. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
Operational Equivalence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
Red-Black Tree Implementation.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521

11 Hash Tables 525

Introduction to Hashing.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
Bank Account Numbers as Keys. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
A Dictionary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
Hashing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
Collisions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533
Open Addressing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536
Linear Probing.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536
Python Code for Open Addressing Hash Tables. . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
Quadratic Probing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
Double Hashing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
Separate Chaining.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
The HashTableChaining Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
Python Code for Separate Chaining. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569
Hash Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
Quick Computation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
Random Keys. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
Nonrandom Keys.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576
Hashing Strings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578
Folding. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580
Hashing Efficiency. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
Open Addressing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
Separate Chaining. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
Open Addressing Versus Separate Chaining.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
Hashing and External Storage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
Table of File Pointers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
Nonfull Blocks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
Full Blocks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589

9780134855684.indb 13 05/08/22 1:54 PM

 xiv Data Structures & Algorithms in Python

Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595

12 Spatial Data Structures 597

Spatial Data.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
Cartesian Coordinates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
Geographic Coordinates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598
Computing Distances Between Points. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
Distance Between Cartesian Coordinates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
Circles and Bounding Boxes.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601
Clarifying Distances and Circles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601
Bounding Boxes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
The Bounding Box of a Query Circle in Cartesian Coordinates. . . . . . 603
The Bounding Box of a Query Circle in Geographic
Coordinates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604
Implementing Bounding Boxes in Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
The CircleBounds Subclass.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
Determining Whether Two Bounds Objects Intersect. . . . . . . . . . . . . . . . . . . . 609
Determining Whether One Bounds Object Lies Entirely Within
Another. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
Searching Spatial Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
Lists of Points. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612
Creating an Instance of the PointList Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612
Inserting Points. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613
Finding an Exact Match. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614
Deleting a Point. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614
Traversing the Points. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
Finding the Nearest Match. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
Grids. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617
Implementing a Grid in Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
Creating an Instance of the Grid Class.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619
Inserting Points. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
Finding an Exact Match. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
Big O and Practical Considerations.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622
Deleting and Traversing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
Finding the Nearest Match. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
Does the Query Circle Fall Within a Layer?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
Does the Query Circle Intersect a Grid Cell?.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628
Generating the Sequence of Neighboring Cells to Visit. . . . . . . . . . . . . . . . . 629

9780134855684.indb 14 05/08/22 1:54 PM

 Contents xv

Pulling It All Together: Implementing Grid’s findNearest(). . . . . . . . . . . . 630

Quadtrees.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
Creating an Instance of the QuadTree Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635
Inserting Points: A Conceptual Overview. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
Avoiding Ambiguity.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
The QuadTree Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
Implementing Quadtrees: The Node Class.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640
The insert Method. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641
Efficiency of Insertion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644
Finding an Exact Match. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644
Efficiency of Exact Search. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
Traversing the Points. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
Deleting a Point. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646
Finding the Nearest Match. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647
Finding a Candidate Node. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
Finding the Closest Node. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 649
Pulling It All Together: Implementing QuadTree’s findNearest(). . . . . 652
Efficiency of findNearest(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
Theoretical Performance and Optimizations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656
Practical Considerations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656
Further Extensions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658
Other Operations.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658
Higher Dimensions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663

13 Heaps 665
Introduction to Heaps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666
Priority Queues, Heaps, and ADTs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
Partially Ordered. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668
Insertion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
Removal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670
Other Operations.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 674
The Heap Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 674
The Insert Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
The Make Random Heap Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676
The Erase and Random Fill Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676
The Peek Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677
The Remove Max Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677
The Heapify Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677

9780134855684.indb 15 05/08/22 1:54 PM

 xvi Data Structures & Algorithms in Python

The Traverse Button. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677

Python Code for Heaps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677
Insertion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679
Removal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 680
Traversal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682
Efficiency of Heap Operations.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683
A Tree-Based Heap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684
Heapsort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 686
Sifting Down Instead of Up. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 686
Using the Same Array.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 688
The heapsort() Subroutine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 691
The Efficiency of Heapsort.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693
Order Statistics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694
Partial Ordering Assists in Finding the Extreme Values. . . . . . . . . . . . . . . . . . 695
The Efficiency of K Highest. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 700
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 701
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703

14 Graphs 705
Introduction to Graphs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705
Definitions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706
The First Uses of Graphs.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708
Representing a Graph in a Program. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 709
Adding Vertices and Edges to a Graph. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 713
The Graph Class. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715
Traversal and Search.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 718
Depth-First.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719
Breadth-First. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729
Minimum Spanning Trees.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 734
Minimum Spanning Trees in the Graph Visualization Tool. . . . . . . . . . . . 735
Trees Within a Graph. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 736
Python Code for the Minimum Spanning Tree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737
Topological Sorting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740
Dependency Relationships.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 741
Directed Graphs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 742
Sorting Directed Graphs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 742
The Graph Visualization Tool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 743
The Topological Sorting Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744
Cycles and Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745
Python Code for the Basic Topological Sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 746

9780134855684.indb 16 05/08/22 1:54 PM

 Contents xvii

Improving the Topological Sort.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 748

Connectivity in Directed Graphs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 753
The Connectivity Matrix. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 753
Transitive Closure and Warshall’s Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 753
Implementation of Warshall’s Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 758
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 759
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 762
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 763

15 Weighted Graphs 767

Minimum Spanning Tree with Weighted Graphs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767
An Example: Networking in the Jungle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 768
The WeightedGraph Visualization Tool.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 768
Building the Minimum Spanning Tree: Send Out the
Surveyors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 770
Creating the Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 775
The Shortest-Path Problem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 783
Travel by Rail. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 783
Dijkstra’s Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 784
Agents and Train Rides. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 784
Finding Shortest Paths Using the Visualization Tool.. . . . . . . . . . . . . . . . . . . . . 790
Implementing the Algorithm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 794
Python Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795
The All-Pairs Shortest-Path Problem.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 797
Efficiency. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 800
Intractable Problems. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 801
The Knight’s Tour. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802
The Traveling Salesperson Problem.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802
Hamiltonian Paths and Cycles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 803
Summary. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 805
Questions.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 806
Experiments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 808
Programming Projects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 809

16 What to Use and Why 813

Analyzing the Problem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814
What Kind of Data?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814
How Much Data?.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 815
What Operations and How Frequent?.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 816
Who Will Maintain the Software?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 817
Foundational Data Structures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 818

9780134855684.indb 17 05/08/22 1:54 PM

 xviii Data Structures & Algorithms in Python

Speed and Algorithms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 819

Libraries.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 820
Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 820
Linked Lists.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 821
Binary Search Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 822
Balanced Search Trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 822
Hash Tables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823
Comparing the General-Purpose Storage Structures.. . . . . . . . . . . . . . . . . . . . . . 824
Special-Ordering Data Structures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 824
Stack. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 825
Queue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 825
Priority Queue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 826
Comparison of Special-Ordering Structures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 826
Sorting.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 826
Specialty Data Structures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 828
Quadtrees and Grids. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 828
Graphs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 828
External Storage.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829
Sequential Storage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829
Indexed Files. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829
B-trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 830
Hashing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 830
Choosing Among External Storage Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 830
Virtual Memory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 830
Onward. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 831

Appendixes

A Running the Visualizations 833

For Developers: Running and Changing the Visualizations. . . . . . . . . . . . . . . . . . . . 834
Getting Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 834
Getting Git. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835
Getting the Visualizations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835
For Managers: Downloading and Running the Visualizations. . . . . . . . . . . . . . . . . 836
For Others: Viewing the Visualizations on the Internet. . . . . . . . . . . . . . . . . . . . . . . . . 837
Using the Visualizations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838

B Further Reading 841

Data Structures and Algorithms.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 841

9780134855684.indb 18 05/08/22 1:54 PM

 Contents xix

Object-Oriented Programming Languages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 842

Object-Oriented Design (OOD) and Software Engineering. . . . . . . . . . . . . . . . . . . . . 842

C Answers to Questions 845

Chapter 1, "Overview". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 845
Chapter 2, "Arrays". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 846
Chapter 3, "Simple Sorting". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 847
Chapter 4, "Stacks and Queues". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848
Chapter 5, "Linked Lists". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848
Chapter 6, "Recursion". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 849
Chapter 7, "Advanced Sorting". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 850
Chapter 8, "Binary Trees". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851
Chapter 9, "2-3-4 Trees and External Storage". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851
Chapter 10, "AVL and Red-Black Trees". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 852
Chapter 11, "Hash Tables".. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853
Chapter 12, "Spatial Data Structures". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853
Chapter 13, "Heaps". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 854
Chapter 14, "Graphs". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 855
Chapter 15, "Weighted Graphs".. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 856

Index 859

9780134855684.indb 19 05/08/22 1:54 PM

 Pearson’s Commitment to Diversity,
Equity, and Inclusion
Pearson is dedicated to creating bias-free content that reflects the diversity of all learners.
We embrace the many dimensions of diversity, including but not limited to race, ethnic-
ity, gender, socioeconomic status, ability, age, sexual orientation, and religious or political
beliefs.

Education is a powerful force for equity and change in our world. It has the potential to
deliver opportunities that improve lives and enable economic mobility. As we work with
authors to create content for every product and service, we acknowledge our responsibil-
ity to demonstrate inclusivity and incorporate diverse scholarship so that everyone can
achieve their potential through learning. As the world’s leading learning company, we
have a duty to help drive change and live up to our purpose to help more people create a
better life for themselves and to create a better world.

Our ambition is to purposefully contribute to a world where

▶▶ Everyone has an equitable and lifelong opportunity to succeed through learning

▶▶ Our educational products and services are inclusive and represent the rich diversity
of learners

▶▶ Our educational content accurately reflects the histories and experiences of the
learners we serve

▶▶ Our educational content prompts deeper discussions with learners and motivates
them to expand their own learning (and worldview)

While we work hard to present unbiased content, we want to hear from you about any
concerns or needs with this Pearson product so that we can investigate and address them.

Please contact us with concerns about any potential bias at https://www.pearson.com/

report-bias.html.

9780134855684.indb 20 05/08/22 1:54 PM

 To my mother, who gave me a thirst for knowledge,
to my father, who taught me the joys of engineering,
and to June, who made it possible to pursue both.

John Canning

For my father Sol Broder, computer science pioneer,

for leading the way.
To my mother Marilyn Broder, master educator,
for inspiring me to teach.
To Fran, for making my life complete.

Alan Broder

9780134855684.indb 21 05/08/22 1:54 PM

 Register your copy of Data Structures & Algorithms in Python at informit.com for conve-
nient access to downloads, updates, and corrections as they become available.​To start the
registration process, go to informit.com/register and log in or create an account. Enter the
product ISBN 9780134855684 and click Submit. Once the process is complete, you will
find any available bonus content under "Registered Products."

Visit the book’s website, https://datastructures.live, to join the conversation with other
readers about the book, and learn more about the visualizations that bring data structures
to life.

9780134855684.indb 22 05/08/22 1:54 PM

 Acknowledgments
From John Canning and Alan Broder

Robert Lafore’s Java-based version of this book has been a mainstay in Data Structures
courses and professionals’ reference shelves around the world for many years. When
Alan’s Data Structures course at Stern College for Women of Yeshiva University moved on
to Python, the inability to use Lafore’s book in the course was a real loss. We’re thus espe-
cially happy to bring this new and revised edition to the world of Python programmers
and students.

We’d like to thank the many students at Stern who contributed to this book either
directly or indirectly over the past several years. Initial Python versions of Lafore’s Java
implementations were central to Alan’s Python-based courses, and Stern student feedback
helped improve the code’s clarity, enhanced its performance, and sometimes even identi-
fied and fixed bugs!

For their valuable feedback and recommendations on early drafts of this new edition, we
are grateful to many students in Alan’s Data Structures courses, including Estee Brooks,
Adina Bruce, Julia Chase, Hanna Fischer, Limor Kohanim, Elisheva Kohn, Shira Orlian,
Shira Pahmer, Jennie Peled, Alexandra Roffe, Avigail Royzenberg, Batia Segal, Penina
Waghalter, and Esther Werblowsky. Our apologies if we’ve omitted anyone’s name.

An open-source package of data structure visualizations is available to enhance your study

of this book, and Stern students played an active role in the development of the visual-
ization software. John and Alan extend many thanks to the Stern student pioneers and
leaders of this project, including Ilana Radinsky, Elana Apfelbaum, Ayliana Teitelbaum, and
Lily Polonetsky, as well as the following past and present Stern student contributors and
mentors: Zoe Abboudi, Ayelet Aharon, Lara Amar, Natania Birnbaum, Adina Bruce, Chani
Dubin, Sarah Engel, Sarah Graff, Avigayil Helman, Michal Kaufman, Sarina Kofman, Rachel
Leiser, Talia Leitner, Shani Lewis, Rina Melincoff, Atara Neugroschl, Shira Pahmer, Miriam
Rabinovich, Etta Rapp, Shira Sassoon, Shira Schneider, Mazal Schoenwald, Shira Smith, Riva
Tropp, Alexandra Volchek, and Esther Werblowsky. Also, many thanks to the Stern faculty
who mentored student participants: Professor Ari Shamash, Professor Lawrence Teitelman,
and Professor Joshua Waxman. Our apologies if we have left anyone off this list.

Many thanks go to Professor David Matuszek of the University of Pennsylvania for his
early contributions of ideas and PowerPoint slides when Alan first started teaching Data
Structures at Stern. Many of the slides available in the Instructors Resources section have
their origin in his clear and well-designed slides. Also, we are grateful to Professor Marian
Gidea of the Department of Mathematics of Yeshiva University for his insights into spher-
ical trigonometry.

Finally, we owe a great debt to the talented editors at Pearson who made this book a
reality: Mark Taber, Kim Spenceley, Mandie Frank, Chuti Prasertsith, and Chris Zahn.
Without their many talents and patient help, this project would just be an odd collection
of text files, drawings, and source code.

9780134855684.indb 23 05/08/22 1:54 PM

 From Robert Lafore for the Java-based versions of the book

Acknowledgments to the First Edition,

Data Structures and Algorithms in
Java
My gratitude for the following people (and many others) cannot be fully expressed
in this short acknowledgment. As always, Mitch Waite had the Java thing figured out
before anyone else. He also let me bounce the applets off him until they did the job,
and extracted the overall form of the project from a miasma of speculation. My editor,
Kurt Stephan, found great reviewers, made sure everyone was on the same page, kept the
ball rolling, and gently but firmly ensured that I did what I was supposed to do. Harry
Henderson provided a skilled appraisal of the first draft, along with many valuable sugges-
tions. Richard S. Wright, Jr., as technical editor, corrected numerous problems with his
keen eye for detail. Jaime Niño, Ph.D., of the University of New Orleans, attempted to
save me from myself and occasionally succeeded, but should bear no responsibility for
my approach or coding details. Susan Walton has been a staunch and much-appreciated
supporter in helping to convey the essence of the project to the nontechnical. Carmela
Carvajal was invaluable in extending our contacts with the academic world. Dan Scherf
not only put the CD-ROM together, but was tireless in keeping me up to date on rapidly
evolving software changes. Finally, Cecile Kaufman ably shepherded the book through its
transition from the editing to the production process.

Acknowledgments to the Second

Edition
My thanks to the following people at Sams Publishing for their competence, effort, and
patience in the development of this second edition. Acquisitions Editor Carol Ackerman
and Development Editor Songlin Qiu ably guided this edition through the complex
production process. Project Editor Matt Purcell corrected a semi-infinite number of gram-
matical errors and made sure everything made sense. Tech Editor Mike Kopak reviewed
the programs and saved me from several problems. Last but not least, Dan Scherf, an old
friend from a previous era, provides skilled management of my code and applets on the
Sams website.

9780134855684.indb 24 05/08/22 1:54 PM

 About the Authors
Dr. John Canning is an engineer, computer scientist, and researcher. He earned an S.B.
degree in electrical engineering from the Massachusetts Institute of Technology and a
Ph.D. in Computer Science from the University of Maryland at College Park. His varied
professions include being a professor of computer science, a researcher and software
engineer in industry, and a company vice president. He now is president of Shakumant
Software.

Alan Broder is clinical professor and chair of the Department of Computer Science at
Stern College for Women of Yeshiva University in New York City. He teaches introductory
and advanced courses in Python programming, data structures, and data science. Before
joining Stern College, he was a software engineer, designing and building large-scale data
analysis systems. He founded and led White Oak Technologies, Inc. as its CEO, and later
served as the chairman and fellow of its successor company, Novetta, in Fairfax, Virginia.
Robert Lafore has degrees in Electrical Engineering and Mathematics, has worked as a
systems analyst for the Lawrence Berkeley Laboratory, founded his own software company,
and is a best-selling writer in the field of computer programming. Some of his titles are
Object-Oriented Programming in C++ and Data Structures and Algorithms in Java.

9780134855684.indb 25 05/08/22 1:54 PM

 xxvi Data Structures & Algorithms in Python

Introduction
What’s in this book? This book is designed to be a practical introduction to data structures
and algorithms for students who have just begun to write computer programs. This intro-
duction will tell you more about the book, how it is organized, what experience we expect
readers will have before starting the book, and what knowledge you will get by reading it
and doing the exercises.

Who This Book Is For

Data structures and algorithms are the core of computer science. If you’ve ever wanted
to understand what computers can do, how they do it, and what they can’t do, then you
need a deep understanding of both (it’s probably better to say "what computers have
difficulty doing" instead of what they can’t do). This book may be used as a text in a data
structures and/or algorithms course, frequently taught in the second year of a univer-
sity computer science curriculum. The text, however, is also designed for professional
programmers, for high school students, and for anyone else who needs to take the next
step up from merely knowing a programming language. Because it’s easy to understand,
it is also appropriate as a supplemental text to a more formal course. It is loaded with
examples, exercises, and supplemental materials, so it can be used for self-study outside of
a classroom setting.

Our approach in writing this book is to make it easy for readers to understand how data
structures operate and how to apply them in practice. That’s different from some other
texts that emphasize the mathematical theory, or how those structures are implemented
in a particular language or software library. We’ve selected examples with real-world appli-
cations and avoid using math-only or obscure examples. We use figures and visualization
programs to help communicate key ideas. We still cover the complexity of the algorithms
and the math needed to show how complexity impacts performance.

What You Need to Know Before You Read This Book

The prerequisites for using this book are: knowledge of some programming language and
some mathematics. Although the sample code is written in Python, you don’t need to
know Python to follow what’s happening. Python is not hard to understand, if you’ve
done some procedural and/or object-oriented programming. We’ve kept the syntax in the
examples as general as possible,

More specifically, we use Python version 3 syntax. This version differs somewhat from
Python 2, but not greatly. Python is a rich language with many built-in data types and librar-
ies that extend its capabilities. Our examples, however, use the more basic constructs for two
reasons: it makes them easier to understand for programmers familiar with other languages,
and it illustrates the details of the data structures more explicitly. In later chapters, we do
make use of some Python features not found in other languages such as generators and list
comprehensions. We explain what these are and how they benefit the programmer.

9780134855684.indb 26 05/08/22 1:54 PM

 Introduction xxvii

Of course, it will help if you’re already familiar with Python (version 2 or 3). Perhaps
you’ve used some of Python’s many data structures and are curious about how they are
implemented. We review Python syntax in Chapter 1, "Overview," for those who need
an introduction or refresher. If you’ve programmed in languages like Java, C++, C#,
JavaScript, or Perl, many of the constructs should be familiar. If you’ve only programmed
using functional or domain-specific languages, you may need to spend more time becom-
ing familiar with basic elements of Python. Beyond this text, there are many resources
available for novice Python programmers, including many tutorials on the Internet.

Besides a programming language, what should every programmer know? A good knowl-
edge of math from arithmetic through algebra is essential. Computer programming is
symbol manipulation. Just like algebra, there are ways of transforming expressions to
rearrange terms, put them in different forms, and make certain parts more prominent,
all while preserving the same meaning. It’s also critical to understand exponentials in
math. Much of computer science is based on knowing what raising one number to a
power of another means. Beyond math, a good sense of organization is also beneficial
for all programming. Knowing how to organize items in different ways (by time, by
function, by size, by complexity, and so on) is crucial to making programs efficient and
maintainable. When we talk about efficiency and maintainability, they have particular
meanings in computer science. Efficiency is mostly about how much time it takes to
compute things but can also be about the amount of space it takes. Maintainability refers
to the ease of understanding and modifying your programs by other programmers as
well as yourself.

You’ll also need knowledge of how to find things on the Internet, download and install
software, and run them on a computer. The instructions for downloading and running the
visualization programs can be found in Appendix A of this book. The Internet has made
it very easy to access a cornucopia of tools, including tools for learning programming and
computer science. We expect readers to already know how to find useful resources and
avoid sources that might provide malicious software.

What You Can Learn from This Book

As you might expect from its title, this book can teach you about how data structures make
programs (and programmers) more efficient in their work. You can learn how data organi-
zation and its coupling with appropriate algorithms greatly affect what can be computed
with a given amount of computing resources. This book can give you a thorough under-
standing of how to implement the data structures, and that should enable you to imple-
ment them in any programming language. You can learn the process of deciding what data
structure(s) and algorithms are the most appropriate to meet a particular programming
request. Perhaps most importantly, you can learn when an algorithm and/or data structure
will fail in a given use case. Understanding data structures and algorithms is the core of
computer science, which is different from being a Python (or other language) programmer.

The book teaches the fundamental data structures that every programmer should know.
Readers should understand that there are many more. These basic data structures work in
a wide variety of situations. With the skills you develop in this book, you should be able

9780134855684.indb 27 05/08/22 1:54 PM

 xxviii Data Structures & Algorithms in Python

to read a description of another data structure or algorithm and begin to analyze whether
or not it will outperform or perform worse than the ones you’ve already learned in partic-
ular use cases.

This book explains some Python syntax and structure, but it will not teach you all its
capabilities. The book uses a subset of Python’s full capabilities to illustrate how more
complex data structures are built from the simpler constructs. It is not designed to teach
the basics of programming to someone who has never programmed. Python is a very
high-level language with many built-in data structures. Using some of the more primi-
tive types such as arrays of integers or record structures, as you might find in C or C++,
is somewhat more difficult in Python. Because the book’s focus is the implementation
and analysis of data structures, our examples use approximations to these primitive types.
Some Python programmers may find these examples unnecessarily complex, knowing
about the more elegant constructs provided with the language in standard libraries. If you
want to understand computer science, and in particular, the complexity of algorithms,
you must understand the underlying operations on the primitives. When you use a data
structure provided in a programming language or from one of its add-on modules, you
will often have to know its complexity to know whether it will work well for your use
case. Understanding the core data structures, their complexities, and trade-offs will help
you understand the ones built on top of them.

All the data structures are developed using object-oriented programming (OOP). If
that’s a new concept for you, the review in Chapter 1 of how classes are defined and used
in Python provides a basic introduction to OOP. You should not expect to learn the full
power and benefits of OOP from this text. Instead, you will learn to implement each data
structure as a class. These classes are the types of objects in OOP and make it easier to
develop software that can be reused by many different applications in a reliable way.

The book uses many examples, but this is not a book about a particular application area of
computer science such as databases, user interfaces, or artificial intelligence. The examples
are chosen to illustrate typical applications of programs, but all programs are written in a
particular context, and that changes over time. A database program written in 1970 may
have appeared very advanced at that time, but it might seem very trivial today. The exam-
ples presented in this text are designed to teach how data structures are implemented,
how they perform, and how to compare them when designing a new program. The exam-
ples should not be taken as the most comprehensive or best implementation possible of
each data structure, nor as a thorough review of all the potential data structures that could
be appropriate for a particular application area.

Structure
Each chapter presents a particular group of data structures and associated algorithms.
At the end of the chapters, we provide review questions covering the key points in the
chapter and sometimes relationships to previous chapters. The answers for these can be
found in Appendix C, "Answers to Questions." These questions are intended as a self-test
for readers, to ensure you understood all the material.

9780134855684.indb 28 05/08/22 1:54 PM

 Introduction xxix

Many chapters suggest experiments for readers to try. These can be individual thought
experiments, team assignments, or exercises with the software tools provided with the
book. These are designed to apply the knowledge just learned to some other area and help
deepen your understanding.

Programming projects are longer, more challenging programming exercises. We provide a

range of projects of different levels of difficulty. These projects might be used in classroom
settings as homework assignments. Sample solutions to the programming projects are avail-
able to qualified instructors from the publisher and the website, https://datastructures.live.

History
Mitchell Waite and Robert Lafore developed the first version of this book and titled it Data
Structures and Algorithms in Java. The first edition was published in 1998, and the second
edition, by Robert, came out in 2002. John Canning and Alan Broder developed this
version using Python due to its popularity in education and commercial and noncommer-
cial software development. Java is widely used and an important language for computer
scientists to know. With many schools adopting Python as a first programming language,
the need for textbooks that introduce new concepts in an already familiar language drove
the development of this book. We expanded the coverage of data structures and updated
many of the examples.

We’ve tried to make the learning process as painless as possible. We hope this text makes
the core, and frankly, the beauty of computer science accessible to all. Beyond just under-
standing, we hope you find learning these ideas fun. Enjoy yourself!

9780134855684.indb 29 05/08/22 1:54 PM

 Figure Credits
Figures Credit/Attribution

Figures 2.1–2.4, 2.6, 3.5, 3.7, 3.9, 4.2, 4.6, 4.10, 4.11, 5.3, 5.4,   Shakumant Software

5.9, 6.10, 6.18, 7.3, 7.4, 7.6, 7.10, 7.11, 8.5, 8.8, 8.9, 8.11,

8.14, 8.15, 9.7–9.9, 10.09-10.11(a-c), 10.14–10.16, 10.29(a-b),

11.06–11.10, 11.14, 11.15, 11.18, 11.19, 12.24, 13.7, 13.8,

13.9, 13.13, 14.6, 14.12, 14.17, 15.02, 15.9, 15.14–15.18,

A.01-A.04

Figure 6.1 Courtesy of Droste B.V.

Figure 13.15 word cloud produced by

        
www.wordclouds.com.

Cover archy13/Shutterstock

A01_DSAP_FM_pi-pxxx.indd 30 06/08/22 10:01 AM

 CHAPTER 1 IN THIS CHAPTER

Overview ▶▶ What Are Data Structures and

Algorithms?
▶▶ Overview of Data Structures

▶▶ Overview of Algorithms

You have written some programs and learned enough ▶▶ Some Definitions

▶▶ Programming in Python
to think that programming is fun, or at least interesting.
Some parts are easy, and some parts are hard. You’d like to ▶▶ Object-Oriented Programming
know more about how to make the process easier, get past
the hard parts, and conquer more complex tasks. You are
starting to study the heart of computer science, and that
brings up many questions. This chapter sets the stage for
learning how to make programs that work properly and
fast. It explains a bunch of new terms and fills in back-
ground about the programming language that we use in the
examples.

What Are Data Structures and

Algorithms?
Data organizations are ways data is arranged in the
computer using its various storage media (such as random-
access memory, or RAM, and disk) and how that data is
interpreted to represent something. Algorithms are the
procedures used to manipulate the data in these structures.
The way data is arranged can simplify the algorithms and
make algorithms run faster or slower. Together, the data
organization and the algorithm form a data structure.
The data structures act like building blocks, with more
complex data structures using other data structures as
components with appropriate algorithms.

Does the way data is arranged and the algorithm used to

manipulate it make a difference? The answer is a definite
yes. From the perspective of nonprogrammers, it often
seems as though computers can do anything and do it very
fast. That’s not really true. To see why, let’s look at a non-
programming example.

9780134855684.indb 1 05/08/22 1:54 PM

 2 CHAPTER 1  Overview

When you cook a meal, a collection of ingredients needs to be combined and manipulated
in specific ways. There is a huge variety of ways that you could go about the individual
steps needed to complete the meal. Some of those methods are going to be more efficient
than others. Let’s assume that you have a written recipe, but are working in an unfamil-
iar kitchen, perhaps while visiting a friend. One method for making the meal would be
Method A:

1. Read through the full recipe noting all the ingredients it mentions, their quantities,
and any equipment needed to process them.

2. Find the ingredients, measure out the quantity needed, and store them.

3. Get out all the equipment needed to complete the steps in the recipe.

4. Go through the steps of the recipe in the order specified.

Let’s compare that to Method B:

1. Read the recipe until you identify the first set of ingredients or equipment that is
needed to complete the first step.

2. Find the identified ingredients or equipment.

3. Measure any ingredients found.

4. Perform the first step with the equipment and ingredients already found.

5. Return to the beginning of this method and repeat the instructions replacing the
word first with next. If there is no next step, then quit.

Both methods are complete in that that they should finish the complete recipe if all the
ingredients and equipment are available. For simple recipes, they should take about
the same amount of time too. The methods differ as the recipes get more complex. For
example, what if you can’t find the fifth ingredient? In method A, that issue is identified
at the beginning before any other ingredients are combined. While neither method really
explains what to do about exceptions like a missing ingredient, you can still compare
them under the assumption that you handle the exceptions the same way.
A missing ingredient could be handled in several ways: find a substitute ingredient,
broaden the search for the ingredient (look in other rooms, ask a neighbor, go to the mar-
ket), or ignore the ingredient (an optional garnish). Each of those remedies takes some
time. If there is one missing ingredient and two cooks using the different methods handle
it in the same way, both are delayed the same amount of time. If there are multiple miss-
ing ingredients, however, Method A should identify those earlier and allow for the
possibility of getting all the missing ingredients in one visit to a neighbor or a market.
The time savings of combining the tasks of replacing missing ingredients could be
significant (imagine the market being far away or neighbors who want to talk for hours
on every visit).

9780134855684.indb 2 05/08/22 1:54 PM

 What Are Data Structures and Algorithms? 3

The order of performing the operations could have significant impact on the time needed
to complete the meal. Another difference could be in the quality of the meal. For example,
in Method B the cook would perform the first "step" and then move on to the next step.
Let’s assume those steps use two different groups of ingredients or equipment. If finding
or measuring the ingredients, or getting the equipment for the later steps takes significant
time, then the results of the first step sit around for a significant time. That can have a
bad effect on the quality of the meal. The cook might be able to overcome that effect in
some circumstances by, say, putting the results of the first step in a freezer or refrigerator
and then bringing them back to room temperature later. The cook would be preserving
the quality of the food at the expense of the time needed to prepare it.

Would Method B ever be desirable if it takes longer or risks degrading the quality of the
food? Perhaps. Imagine that the cook is preparing this meal in the unfamiliar kitchen of
a family relative. The kitchen is full of family members, and each one is trying to make
part of the meal. In this crowded situation, it could be difficult for each cook to get out
all of their ingredients and equipment at once. There might not be enough counter space,
or mixing bowls, or knives, for example, for each cook to have all their items assembled
at the beginning. The cooks could be constrained to work on individual steps while wait-
ing for equipment, space, or ingredients to become available. In this case, Method B could
have advantages over asking all the cooks to work one at a time using Method A.

Coming back to programming, the algorithm specifies the sequence of operations that are
to be performed, much like the steps in the recipe. The data organizations are somewhat
analogous to how the ingredients are stored, laid out in the kitchen, and their proximity
to other ingredients and equipment. For example, having the ingredient in the kitchen
makes the process much faster than if the ingredient needs to be retrieved from a neigh-
bor or the market. You can think of the amount of space taken up by spreading out the
ingredients in various locations as the amount of space needed for the algorithm. Even if
all the ingredients are in the kitchen where the cook is, there are ways of setting up the
ingredients to make the cooking tasks go faster. Having them compactly arranged in the
order they are needed minimizes the amount of moving around the cook must do. The
organization of the ingredients can also help if a cook must be replaced by another cook
in the middle of the preparation; understanding where each of the ingredients fits in to
the recipe is faster if the layout is organized. This is another reason why good data organi-
zation is important. It also reinforces that concept that the algorithm and the data organi-
zation work together to make the data structure.

Data structures are important not just for speed but also to properly model the meaning
of the data. Let’s say there’s an event that many people want to attend and they need to
submit their phone number to have a chance to get tickets. Each person can request mul-
tiple tickets. If there are fewer tickets than the number of people who want to get them,
some method needs to be applied to decide which phone numbers to contact first and
determine the number of tickets they will receive. One method would be to go through
the phone numbers one at a time and total up the number of tickets until all are given
out, then go through the remaining numbers to let them know the tickets are gone. That
might be a fair method if the numbers were put in an ordered list defined in a way that

9780134855684.indb 3 05/08/22 1:54 PM

 4 CHAPTER 1  Overview

potential recipients understood— for example, a chronological list of phone numbers

submitted by people interested in the tickets. If the tickets are to be awarded as a sort of
lottery, then going through them sequentially means following any bias that is implicit
in the order of the list. Randomly choosing a number from the list, contacting the buyer,
and then removing the number would be fairer in a lottery system.

Data structures model systems by assigning specific meanings to each of the pieces and how
they interact. The "systems" are real-world things like first-come, first-served ticket sales,
or a lottery giveaway, or how roads connect cities. For the list of phone numbers with
ticket requests, a first-come, first-served system needs the list in chronological order, some
pointer to the next number that should be taken, and a pointer to where any newly arriv-
ing number should be added (after all previous list entries). The lottery system would
need a different organization, and modeling the map of roads and cities needs another.
In this book we examine a lot of different data structures. Each one has its strengths and
weaknesses and is applicable to different kinds of real-world problems. It’s important to
understand how each one operates, whether it correctly models the behavior needed by a
particular problem area, whether it will operate efficiently to perform the operations, and
whether it can "scale" well. We say a data structure or algorithm scales well if it will per-
form as efficiently as possible as the amount of data grows.

Overview of Data Structures

As we’ve discussed, not every data structure models every type of problem. Or perhaps a
better way to put it is that the structures model the problem awkwardly or inefficiently.
You can generalize the data structures somewhat by looking at the common operations
that you are likely to do across all of them. For example, to manage the requests for tick-
ets, you need to

▶▶ Add a new phone number (for someone who wants one or more tickets)

▶▶ Remove a phone number (for someone who later decides they don’t want tickets)

▶▶ Find a particular phone number (the next one to get a ticket by some method, or to
look up one by its characteristics)

▶▶ List all the phone numbers (show all the phone numbers exactly once, that is, with-
out repeats except, perhaps, for cases where multiple identical entries were made)

These four operations are needed for almost every data structure that manages a large col-
lection of similar items. We call them insertion, deletion, search, and traversal.

Here’s a list of the data structures covered in this book and some of their advantages
and disadvantages with respect to the four operations. Table 1-1 shows a very high-level
view of the structures; we look at them in much more detail in the following chapters.
One aspect mentioned in this table is the data structure’s complexity. In this context,
we’re referring to the structure’s ability to be understood easily by programmers, not how
quickly it can be manipulated by the computer.

9780134855684.indb 4 05/08/22 1:54 PM

 Overview of Data Structures 5

Table 1-1 Comparison of Different Data Types

Data Advantages Disadvantages
Structure
Array Simple. Fast insertion as long as index is Slow search, size must
known. Fast traversal. be known at beginning.
Slow to grow.
Ordered Same as array but quicker search for items if Same as array.
array looking by sort key.
Stack Simple. Fast for last-in, first-out (LIFO) insertion Slow search for items
and deletion. Fast traversal. other than last-in,
first-out.
Queue Moderately complex. Fast for first-in, first-out Slow search for items
(FIFO) insertion and deletion. Fast traversal. other than first-in,
first-out.
Linked list Moderately complex. Fast insertion and deletion Slow search.
for a known position in list. Easy to grow and
shrink. Fast traversal.
Binary tree Moderately complex. Quick search, insertion, Deletion algorithm is
and deletion when tree is balanced. Easy to complex, and balancing
grow and shrink. Fast traversal. can be time-consuming.
Red-Black Quick search, insertion, and deletion. Tree Complex.
tree always balanced. Fast traversal.
2-3-4 tree Quick search, insertion, and deletion. Tree Complex.
always balanced. Similar trees are good for
disk storage. Easy to grow and shrink. Fast
traversal.
Quadtree Quick search, insertion, and deletion by 2 Complex.
dimensional coordinates. Easy to grow and
shrink. Fast traversal.
Hash table Fast search. Fast insertion and quick deletion Complex. Can take
in most cases. more space than
other data structures.
Traversal may be slightly
slower than others.
Heap Moderately complex. Quick insertion and quick Slow search for items
deletion of items in sorted order. Fast traversal. other than minimum or
maximum.
Graph Fast insertion and unordered traversal of nodes Complex. Slow search
and edges (by label) and deletion.
Traversal can be slow
depending on path con-
straints. Can take more
space than other data
structures.

9780134855684.indb 5 05/08/22 1:54 PM

 6 CHAPTER 1  Overview

Overview of Algorithms
Algorithms are ways to implement an operation using a data structure or group of struc-
tures. A single algorithm can sometimes be applied to multiple data structures with each
data structure needing some variations in the algorithm. For example, a depth first search
algorithm applies to all the tree data structures, perhaps the graph, and maybe even stacks
and queues (consider a stack as a tree with branching factor of 1). In most cases, however,
algorithms are intimately tied to particular data structures and don’t generalize easily to
others. For example, the way to insert new items or search for the presence of an item is
very specific to each data structure. We examine the algorithms for insertion, search, dele-
tion, and traversal for all the data structures. That illustrates how much they vary by data
structure and the complexity involved in those structures.

Another core algorithm is sorting, where a collection of items is put in a particular order.
Ordering the items makes searching for items faster. There are many ways to perform sort
operations, and we devote Chapter 3, "Simple Sorting," to this topic, and revisit the prob-
lem in Chapter 7, "Advanced Sorting."

Algorithms are often defined recursively, where part of the algorithm refers to executing
the algorithm again on some subset of the data. This very important concept can simplify
the definition of algorithms and make it very easy to prove the correctness of an imple-
mentation. We study that topic in more detail in Chapter 6, "Recursion."

Some Definitions
This section provides some definitions of key terms.

Database
We use the term database to refer to the complete collection of data that’s being pro-
cessed in a particular situation. Using the example of people interested in tickets, the data-
base could contain the phone numbers, the names, the desired number of tickets, and the
tickets awarded. This is a broader definition than what’s meant by a relational database or
object-oriented database.

Record
Records group related data and are the units into which a database is divided. They pro-
vide a format for storing information. In the ticket distribution example, a record could
contain a person’s name, a person’s phone number, a desired number of tickets, and a
number of awarded tickets. A record typically includes all the information about some
entity, in a situation in which there are many such entities. A record might correspond to
a user of a banking application, a car part in an auto supply inventory, or a stored video
in a collection of videos.

9780134855684.indb 6 05/08/22 1:54 PM

 Some Definitions 7

Field
Records are usually divided into several fields. Each field holds a particular kind of data.
In the ticket distribution example, the fields could be as shown in Figure 1-1.

Name
Phone number
Desired tickets
Awarded tickets

FIGURE 1-1 A record definition for ticket distribution

The fields are named and have values. Figure 1-1 shows an empty box representing the
storage space for the value. In many systems, the type of value is restricted to a single
or small range of data types, just like variables are in many programming languages. For
example, the desired number of tickets could be restricted to only integers, or only non-
negative integers. In object-oriented systems, objects often represent records, and each
object’s attributes are the fields of that record. The terminology can be different in the
various programming languages. Object attributes might be called members, fields, or
variables.

Key
When searching for records or sorting them, one of the fields is called the key (or search
key or sort key). Search algorithms look for an exact match of the key value to some
target value and return the record containing it. The program calling the search routine
can then access all the fields in the record. For example, in the ticket distribution system,
you might search for a record by a particular phone number and then look at the num-
ber of desired tickets in that record. Another kind of search could use a different key. For
example, you could search for a record using the desired tickets as search key and look for
people who want three tickets. Note in this case that you could define the search to return
the first such record it finds or a collection of all records where the desired number of tick-
ets is three.

Databases vs. Data Structures

The collection of records representing a database is going to require a data structure to
implement it. Each record within the database may also be considered a data structure
with its own data organization and algorithms. This decomposition of the data into
smaller and smaller units goes on until you get to primitive data structures like integers,
floating-point numbers, characters, and Boolean values. Not all data structures can be con-
sidered databases; they must support insertion, search, deletion, and traversal of records to
implement a database.

9780134855684.indb 7 05/08/22 1:54 PM

 8 CHAPTER 1  Overview

Programming in Python
Python is a programming language that debuted in 1991. It embraces object-oriented
programming and introduced syntax that made many common operations very concise
and elegant. One of the first things that programmers new to Python notice is that certain
whitespace is significant to the meaning of the program. That means that when you edit
Python programs, you should use an editor that recognizes its syntax and helps you create
the program as you intend it to work. Many editors do this, and even editors that don’t
recognize the syntax by filename extension or the first few lines of text can often be
configured to use Python syntax for a particular file.

Interpreter
Python is an interpreted language, which means that even though there is a compiler,
you can execute programs and individual expressions and statements by passing the text
to an interpreter program. The compiler works by translating the source code of a program
into bytecode that is more easily read by the machine and more efficient to process.
Many Python programmers never have to think about the compiler because the Python
interpreter runs it automatically, when appropriate.
Interpreted languages have the great benefit of allowing you to try out parts of your code
using an interactive command-line interpreter. There are often multiple ways to start a
Python interpreter, depending on how Python was installed on the computer. If you use
an Integrated Development Environment (IDE) such as IDLE, which comes with most
Python distributions, there is a window that runs the command-line interpreter. The
method for starting the interpreter differs between IDEs. When IDLE is launched, it auto-
matically starts the command-line interpreter and calls it the Shell.

On computers that don’t have a Python IDE installed, you can still launch the Python
interpreter from a command-line interface (sometimes called a terminal window, or shell,
or console). In that command-line interface, type python and then press the Return or
Enter key. It should display the version of Python you are using along with some other
information, and then wait for you to type some expression in Python. After reading the
expression, the interpreter decides if it’s complete, and if it is, computes the value of the
expression and prints it. The example in Listing 1-1 shows using the Python interpreter to
compute some math results.

LISTING 1-1 Using the Python Interpreter to Do Math

$ python
Python 3.6.0 (default, Dec 23 2016, 13:19:00)
Type "help", "copyright", "credits" or "license" for more information.
>>> 2019 - 1991
28
>>> 2**32 - 1
4294967295
>>> 10**27 + 1
1000000000000000000000000001

9780134855684.indb 8 05/08/22 1:54 PM

 Programming in Python 9

>>> 10**27 + 1.001

1e+27
>>>

In Listing 1-1, we’ve colored the text that you type in blue italics. The first dollar sign ($) is
the prompt from the command-line interpreter. The Python interpreter prints out the rest
of the text. The Python we use in this book is version 3. If you see Python 2… on the first
line, then you have an older version of the Python interpreter. Try running python3 in the
command-line interface to see if Python version 3 is already installed on the computer. If
not, either upgrade the version of Python or find a different computer that has python3.
The differences between Python 2 and 3 can be subtle and difficult to understand for new
programmers, so it’s important to get the right version. There are also differences between
every minor release version of Python, for example, between versions 3.8 and 3.9. Check
the online documentation at https://docs.python.org to find the changes.

The interpreter continues prompting for Python expressions, evaluating them, and print-
ing their values until you ask it to stop. The Python interpreter prompts for expressions
using >>>. If you want to terminate the interpreter and you’re using an IDE, you typically
quit the IDE application. For interpreters launched in a command-line interface, you can
press Ctrl-D or sometimes Ctrl-C to exit the Python interpreter. In this book, we show
all of the Python examples being launched from a command line, with a command that
starts with $ python3.

In Listing 1-1, you can see that simple arithmetic expressions produce results like other
programming languages. What might be less obvious is that small integers and very large
integers (bigger than what fits in 32 or 64 bits of data) can be calculated and used just
like smaller integers. For example, look at the result of the expression 10**27 + 1. Note
that these big integers are not the same as floating-point numbers. When adding integers
and floating-point numbers as in 10**27 + 1.0001, the big integer is converted to floating-
point representation. Because floating-point numbers only have enough precision for a
fixed number of decimal places, the result is rounded to 1e+27 or 1 × 1027.

Whitespace syntax is important even when using the Python interpreter interactively.
Nested expressions use indentation instead of a visible character to enclose the expressions
that are evaluated conditionally. For example, Python if statements demarcate the then-
expression and the else-expression by indentation. In C++ and JavaScript, you could write

if (x / 2 == 1) {do_two(x)}
else {do_other(x)}

The curly braces enclose the two expressions. In Python, you would write

if x / 2 == 1:
do_two(x)
else:
do_other(x)

9780134855684.indb 9 05/08/22 1:54 PM

 10 CHAPTER 1  Overview

You must indent the two procedure call lines for the interpreter to recognize their relation
to the line before it. You must be consistent in the indentation, using the same tabs or
spaces, on each indented line for the interpreter to know the nested expressions are at the
same level. Think of the indentation changes as replacements for the open curly brace and
the close curly brace. When the indent increases, it’s a left brace. When it decreases, it is a
right brace.

When you enter the preceding expression interactively, the Python interpreter prompts
for additional lines with the ellipsis prompt (…). These prompts continue until you enter
an empty line to signal the end of the top-level expression. The transcript looks like this,
assuming that x is 3 and the do_other() procedure prints a message:

>>> if x / 2 == 1:
... do_two(x)
... else:
... do_other(x)
...
Processing other value
>>>

Note, if you’ve only used Python 2 before, the preceding result might surprise you,
and you should read the details of the differences between the two versions at
https://docs.python.org. To get integer division in Python 3, use the double slash (//)
operator.

Python requires that the indentation of logical lines be the same if they are at the same
level of nesting. Logical lines are complete statements or expressions. A logical line might
span multiple lines of text, such as the previous if statement. The next logical line to be
executed after the if statement’s then or else clause should start at the same indentation
as the if statement does. The deeper indentation indicates statements that are to be exe-
cuted later (as in a function definition), conditionally (as in an else clause), repeatedly (as
in a loop), or as parts of larger construct (as in a class definition). If you have long expres-
sions that you would prefer to split across multiple lines, they either

▶▶ Need to be inside parentheses or one of the other bracketed expression types (lists,
tuples, sets, or dictionaries), or

▶▶ Need to terminate with the backslash character (\) in all but the last line of the
expression

Inside of parentheses/brackets, the indentation can be whatever you like because the
closing parenthesis/bracket determines where the expression ends. When the logical line
containing the expression ends, the next logical line should be at the same level of inden-
tation as the one just finished. The following example shows some unusual indentation to
illustrate the idea:

9780134855684.indb 10 05/08/22 1:54 PM

 Programming in Python 11

>>> x = 9
>>> if (x %
... 2 == 0):
... if (x %
... 3 == 0):
... 'Divisible by 6'
... else:
... 'Divisible by 2'
... else:
... if (x %
... 3 == 0):
... 'Divisible by 3'
... else:
... 'Not divisble by 2 or 3'
...
'Divisible by 3'

The tests of divisibility in the example occur within parentheses and are split across lines
in an arbitrary way. Because the parentheses are balanced, the Python interpreter knows
where the if test expressions end and doesn’t complain about the odd indentation. The
nested if statements, however, must have the same indentation to be recognized as being
at equal levels within the conditional tests. The else clauses must be at the same indenta-
tion as the corresponding if statement for the interpreter to recognize their relationship.
If the first else clause is omitted as in the following example,

>>> if (x %
... 2 == 0):
... if (x %
... 3 == 0):
... 'Divisible by 6'
... else:
... if (x %
... 3 == 0):
... 'Divisible by 3'
... else:
... 'Not divisble by 2 or 3'
...
'Divisible by 3'

then the indentation makes clear that the first else clause now belongs to the
if (x % 2 == 0) and not the nested if (x % 3 == 0). If x is 4, then the statement
would evaluate to None because the else clause was omitted. The mandatory indentation
makes the structure clearer, and mixing in unconventional indentation makes the
program very hard to read!

9780134855684.indb 11 05/08/22 1:54 PM

 12 CHAPTER 1  Overview

Whitespace inside of strings is important and is preserved. Simple strings are enclosed in
single (’) or double (") quote characters. They cannot span lines but may contain escaped
whitespace such as newline (\n) or tab (\t) characters, e.g.,

>>> "Planck's constant:\n quantum of action:\t6.6e-34"

"Planck's constant:\n quantum of action:\t6.6e-34"
>>> print("Planck's constant:\n quantum of action:\t6.6e-34")
Planck's constant:
quantum of action: 6.6e-34

The interpreter reads the double-quoted string from the input and shows it in printed rep-
resentation form, essentially the same as the way it would be entered in source code with
the backslashes used to escape the special whitespace. If that same double-quoted string
is given to the print function, it prints the embedded whitespace in output form. To cre-
ate long strings with many embedded newlines, you can enclose the string in triple quote
characters (either single or double quotes).

>>> """Python
... enforces readability
... using structured
... indentation.
... """
'Python\nenforces readability\nusing structured\nindentation.\n'

Long, multiline strings are especially useful as documentation strings in function

definitions.

You can add comments to the code by starting them with the pound symbol (#) and con-
tinuing to the end of the line. Multiline comments must each have their own pound sym-
bol on the left. For example:

def within(x, lo, hi): # Check if x is within the [lo, hi] range
return lo <= x and x <= hi # Include hi in the range

We’ve added some color highlights to the comments and reserved words used by Python
like def, return, and and, to improve readability. We discuss the meaning of those terms
shortly. Note that comments are visible in the source code files but not available in the
runtime environment. The documentation strings mentioned previously are attached to
objects in the code, like function definitions, and are available at runtime.

Dynamic Typing
The next most noticeable difference between Python and some other languages is that
it uses dynamic typing. That means that the data types of variables are determined at
runtime, not declared at compile time. In fact, Python doesn’t require any variable decla-
rations at all; simply assigning a value to a variable identifier creates the variable. You can
change the value and type in later assignments. For example,

9780134855684.indb 12 05/08/22 1:54 PM

 Programming in Python 13

>>> x = 2
>>> x
2
>>> x = 2.71828
>>> x
2.71828
>>> x = 'two'
>>> x
'two'

The assignment statement itself doesn’t return a value, so nothing is printed after each
assignment statement (more precisely, Python’s None value is returned, and the interpreter
does not print anything when the typed expression evaluates to None). In Python 3.8, a
new operator, :=, was introduced that allows assignment in an expression that returns a
value. For example, evaluating

(x := 2) ** 2 + (y := 3) ** 2

sets x to be 2 and y to be 3 and returns 13 as a value.

The type of a variable’s value can be determined by the type() function or tested using
the isinstance() function.

Sequences
Arrays are different in Python than in other languages. The built-in data type that "looks
like" an array is called a list. Python’s list type is a hybrid of the arrays and linked lists
found in other languages. As with variables, the elements of Python lists are dynamically
typed, so they do not all have to be of the same type. The maximum number of elements
does not need to be declared when creating a list, and lists can grow and shrink at
runtime. What’s quite different between Python lists and other linked list structures is
that they can be indexed like arrays to retrieve any element at any position. There is no
data type called array in the core of Python, but there is an array module that can be
imported. The array module allows for construction of arrays of fixed-typed elements.

In this book, we make extensive use of the built-in list data type as if it were an array.
This is for convenience of syntax, and because the underlying implementation of the list
acts like arrays do in terms of indexed access to elements. Please note, however, that we
do not use all of the features that the Python list type provides. The reason is that we
want to show how fixed-type, fixed-length arrays behave in all computer languages. For
new programmers, it’s better to use the simpler syntax that comes with the built-in list
for constructing arrays while learning how to manipulate their contents in an algorithm.

Python’s built-in lists are indexed using 0-relative indexes. For example:

>>> a = [1, 'a', False]

>>> a
[1, 'a', False]

9780134855684.indb 13 05/08/22 1:54 PM

 14 CHAPTER 1  Overview

>>> len(a)
3
>>> a[2]
False
>>> a[2] = True
>>> a
[1, 'a', True]
>>>

The three-element list in the example contains an integer, a string, and a Boolean value.
The square brackets are used either to create a new list (as in the first assignment to a) or
to enclose the index of an existing list (as in a[2]). The built-in len() function is used to
determine the current size of its argument. Individual values in the list can be changed
using the assignment statement. Strings can be treated like lists or arrays of characters,
except that unlike lists, strings are immutable, meaning that after a string is created, the
characters of the string cannot be changed. In Python 3, strings always contain Unicode
characters, which means there can be multiple bytes per character.

>>> s = 'π = 3.14159'

>>> s
'π = 3.14159'
>>> len(s)
11
>>> π = 3.14159
>>> π
3.14159

In the preceding example, the string, s, contains the Greek letter π, which is counted as
one character by the len() function, whereas the Unicode character takes two bytes of
space. Unicode characters can also be used in variable names in Python 3 as shown by
using π as a variable name.

Python treats all the data types that can be indexed, such as lists, arrays, and strings, as
sequence data types. The sequence data types can be sliced to form new sequences.
Slicing means creating a subsequence of the data, which is equivalent to getting a sub-
string for strings. Slices are specified by a start and end index, separated by a colon (:)
character. Every element from the start index up to, but not including, the end index
is copied into the new sequence. The start index defaults to 0, the beginning of the
sequence, and the end index defaults to the length of the sequence. You can use negative
numbers for both array and slice indexes. Negative indices count backwards from the end
of the sequence; –1 means the last element, –2 means the second to last element, and so
on. Here are some examples with a string:

>>> digits = '0123456789'

>>> digits[3]
'3'

9780134855684.indb 14 05/08/22 1:54 PM

 Programming in Python 15

>>> digits[-1]
'9'
>>> digits[-2]
'8'
>>> digits[3:6]
'345'
>>> digits[:-2]
'01234567'

Sequence data types can be concatenated, multiplied, searched, and enumerated.

These operations sometimes require more function calls in other languages, but Python
provides simple syntax to perform them. For example:

>>> [1, 2, 3] + ['a', 'b']

[1, 2, 3, 'a', 'b']
>>> '011' * 7
'011011011011011011011'
>>> '011' * 0
''
>>> 3 in [1, 2, 3]
True
>>> 'elm' in ['Elm', 'Asp', 'Oak']
False

The preceding example shows two lists concatenated with the plus (+) operator to form
a longer list. Multiplying a string by an integer produces that many copies of the string,
concatenated together. The in operator is a Boolean test that searches for an element in
a sequence. It uses the == equality test to determine whether the element matches. These
operations work with all sequence data types. This compact syntax hides some of the
complexity of stepping through each sequence element and doing some operation such as
equality testing or copying the value over to a new sequence.

Looping and Iteration

Frequently we want to implement algorithms that process each of the elements of
a sequence in order. For that, Python has several ways to iterate and enumerate
sequences. For example:

>>> total = 0
>>> for x in [5, 4, 3, 2, 1]:
... total += x
...
>>> total
15

9780134855684.indb 15 05/08/22 1:54 PM

 16 CHAPTER 1  Overview

The for variable in sequence syntax is the basic loop construct (or iteration) in Python.
The nested expression is evaluated once for each value in the sequence with the vari-
able bound to the value. There is no need to explicitly manipulate an index variable that
points to the current element of the sequence; that’s handled by the Python interpreter.
One common mistake when trying to enter this expression in the interactive interpreter is
to forget the empty line after the nested expression.

>>> total = 0
>>> for x in [5, 4, 3, 2, 1]:
... total += x
... total
File "<stdin>", line 3
total
^
SyntaxError: invalid syntax

The reason this is so common is that the empty line is needed only for the interactive
interpreter; the same Python expressions written in a file would not report this as an error.
The interactive interpreter, however, waits for the empty line to signal the end of the
for loop and begin evaluation of that full expression. When the interpreter finds a new
expression starting at the same indent level as the for loop, it is dealing with two con-
secutive expressions and does not allow it. The interpreter expects to read one expression,
evaluate it, and print the value, before starting to determine where the next expression
begins and ends.

In some circumstances, having an explicit index variable is important. In those cases,

there are a couple of convenient ways to perform the work. For example:

>>> height = [5, 4, 7, 2, 3]

>>> weightedsum = 0
>>> for i in range(len(height)):
... weightedsum += i * height[i]
...
>>> weightedsum
36
>>> for i, h in enumerate(height):
... weightedsum += i * h
...
>>> weightedsum
72

The example calculates a weighted sum where we multiply each value in the height list
by the index of that value. The range() function can be thought of as a function that
produces a list of integers starting at 0 and going up to, but not equal to, its argument. By
passing len(height) as an argument, range() produces the list [0, 1, 2, 3, 4]. In the

9780134855684.indb 16 05/08/22 1:54 PM

 Programming in Python 17

body of the first for loop, the weightedsum variable is incremented by the product of
the index, i, and the value that i indexes in the height list. The second for loop repeats
the same calculation using a slightly more concise form called enumeration. The
enumerate() function can be thought of as taking a sequence as input and producing a
sequence of pairs. The first element of each pair is an index, and the second is the corre-
sponding value from its sequence argument. The second for loop has two variables sepa-
rated by a comma, i and h, instead of just one as in the previous loops. On each iteration
of the enumerate loop, i is bound to the index and h is bound to the corresponding value
from height. Python makes the common pattern of looping over a sequence very easy to
write, both with or without an index variable.

The range() and enumerate() functions actually create iterators, which are complex data
types that get called in each loop iteration to get the next value of the sequence. It doesn’t
actually produce a list in memory for the full sequence. We discuss how iterators can be
used to represent very long sequences without taking up much memory in Chapter 5,
"Linked Lists."

Multivalued Assignment
The comma-separated list of variables can also be used in assignment statements to per-
form multiple assignments with a single equal sign (=) operator. This makes the most
sense when all the values being assigned are closely related, like coordinates of a vector.
To illustrate:

>>> x, y, z = 3, 4, 5
>>> y
4
>>> (x, y, z) = [7, 8, 9]
>>> y
8

The sequences on both sides of the assignment operator must have the same length; oth-
erwise, an error occurs. The sequences can be of different types. The second assignment
here uses a tuple on the left and a list on the right side. Python’s tuple data type is also a
sequence data type very similar to a list, with the distinction that its elements cannot be
modified. In this case, the tuple on the left must be a tuple of variable names. The comma
is the operator that creates the tuple of the x, y, and z variables. Each of them is bound to
the corresponding value in the list on the right. Looking back at the enumerate loop in
the previous example, the iterations of the loop are performing the equivalent of

>>> i, h = (0, 5)
>>> weightedsum += i * h
>>> i, h = (1, 4)
>>> weightedsum += i * h
>>> i, h = (2, 7)

9780134855684.indb 17 05/08/22 1:54 PM

 18 CHAPTER 1  Overview

>>> weightedsum += i * h
>>> i, h = (3, 2)
>>> weightedsum += i * h
>>> i, h = (4, 3)
>>> weightedsum += i * h

Python’s multivalued assignments can be used to swap or rotate values. That can be a
surprise to programmers of other languages where an explicit temporary variable must be
used to hold one or more of the values. For example:

>>> left, middle, right = 'Elm', 'Asp', 'Oak'

>>> left, middle, right
('Elm', 'Asp', 'Oak')
>>> left, middle, right = middle, right, left
>>> left, middle, right
('Asp', 'Oak', 'Elm')

The Python interpreter evaluates all the expressions on the right of the equal sign, puts
the results in a tuple, and then makes the assignments to the variables on the left side
from the tuple. The tuple holding the results is something like a hidden temporary vari-
able. The parentheses surrounding the tuples on both sides of the equal sign operator are
optional.

There is another kind of assignment statement that looks like the multivalued assignment
but is different. You use it to assign the same value to multiple variables. For example:

>>> left = middle = right = 'Gum'

>>> left, middle, right
('Gum', 'Gum', 'Gum')

Several variables are all assigned the same value. The overall assignment statement, how-
ever, still evaluates as None.

Importing Modules
Functions can return multiple values in the form of tuples, too. You can decide whether
to store all these values as a single tuple, or in several variables, one for each of the tuple’s
elements, just like the multivalued assignment does. A good example of this is splitting
pathname components. The os module is in Python’s standard library and provides many
tools to operate on the underlying operating system where Python is running. To access a
module, you import it. After it is imported, you refer to its contents via the module name,
followed by a period, and then the name of one of its functions or other definitions. For
example:

>>> import math

>>> math.pi
3.141592653589793

9780134855684.indb 18 05/08/22 1:54 PM

 Programming in Python 19

>>> import os
>>> os.path.splitext('myfile.ext')
('myfile', '.ext')
>>> filename, extension = os.path.splitext('myfile.ext')
>>> extension
'.ext'

The import statement creates a namespace for all the objects it defines. That’s impor-
tant to avoid conflicts between a variable or function that you define and the one in the
module. In the preceding example, the value for pi is stored in the math namespace. If
you have a separate definition, say an approximation like pi = 3.1, your program can
refer to each one without confusion. The os module has submodules, one of which is the
path module. Nested submodules create nested namespaces with corresponding names
separated by periods. The os.path.splitext() function splits a filename at the last period
and returns the two parts as a tuple. The preceding example shows binding that result to
two variables, filename and extension, and then shows the value of the extension. Occa-
sionally, you may call a function that returns multiple values without needing to retain
all of them. Some Python programmers like to use the simplest variable name, a single
underscore (_), as a throwaway variable. For instance, if only the filename extension was
needed, you could write

_, extension = os.path.splitext('myfile.ext')

Functions and Subroutines

Of course, the core of all programming languages is the ability to define functions and
subroutines. In Python, they are defined with the def statement. The parameters the func-
tion accepts are provided in a list of variables. Parameters can be mandatory or optional;
the optional ones must have a default value to use when they are missing. The def state-
ment has the name of the function, the parameter list in parentheses, a colon, followed
by a nested expression that is the body of the routine. If it is a function, the body should
contain one or more return statements for the value to be returned. Subroutines in other
programming languages do not return values. In Python, all functions and subroutines
return something, but if no explicit return value is provided in the body of a def state-
ment, then the value returned is None.

Here’s an implementation of a weighted sum function. It takes a sequence of weights and

a sequence of values. If the weights sequence is shorter than that of the values, it uses the
missing value as the default weight.

>>> def weightedsum(values, weights, missing=0):

... sum = 0
... for i, val in enumerate(values):
... sum += val * (weights[i] if i < len(weights) else missing)
... return sum
...

9780134855684.indb 19 05/08/22 1:54 PM

Random documents with unrelated
content Scribd suggests to you:
Baked toast 208
Batter for fruit fritters 207
Boiled eggs 200
Boiled hominy 211
Bread, fried 206
Bread omelet 205
Breaded eggs 202
Broiled apples 213
Corn meal mush 210
Cracker cream toast 209
Cranberry jelly 213
Cranberry sauce 215
Creamed eggs 202
Dumplings 215
Eggs au gratin 201
Eggs, baked 202
Eggs, boiled 200
Eggs, breaded 202
Eggs, creamed 202
Egg cutlets 203
Eggs, fried 201
Eggs, poached 200
Eggs scrambled 201
Evaporated apple sauce 213
Evaporated apricots 214
Evaporated peaches 214
Fried apples 213
Fried bread 206
Fried eggs 201
Fried hominy 211
Fried mush 210
Fritters, apple 207
Fruit fritters, batter for 207
Fruit sauces 212
Green apple sauce 213
Hominy, boiled 211
Hominy cakes 211
Hominy, fried 211
Maple syrup from sugar 207
Milk toast 208
Mush 209
Mush, corn meal 210
Mush, fried 210
Oatmeal mush 210
Omelet, baked 205
Omelet, plain 203
Oyster crackers, roasted 206
Peaches, evaporated 214
Pears, baked 214
Plain omelet 203
Poached eggs 200
Prunes, stewed 214
Rarebit, Welsh 206
Rhubarb sauce 215
Roasted oyster crackers 206
Scrambled eggs 201
Soft butter toast 208
Stewed prunes 214
Sweet apples, baked 212
Syrup, maple, from sugar 207
Toast, baked 208
Toast, cracker cream 209
Toast, milk 208
Toast, soft butter 208
Welsh rarebit 206

BREAD IN VARIOUS FORMS.

Introduction 217
Baking powder biscuit 226
Baking powder griddle cakes 236
Baltimore hominy bread 234
Biscuit, baking powder 226
Blueberry griddle cakes 237
Blueberry muffins 232
Boston brown bread 222
Bread, Baltimore hominy 234
Bread, corn 233
Bread dough, rolls from 223
Bread, entire-wheat 221
Bread, graham 221
Bread griddle cakes 238
Bread made with dry yeast 219
Bread, pulled 223
Bread, rye 222
Bread, steamed Indian 223
Bread, water 220
Buckwheat cakes 235
Buttermilk or sour milk muffins 230
Cakes, baking powder griddle 236
Cakes, blueberry griddle 237
Cakes, bread griddle 236
Cakes, buckwheat 235
Cakes, sour milk graham griddle 236
Cakes, ground rice griddle 237
Cakes, hominy griddle 236
Cakes, hominy, with sour milk, griddle 237
Cakes, raised flannel 238
Cakes, sour milk griddle 235
Cakes, sour milk Indian griddle 236
Corn bread 233
Corn cake, spider 233
Corn dodgers 234
Cream of tartar muffins 232
Crumpets 227
Dry yeast, bread made with 219
Entire-wheat bread 221
Flour pop-overs 228
Gems, wheat 229
Graham bread 221
Graham muffins 231
Graham muffins with sour milk 231
Graham pop-overs 229
Griddle cakes, bread 238
Griddle cakes, baking powder 236
Griddle cakes, blueberry 237
Griddle cakes, ground rice 237
Griddle cakes, hominy 236
Griddle cakes, hominy, with sour milk 237
Griddle cakes, sour milk 235
Griddle cakes, sour milk graham 236
Griddle cakes, sour milk Indian 236
Ground rice griddle cakes 237
Hominy griddle cakes 236
Hominy griddle cakes with sour milk 237
Hominy waffles 240
Hop yeast 218
Luncheon rolls 226
Milk rolls 225
Muffins, blueberry 232
Muffins, buttermilk or sour milk 230
Muffins, cream of tartar 232
Muffins, graham 231
Muffins, graham with sour milk 231
Muffins, raised wheat 230
Muffins, rye 231
Muffins, rye, with sour milk 231
Muffins, white corn meal 233
Muffins, yellow corn meal 232
Parker House rolls 224
Pin wheels 227
Pop-overs, flour 228
Pop-overs, graham 229
Pulled bread 223
Quick luncheon rolls 227
Raised flannel cakes 238
Raised wheat muffins 230
Raised wheat waffles 240
Rolls from bread dough 223
Rolls, luncheon 226
Rolls, quick luncheon 227
Rolls, milk 225
Rolls, Parker House 224
Rolls, sponge 224
Rye bread 222
Rye muffins 231
Rye muffins, with sour milk 231
Rye pop-overs 229
Sally Lunn 228
Sour milk graham griddle cakes 236
Sour milk griddle cakes 255
Sour milk Indian griddle cakes 236
Sour milk or buttermilk muffins 230
Spider corn cake 233
Sponge rolls 224
Steamed Indian bread 223
Waffles 238
Waffles, hominy 240
Waffles, raised wheat 240
Water bread 220
Wheat gems 229
White corn meal muffins 233
Yeast, hop 218
Yellow corn meal muffins 232

CAKE.
Angel 244
Blackberry jam 242
Blueberry 247
Chocolate icing 252
Clinton doughnuts 249
Cold water 245
Corn starch 244
Dropped doughnuts 250
Gingerbread, maple sugar 248
Gingerbread, soft molasses 248
Gingerbread, soft molasses, No. 2 249
Gingerbread, soft molasses, No. 3 249
Hermits 247
Icing 252
Maple sugar gingerbread 248
Plain cup 245
Plain sponge 243
Raised fruit 241
Rich cup 245
Rich sponge 242
Soft molasses gingerbread 248
Spice 241
Strawberry shortcake 251
Strawberry shortcake, No. 2 251
Swiss 246
Tea 246

PASTRY.
Apple pie, sliced 254
Apple pie, stewed 255
Apple turnovers 259
Berry pies 256
Berry tarts 258
Chocolate pie 258
Cream pie 257
Delicate paste 253
Lemon pie 256
Mince meat 254
Mince pies 255
Peach pie 255
Plain paste 253
Sliced apple pie 254
Squash pie 256
Stewed apple pie 255
Sweet potato pie 257
Washington pie 258

PUDDINGS.
Apple and Indian 262
Apple sponge 263
Apple tapioca 262
Baked apple 261
Baked apple dumplings 261
Baked Indian 271
Baked rice 280
Berry 266
Blackberry 267
Blueberry 265
Blueberry, No. 2 266
Boiled rice 278
Bread 272
Caramel 276
Chester 269
Chocolate 275
Chocolate, No. 2 275
Cocoanut 277
Cold farina 280
Cold rice 279
Corn starch 276
Cottage 273
Cream 274
Custard 277
Dumplings, baked apple 262
Dumplings, steamed apple 262
English rice 280
Farina, cold 280
Farina fruit 281
Farina, hot 280
Graham 270
Hot farina 280
Indian and apple 262
Jam 268
Lemon 273
Little fruit 265
Mock Indian 272
Oatmeal 278
Orange snow 283
Peach tapioca 263
Plum 269
Prune 263
Prune tapioca 264
Quick steamed apple 261
Quiver 268
Raspberry tapioca 264
Rhubarb 267
Rice balls 279
Rose 281
Snow 282
Snow, No. 2 282
Snow blancmange 283
Sponge 273
Sponge apple 263
Steamed apple 260
Steamed apple dumplings 262
Steamed batter 268
Steamed black 267
Steamed Indian 271
Steamed Indian and apple 271
Steamed Indian berry 271
Tapioca 278
Tapioca prune 264
Tapioca raspberry 264
Turkish 270
Wayne 270

PUDDING SAUCES.
Cinnamon 286
Clear 286
Clear lemon 286
Creamy 284
Egg 285
Foaming 284
Fruit 285
Golden 287
Hot cream 288
Italian 287
Molasses 285
Nutmeg 286
Vinegar 285
Wine 284

SWEETS.
Apricot ice 299
Baked cup custards 290
Blackberry jelly 294
Blancmange, chocolate 292
Blancmange, moss 292
Blancmange, sea moss farina 292
Chocolate ice cream 297
Cider jelly 293
Coffee jelly 294
Cup custards, baked 290
Cup custards, steamed 290
Custard, soft 289
Directions for freezing 295
Lemon jelly 293
Lemon sherbet 298
Milk sherbet 298
Moss blancmange 292
Orange jelly 294
Orange sherbet 298
Peach ice 299
Peach ice cream 297
Pistachio ice cream 297
Raspberry jelly 294
Rennet custard 290
Sea moss farina blancmange 292
Slip 291
Soft custard 289
Steamed cup custards 290
Strawberry Bavarian cream 291
Strawberry ice cream 297
Strawberry jelly 294
Tapioca custard 290
Vanilla ice cream 296
Wine jelly 293

BEVERAGES.
Boiled coffee 302
Breakfast cocoa 304
Broma 304
Chocolate 304
Cocoa 304
Cocoa shells and nibs 306
Coffee 301
Filtered coffee 302
Lemonade 306
Tea 300

PRESERVES AND PICKLES.

Blackberry jam 314
Canadian tomato pickle 320
Canned rhubarb 314
Canned tomatoes 322
Canning fruits 311
Catsup, tomato 321
Covering jellies 316
Crab apples 308
Crab apple jelly 318
Crab apple, spiced 323
Cucumber pickles 318
Currant and raisin jam 315
Currant jelly 316
Currant jelly, No. 2 317
Currants, spiced 322
Different fruits need different treatment 312
Filling the jars 312
Governor’s sauce 321
Grape preserve 309
Jam, blackberry 314
Jam, raisin and currant 315
Jam, raspberry 314
Jellies 315
Jelly, currant 316
Other jellies 318
Peaches, preserved 307
Pear marmalade 315
Pears, preserved 308
Piccalilli 323
Pickle, tomato 320
Pickles, cucumber 318
Pineapple, preserved 310
Pineapple, uncooked, preserved 310
Preserved peaches 307
Preserved pears 308
Preserved pineapple 310
Preserved uncooked pineapple 310
Preserved plums 309
Preserved quinces 309
Pulp of fruit, what to do with it 307
Quality of the fruit 307
Raspberry jam 314
Rhubarb, canned 314
Small fruits, how to can 313
Spiced crab apple 323
Spiced currants 322
Sun cooked strawberries 311
Sweet cucumber pickles 319
Tomatoes, canned 322
Tomato catsup 321
Tomato pickle 320
What to do with fruit pulp 307

FOR THOSE WHO LIVE ON FARMS.

Introduction 324
Bacon, to cure breakfast 328
Butter making 335
Cheese, cottage 335
Cheese, hogs’ head 330
Chine and jowl, to cure 328
Chine pillau 329
Corned shoulder of mutton 326
Corning, how to prepare meat for 325
Cottage cheese 335
Cream, care of 334
Dairy, the 334
English sausage meat 328
Essence of rennet 333
Hams, to cure 327
Hogs’ head cheese 330
Jowl and chine, to cure 328
Jowl, to cook 329
Lard, how to render 320
Milk, care of 334
Mutton, corned shoulder of 326
Pickle for any kind of meat 326
Pickle for tongues 326
Pigs’ feet 332
Pillau, chine 329
Rennet, essence of 333
Rennet, to preserve 332
Rennet wine 333
Sausage meat 328
Sausage meat, English 328
Scrapple 331
Soused tripe 332
Tongues, pickle for 326
Tripe 332
Wine, rennet 333

CARE OF THE SICK.

Introduction 338
Apple water 348
Arrowroot gruel 347
Barley water 348
Bathing 339
Beef juice 345
Beef tea 344
Broth, mutton 341
Camphorated oil 351
Cleanliness and ventilation 329
Cold in the head, remedy for 351
Cracked ice, to keep 341
Cracker gruel 347
Crust coffee 349
Custard, mutton 343
Eggnog 348
Egg tea 349
Flour gruel 346
For a cold in the head 351
Gargle for a sore throat 351
Gruel, arrowroot 347
Gruel, cracker 347
Gruel, flour 346
Gruel, Indian meal 346
Gruel, oatmeal 346
Ice, cracked, to keep 341
Ice, to break in a sick room 341
Indian meal gruel 346
Jelly, restorative 350
Lemonade, moss 349
Lime water 351
Milk punch 347
Moss lemonade 349
Mutton broth 341
Mutton custard 343
Neuralgia, to relieve 340
Oatmeal gruel 346
Oyster roast 343
Oysters roasted in the shell 343
Oysters, steamed 343
Prunes, senna 350
Punch, milk 347
Raw beef sandwiches 345
Restorative jelly 350
Rice water 348
Roast oysters 343
Roasted oysters, in the shell 343
Round steak 345
Sandwiches, raw beef 345
Senna prunes 350
Sore throat, a gargle for 351
Steak, round 345
Steamed oysters 343
Tea, beef 344
Tea, egg 349
Turpentine applications 340
Ventilation and cleanliness 339
Wine whey 349

WHEN CLEANING HOUSE.

Introduction 352
Carpets, laying the 357
Carpets, taking up and cleaning 355
Cleaning the cellar 353
Dusting 356
From cellar to attic 354
Kitchen, pantry, and closets 359
Rooms on the first floor 358
Sweeping 356
System absolutely necessary 352
Washing painted surfaces 356
Whitewashing, importance of 354

ODD BITS OF USEFUL KNOWLEDGE.

A word regarding stains 371
About whipping cream 364
Acids, what to do if they are spilled 377
Alcohol for grass stains 376
Ants, how to drive away 387
Bouquet of sweet herbs, how to make 367
Brass, how to clean 383
Bread, to freshen 367
Bread crumbs, how to prepare 365
Breading articles for frying 365
Brightening leather furniture 379
Brushes, to clean 381
Burning accidents, what to do in case of 368
Cake, to freshen 367
Care of straw matting 381
Care of the hands 387
Cement for china 384
Chandeliers, keeping flies from 387
Chimney, what to do when it is cold 385
Cleaning brass 383
Cleaning chamois skins 381
Cleaning dress silks and ribbons 380
Cleaning fluid, a good 378
Coffee, tea, or wine stains on linen 374
Cold cream 388
Colors, restoring 377
Conveniences when sweeping 383
Cream, about whipping 364
Crumbs, how to prepare 365
Cupfuls, half-pints, and gills 388
Driving away ants 387
Equivalents of measures in weight 389
Flies, to keep away from chandeliers 387
Flour, difference in various brands 361
Flour paste 368
Fruit stains, treatment of 373
Frying, breading articles for 365
Furniture, to remove stains from 382
Getting rid of the odor of onions 366
Grass stains, alcohol for 376
Grease spots on wall paper, treatment of 378
Grease spots, to remove 371
Grease, to take from wood and stone 372
Handles of knives and forks, how to fasten 384
Hands, the care of 387
Heat of the oven, how to test 386
Herbs, sweet, making a bouquet of 367
How to prepare bread crumbs 365
Iron and earthen ware, to temper 367
Iron rust, the best way to remove 374
Javelle water, how to make 377
Kid, to prevent from cracking 385
Leather furniture, to brighten 379
Marble, removing stains from 373
Matting, care of 381
Measures, equivalents of, in weight 389
Mending breaks in plaster 383
Meringue, to prevent from falling 367
Mildewed clothes, treatment of 374
Muriatic acid for stains on porcelain 376
Naphtha, use of, in the household 369
Oil, value of a drop of 385
Onions, getting rid of the odor of 366
Onion juice, ways to get 366
Oven heat, testing with paper 386
Oven thermometers 386
Paint, to remove 376
Paper, soiled, how to clean 378,
379
Paste, flour 368
Pitch and tar, to remove 375
Plaster, mending breaks in 383
Points of difference in various brands of flour 361
Porcelain, stains on, how to remove 376
Preventing a meringue from falling 367
Preventing silks and woollens from turning yellow 380
Raisins, how to stone 366
Removing blood stains 375
Removing ink stains 376
Removing iron rust 374
Removing sewing-machine oil stains 375
Removing stains from marble 373
Restoring colors 377
Ridding the house of water bugs 386
Silk goods, to keep from turning yellow 380
Soiled paper, stale bread for cleaning 379
Stains, a word regarding 371
Stains, fruit, treatment of 373
Stains on linen,—coffee, tea, or wine 374
Stains on porcelain, muriatic acid for 376
Stains, removing ink 376
Stale bread for cleaning soiled paper 379
Stoning raisins in an easy manner 366
Straw matting, care of 381
Sweeping, conveniences to use when 383
Sweet herbs, making a bouquet of 367
Tar, how to remove 375
Testing the oven heat with paper 386
Thermometers, oven 386
To clean brushes 381
To clean woods in natural finish 382
To freshen bread and cake 367
To make Javelle water 377
To prevent kid from cracking 385
To remove grease spots 371
To remove paint 376
To remove pitch and tar 375
To remove white stains from furniture 382
To take grease from wood and stone 372
To temper iron and earthen ware 367
Use of naphtha in the household 369
Value of a drop of oil 385
Various brands of flour, points of difference in 361
Wall paper, treatment of grease spots on 378
Wall paper, two ways to repair 379
Water bugs, ridding the house of 386
Ways to get onion juice 366
What to do when burning accidents occur 368
What to do when the chimney is cold 385
When and why soda, cream of tartar, and baking 363
powders are used
When acids are spilled 377
When clothes become mildewed 374
Woollen goods, to keep from turning yellow 380
 Transcriber’s note:

All instances of ‘Bechamel’ and ‘Bechémal’ changed to ‘Béchamel’

Page 12, full stop inserted after ‘handled,’ “Dipper, long-handled.”
Page 12, ‘Dishcloths’ changed to ‘Dish-cloths,’ “Dish-cloths, two,
—one being of”
Page 66, ‘lamb’s’ changed to ‘lambs’,’ “and lambs’ livers are
delicious”
Page 86, em-dash changed to space after ‘salt,’ “1 teaspoonful of
salt, generous.”
Page 96, ‘white-fish’ changed to ‘whitefish,’ “bluefish. Whitefish,
like cod”
Page 134, ‘stew-pan’ changed to ‘stewpan,’ “the bones in a
stewpan and”
Page 149, ‘Syrinkle’ changed to ‘Sprinkle,’ “the little dishes.
Sprinkle the crumbs”
Page 168, ‘strawcolor’ changed to ‘straw-color,’ “turn a light
straw-color.”
Page 206, both instances of ‘rare-bit’ changed to ‘rarebit,’ “Welsh
Rarebit,” “The rarebit can be made”
Page 213, ‘tablepoonful’ changed to ‘tablespoonful,’ “1
tablespoonful of sugar.”
Page 220, em-dash changed to space after ‘water,’ “1/2 pint of
water, generous measure.”
Page 230, ‘muf’ changed to ‘muffins,’ “above, a dozen muffins
can be made”
Welcome to our website – the perfect destination for book lovers and
knowledge seekers. We believe that every book holds a new world,
offering opportunities for learning, discovery, and personal growth.
That’s why we are dedicated to bringing you a diverse collection of
books, ranging from classic literature and specialized publications to
self-development guides and children's books.

More than just a book-buying platform, we strive to be a bridge

connecting you with timeless cultural and intellectual values. With an
elegant, user-friendly interface and a smart search system, you can
quickly find the books that best suit your interests. Additionally,
our special promotions and home delivery services help you save time
and fully enjoy the joy of reading.

Join us on a journey of knowledge exploration, passion nurturing, and

personal growth every day!

ebookbell.com