Learning Algorithms: A Programmer's Guide to Writing Better Code

✍ Scribed by George Heineman

• Publisher: O'Reilly Media
• Year: 2021
• Tongue: English
• Leaves: 281
• Edition: 1
• Category: Library

✦ Synopsis

When it comes to writing efficient code, every software professional needs to have an effective working knowledge of algorithms. In this practical book, author George Heineman (Algorithms in a Nutshell) provides concise and informative descriptions of key algorithms that improve coding in multiple languages. Software developers, testers, and maintainers will discover how algorithms solve computational problems creatively.

Each chapter builds on earlier chapters through eye-catching visuals and a steady rollout of essential concepts, including an algorithm analysis to classify the performance of every algorithm presented in the book. At the end of each chapter, you’ll get to apply what you’ve learned to a novel challenge problem—simulating the experience you might find in a technical code interview.

With this book, you will:
• Examine fundamental algorithms central to computer science and software engineering
• Learn common strategies for efficient problem solving—such as divide and conquer, dynamic programming, and greedy approaches
• Analyze code to evaluate time complexity using big O notation
• Use existing Python libraries and data structures to solve problems using algorithms
• Understand the main steps of important algorithms

✦ Table of Contents

Cover
Copyright
Table of Contents
Foreword
Preface
Who This Book Is For
About the Code
Conventions Used in This Book
O’Reilly Online Learning
How to Contact Us
Acknowledgments
Chapter 1. Problem Solving
What Is an Algorithm?
Finding the Largest Value in an Arbitrary List
Counting Key Operations
Models Can Predict Algorithm Performance
Find Two Largest Values in an Arbitrary List
Tournament Algorithm
Time Complexity and Space Complexity
Summary
Challenge Exercises
Chapter 2. Analyzing Algorithms
Using Empirical Models to Predict Performance
Multiplication Can Be Faster
Performance Classes
Asymptotic Analysis
Counting All Operations
Counting All Bytes
When One Door Closes, Another One Opens
Binary Array Search
Almost as Easy as π
Two Birds with One Stone
Pulling It All Together
Curve Fitting Versus Lower and Upper Bounds
Summary
Challenge Exercises
Chapter 3. Better Living Through Better Hashing
Associating Values with Keys
Hash Functions and Hash Codes
A Hashtable Structure for (Key, Value) Pairs
Detecting and Resolving Collisions with Linear Probing
Separate Chaining with Linked Lists
Removing an Entry from a Linked List
Evaluation
Growing Hashtables
Analyzing the Performance of Dynamic Hashtables
Perfect Hashing
Iterate Over (key, value) Pairs
Summary
Challenge Exercises
Chapter 4. Heaping It On
Max Binary Heaps
Inserting a (value, priority)
Removing the Value with Highest Priority
Representing a Binary Heap in an Array
Implementation of Swim and Sink
Summary
Challenge Exercises
Chapter 5. Sorting Without a Hat
Sorting by Swapping
Selection Sort
Anatomy of a Quadratic Sorting Algorithm
Analyze Performance of Insertion Sort and Selection Sort
Recursion and Divide and Conquer
Merge Sort
Quicksort
Heap Sort
Performance Comparison of O(N log N) Algorithms
Tim Sort
Summary
Challenge Exercises
Chapter 6. Binary Trees: Infinity in the Palm of Your Hand
Getting Started
Binary Search Trees
Searching for Values in a Binary Search Tree
Removing Values from a Binary Search Tree
Traversing a Binary Tree
Analyzing Performance of Binary Search Trees
Self-Balancing Binary Trees
Analyzing Performance of Self-Balancing Trees
Using Binary Tree as (key, value) Symbol Table
Using the Binary Tree as a Priority Queue
Summary
Challenge Exercises
Chapter 7. Graphs: Only Connect!
Graphs Efficiently Store Useful Information
Using Depth First Search to Solve a Maze
Breadth First Search Offers Different Searching Strategy
Directed Graphs
Graphs with Edge Weights
Dijkstra’s Algorithm
All-Pairs Shortest Path
Floyd–Warshall Algorithm
Summary
Challenge Exercises
Chapter 8. Wrapping It Up
Python Built-in Data Types
Implementing Stack in Python
Implementing Queues in Python
Heap and Priority Queue Implementations
Future Exploration
Index
About the Author
Colophon

✦ Subjects

Algorithms; Python; Graph Algorithms; Trees; Heaps; Hashing; Algorithm Analysis; Sorting Algorithms; Dijkstra's Algorithm