Algorithms For Dummies

Document Outline

• Title Page
• Copyright Page
• Table of Contents
• Introduction
  • About This Book
  • Foolish Assumptions
  • Icons Used in This Book
  • Beyond the Book
  • Where to Go from Here
• Part 1 Getting Started
  • Chapter 1 Introducing Algorithms
    • Describing Algorithms
      • Defining algorithm uses
      • Finding algorithms everywhere
    • Using Computers to Solve Problems
      • Leveraging modern CPUs and GPUs
      • Working with special-purpose chips
      • Leveraging networks
      • Leveraging available data
    • Distinguishing between Issues and Solutions
      • Being correct and efficient
      • Discovering there is no free lunch
      • Adapting the strategy to the problem
      • Describing algorithms in a lingua franca
      • Facing hard problems
    • Structuring Data to Obtain a Solution
      • Understanding a computer’s point of view
      • Arranging data makes the difference
  • Chapter 2 Considering Algorithm Design
    • Starting to Solve a Problem
      • Modeling real-world problems
      • Finding solutions and counterexamples
      • Standing on the shoulders of giants
    • Dividing and Conquering
      • Avoiding brute-force solutions
      • Starting by making it simpler
      • Breaking down a problem is usually better
    • Learning that Greed Can Be Good
      • Applying greedy reasoning
      • Reaching a good solution
    • Computing Costs and Following Heuristics
      • Representing the problem as a space
      • Going random and being blessed by luck
      • Using a heuristic and a cost function
    • Evaluating Algorithms
      • Simulating using abstract machines
      • Getting even more abstract
      • Working with functions
  • Chapter 3 Using Python to Work with Algorithms
    • Considering the Benefits of Python
      • Understanding why this book uses Python
      • Working with MATLAB
      • Considering other algorithm testing environments
    • Looking at the Python Distributions
      • Obtaining Analytics Anaconda
      • Considering Enthought Canopy Express
      • Considering pythonxy
      • Considering WinPython
    • Installing Python on Linux
    • Installing Python on MacOS
    • Installing Python on Windows
    • Downloading the Datasets and Example Code
      • Using Jupyter Notebook
      • Defining the code repository
      • Understanding the datasets used in this book
  • Chapter 4 Introducing Python for Algorithm Programming
    • Working with Numbers and Logic
      • Performing variable assignments
      • Doing arithmetic
      • Comparing data by using Boolean expressions
    • Creating and Using Strings
    • Interacting with Dates
    • Creating and Using Functions
      • Creating reusable functions
      • Calling functions
    • Using Conditional and Loop Statements
      • Making decisions using the if statement
      • Choosing between multiple options using nested decisions
      • Performing repetitive tasks using the for loop
      • Using the while statement
    • Storing Data Using Sets, Lists, and Tuples
      • Creating sets
      • Creating lists
      • Creating and using tuples
    • Defining Useful Iterators
    • Indexing Data Using Dictionaries
  • Chapter 5 Performing Essential Data Manipulations Using Python
    • Performing Calculations Using Vectors and Matrixes
      • Understanding scalar and vector operations
      • Performing vector multiplication
      • Creating a matrix is the right way to start
      • Multiplying matrixes
      • Defining advanced matrix operations
    • Creating Combinations the Right Way
      • Distinguishing permutations
      • Shuffling combinations
      • Facing repetitions
    • Getting the Desired Results Using Recursion
      • Explaining recursion
      • Eliminating tail call recursion
    • Performing Tasks More Quickly
      • Considering divide and conquer
      • Distinguishing between different possible solutions
• Part 2 Understanding the Need to Sort and Search
  • Chapter 6 Structuring Data
    • Determining the Need for Structure
      • Making it easier to see the content
      • Matching data from various sources
      • Considering the need for remediation
    • Stacking and Piling Data in Order
      • Ordering in stacks
      • Using queues
      • Finding data using dictionaries
    • Working with Trees
      • Understanding the basics of trees
      • Building a tree
    • Representing Relations in a Graph
      • Going beyond trees
      • Building graphs
  • Chapter 7 Arranging and Searching Data
    • Sorting Data Using Mergesort and Quicksort
      • Defining why sorting data is important
      • Ordering data naïvely
      • Employing better sort techniques
    • Using Search Trees and the Heap
      • Considering the need to search effectively
      • Building a binary search tree
      • Performing specialized searches using a binary heap
    • Relying on Hashing
      • Putting everything into buckets
      • Avoiding collisions
      • Creating your own hash function
• Part 3 Exploring the World of Graphs
  • Chapter 8 Understanding Graph Basics
    • Explaining the Importance of Networks
      • Considering the essence of a graph
      • Finding graphs everywhere
      • Showing the social side of graphs
      • Understanding subgraphs
    • Defining How to Draw a Graph
      • Distinguishing the key attributes
      • Drawing the graph
    • Measuring Graph Functionality
      • Counting edges and vertexes
      • Computing centrality
    • Putting a Graph in Numeric Format
      • Adding a graph to a matrix
      • Using sparse representations
      • Using a list to hold a graph
  • Chapter 9 Reconnecting the Dots
    • Traversing a Graph Efficiently
      • Creating the graph
      • Applying breadth-first search
      • Applying depth-first search
      • Determining which application to use
    • Sorting the Graph Elements
      • Working on Directed Acyclic Graphs (DAGs)
      • Relying on topological sorting
    • Reducing to a Minimum Spanning Tree
      • Discovering the correct algorithms to use
      • Introducing priority queues
      • Leveraging Prim’s algorithm
      • Testing Kruskal’s algorithm
      • Determining which algorithm works best
    • Finding the Shortest Route
      • Defining what it means to find the shortest path
      • Explaining Dijkstra’s algorithm
  • Chapter 10 Discovering Graph Secrets
    • Envisioning Social Networks as Graphs
      • Clustering networks in groups
      • Discovering communities
    • Navigating a Graph
      • Counting the degrees of separation
      • Walking a graph randomly
  • Chapter 11 Getting the Right Web page
    • Finding the World in a Search Engine
      • Searching the Internet for data
      • Considering how to find the right data
    • Explaining the PageRank Algorithm
      • Understanding the reasoning behind the PageRank algorithm
      • Explaining the nuts and bolts of PageRank
    • Implementing PageRank
      • Implementing a Python script
      • Struggling with a naive implementation
      • Introducing boredom and teleporting
      • Looking inside the life of a search engine
      • Considering other uses of PageRank
    • Going Beyond the PageRank Paradigm
      • Introducing semantic queries
      • Using AI for ranking search results
• Part 4 Struggling with Big Data
  • Chapter 12 Managing Big Data
    • Transforming Power into Data
      • Understanding Moore’s implications
      • Finding data everywhere
      • Getting algorithms into business
    • Streaming Flows of Data
      • Analyzing streams with the right recipe
      • Reserving the right data
    • Sketching an Answer from Stream Data
      • Filtering stream elements by heart
      • Demonstrating the Bloom filter
      • Finding the number of distinct elements
      • Learning to count objects in a stream
  • Chapter 13 Parallelizing Operations
    • Managing Immense Amounts of Data
      • Understanding the parallel paradigm
      • Distributing files and operations
      • Employing the MapReduce solution
    • Working Out Algorithms for MapReduce
      • Setting up a MapReduce simulation
      • Inquiring by mapping
  • Chapter 14 Compressing Data
    • Making Data Smaller
      • Understanding encoding
      • Considering the effects of compression
      • Choosing a particular kind of compression
      • Choosing your encoding wisely
      • Encoding using Huffman compression
      • Remembering sequences with LZW
• Part 5 Challenging Difficult Problems
  • Chapter 15 Working with Greedy Algorithms
    • Deciding When It Is Better to Be Greedy
      • Understanding why greedy is good
      • Keeping greedy algorithms under control
      • Considering NP complete problems
    • Finding Out How Greedy Can Be Useful
      • Arranging cached computer data
      • Competing for resources
      • Revisiting Huffman coding
  • Chapter 16 Relying on Dynamic Programming
    • Explaining Dynamic Programming
      • Obtaining a historical basis
      • Making problems dynamic
      • Casting recursion dynamically
      • Leveraging memoization
    • Discovering the Best Dynamic Recipes
      • Looking inside the knapsack
      • Touring around cities
      • Approximating string search
  • Chapter 17 Using Randomized Algorithms
    • Defining How Randomization Works
      • Considering why randomization is needed
      • Understanding how probability works
      • Understanding distributions
      • Simulating the use of the Monte Carlo method
    • Putting Randomness into your Logic
      • Calculating a median using Quickselect
      • Doing simulations using Monte Carlo
      • Ordering faster with Quicksort
  • Chapter 18 Performing Local Search
    • Understanding Local Search
      • Knowing the neighborhood
    • Presenting local search tricks
      • Explaining hill climbing with n-queens
      • Discovering simulated annealing
      • Avoiding repeats using Tabu Search
    • Solving satisfiability of Boolean circuits
      • Solving 2-SAT using randomization
      • Implementing the Python code
      • Realizing that the starting point is important
  • Chapter 19 Employing Linear Programming
    • Using Linear Functions as a Tool
      • Grasping the basic math you need
      • Learning to simplify when planning
      • Working with geometry using simplex
      • Understanding the limitations
    • Using Linear Programming in Practice
      • Setting up PuLP at home
      • Optimizing production and revenue
  • Chapter 20 Considering Heuristics
    • Differentiating Heuristics
      • Considering the goals of heuristics
      • Going from genetic to AI
    • Routing Robots Using Heuristics
      • Scouting in unknown territories
      • Using distance measures as heuristics
    • Explaining Path Finding Algorithms
      • Creating a maze
      • Looking for a quick best-first route
      • Going heuristically around by A*
• Part 6 The Part of Tens
  • Chapter 21 Ten Algorithms That Are Changing the World
    • Using Sort Routines
    • Looking for Things with Search Routines
    • Shaking Things Up with Random Numbers
    • Performing Data Compression
    • Keeping Data Secret
    • Changing the Data Domain
    • Analyzing Links
    • Spotting Data Patterns
    • Dealing with Automation and Automatic Responses
    • Creating Unique Identifiers
  • Chapter 22 Ten Algorithmic Problems Yet to Solve
    • Dealing with Text Searches
    • Differentiating Words
    • Determining Whether an Application Will End
    • Creating and Using One-Way Functions
    • Multiplying Really Large Numbers
    • Dividing a Resource Equally
    • Reducing Edit Distance Calculation Time
    • Solving Problems Quickly
    • Playing the Parity Game
    • Understanding Spatial Issues
• Index
• EULA