Index

Symbols

• % (modulo operator), Associating Values with Keys
• & (bitwise and), Hash Functions and Hash Codes, Python Built-in Data Types
• // (integer division), Recursion and Divide and Conquer
• < (less-than operator), What Is an Algorithm?
• > (greater-than operator), Find Two Largest Values in an Arbitrary List, Summary
• _insert() method, Searching for Values in a Binary Search Tree, Self-Balancing Binary Trees
• _remove() method, Self-Balancing Binary Trees
• _remove_max() function, Using the Binary Tree as a Priority Queue
• _remove_min() method, Self-Balancing Binary Trees
• Θ (theta), Curve Fitting Versus Lower and Upper Bounds
• Ω (omega), Curve Fitting Versus Lower and Upper Bounds

A

• active search space, Breadth First Search Offers Different Searching Strategy, Breadth First Search Offers Different Searching Strategy, Directed Graphs, Directed Graphs, Directed Graphs
• additive constant, Asymptotic Analysis
• adjacency list, Breadth First Search Offers Different Searching Strategy
• adjacency matrix, Breadth First Search Offers Different Searching Strategy
• algorithm
  • analysis, Asymptotic Analysis
    • (see also asymptotic analysis)
  • complexity, Time Complexity and Space Complexity
    • (see also space complexity, time complexity)
  • definition of, What Is an Algorithm?
  • performance, Using Empirical Models to Predict Performance, Performance Comparison of O(N log N) Algorithms
    • (see also performance classes, performance prediction)
• all-pairs shortest path, All-Pairs Shortest Path-All-Pairs Shortest Path
• alpha, Analyzing the Performance of Dynamic Hashtables
• alternate() algorithm, Models Can Predict Algorithm Performance-Models Can Predict Algorithm Performance
• amortized analysis
  • amortized constant O(1), Dijkstra’s Algorithm
  • amortized O(1), Better Living Through Better Hashing, Wrapping It Up, Wrapping It Up, Python Built-in Data Types
  • amortized performance, Summary
• approximation algorithms, Future Exploration
• array data structure, What Is an Algorithm?
  • for heap storage, Representing a Binary Heap in an Array
  • for open addressing, Detecting and Resolving Collisions with Linear Probing
  • geometric resizing, Better Living Through Better Hashing, Growing Hashtables, Analyzing the Performance of Dynamic Hashtables, Summary, Analyzing Performance of Binary Search Trees, Wrapping It Up
• Art of Computer Programming, The, Future Exploration
• ASCII, Associating Values with Keys
• asymptotic analysis, Asymptotic Analysis-Asymptotic Analysis
• AVL property, Self-Balancing Binary Trees
• AVL tree, Self-Balancing Binary Trees-Self-Balancing Binary Trees, Using the Binary Tree as a Priority Queue, Challenge Exercises

B

• bag, Wrapping It Up
• base case, Recursion and Divide and Conquer, Getting Started
• Bellman–Ford algorithm, Dijkstra’s Algorithm-Dijkstra’s Algorithm
• best case problem instance, Models Can Predict Algorithm Performance, Asymptotic Analysis
• Big O notation, Asymptotic Analysis
• Bignum structure, Multiplication Can Be Faster
• Binary Array Search, Heaping It On, Binary Search Trees
• Binary Array Search algorithm, Binary Array Search-Two Birds with One Stone
• binary heap, Max Binary Heaps-Removing the Value with Highest Priority
  • levels, Max Binary Heaps-Max Binary Heaps
  • max binary heap, Heaping It On, Max Binary Heaps-Max Binary Heaps
  • min binary heap, Heaping It On, Max Binary Heaps, Summary, Heap and Priority Queue Implementations
  • sink() function, Removing the Value with Highest Priority-Removing the Value with Highest Priority, Implementation of Swim and Sink-Implementation of Swim and Sink
  • swim() function, Inserting a (value, priority)-Inserting a (value, priority), Implementation of Swim and Sink-Implementation of Swim and Sink
• binary search tree
  • about, Binary Search Trees-Binary Search Trees
  • performance, Analyzing Performance of Binary Search Trees-Analyzing Performance of Binary Search Trees
  • priority queue as, Using the Binary Tree as a Priority Queue-Using the Binary Tree as a Priority Queue
  • self-balancing, Self-Balancing Binary Trees-Analyzing Performance of Self-Balancing Trees
  • symbol table as, Using Binary Tree as (key, value) Symbol Table-Using Binary Tree as (key, value) Symbol Table
  • traversing, Traversing a Binary Tree-Traversing a Binary Tree
  • values removal, Removing Values from a Binary Search Tree-Removing Values from a Binary Search Tree
  • values search, Searching for Values in a Binary Search Tree-Searching for Values in a Binary Search Tree
• binary tree recursive data structure, Getting Started-Binary Search Trees
• blind search, Breadth First Search Offers Different Searching Strategy
• Breadth First Search, Breadth First Search Offers Different Searching Strategy-Breadth First Search Offers Different Searching Strategy, Dijkstra’s Algorithm
• bucket, A Hashtable Structure for (Key, Value) Pairs

C

• C programming language, What Is an Algorithm?, What Is an Algorithm?
• C++ programming language, What Is an Algorithm?
• central processing unit (see CPU)
• chain, Detecting and Resolving Collisions with Linear Probing, Separate Chaining with Linked Lists
• Challenge Exercises, Challenge Exercises-Challenge Exercises, Challenge Exercises-Challenge Exercises, Challenge Exercises-Challenge Exercises, Challenge Exercises-Challenge Exercises, Challenge Exercises-Challenge Exercises, Challenge Exercises-Challenge Exercises, Challenge Exercises-Challenge Exercises
• circular queue, Challenge Exercises
• circular reference, Directed Graphs
• collisions, A Hashtable Structure for (Key, Value) Pairs-Detecting and Resolving Collisions with Linear Probing
• complete binary tree, Analyzing Performance of Binary Search Trees
• Complexity classes, Two Birds with One Stone-Two Birds with One Stone, Two Birds with One Stone
  • (see also constant complexity class, exponential complexity class, factorial complexity class, linear complexity class, logarithmic complexity class)
  • O(1), Analyzing Algorithms, Counting All Bytes
  • O(log N), Analyzing Algorithms, Counting All Bytes
  • O(log N/log(log N)), Challenge Exercises
  • O(log(log N)), Challenge Exercises
  • O(N log N), Analyzing Algorithms, Performance Classes, Counting All Operations, Pulling It All Together, Performance Comparison of O(N log N) Algorithms, Binary Search Trees
  • O(N!), Pulling It All Together
  • O(N), Analyzing Algorithms, Counting All Operations, Counting All Operations, Counting All Bytes
  • O(N²), Analyzing Algorithms, Performance Classes, Counting All Operations, Two Birds with One Stone, Pulling It All Together
  • O(N³), Two Birds with One Stone
• computational geometry, Future Exploration
• compute_height() function, Self-Balancing Binary Trees, Analyzing Performance of Self-Balancing Trees
• connected graph, Graphs Efficiently Store Useful Information
• constant complexity class, Counting All Bytes, Two Birds with One Stone
• container types, Python Built-in Data Types
  • (see also dict data type, list data type, set data type, tuple data type)
• CPU, What Is an Algorithm?, What Is an Algorithm?, Multiplication Can Be Faster
• curve_fit() function, Curve Fitting Versus Lower and Upper Bounds
• cybersecurity measure, Hash Functions and Hash Codes
• cycle, Graphs Efficiently Store Useful Information, Directed Graphs
• Cycle Detection algorithm, Directed Graphs

D

• denial-of-service attack, Hash Functions and Hash Codes
• Depth First Search algorithm, Using Depth First Search to Solve a Maze-Using Depth First Search to Solve a Maze, Breadth First Search Offers Different Searching Strategy, Directed Graphs, Directed Graphs
• deque, Implementing Stack in Python
• dequeue operation, Heaping It On-Heaping It On, Implementation of Swim and Sink, Implementation of Swim and Sink
• descendants, Binary Search Trees
• dict data type, Associating Values with Keys, Python Built-in Data Types
• Dijkstra's algorithm, Dijkstra’s Algorithm-Dijkstra’s Algorithm
• Dijkstra, Edsger, Dijkstra’s Algorithm
  • (see also Dijkstra's algorithm)
• directed graph, Graphs Efficiently Store Useful Information, Graphs Efficiently Store Useful Information, Directed Graphs-Directed Graphs
• disconnected graph, Graphs Efficiently Store Useful Information
• distributed algorithms, Future Exploration
• divide and conquer strategy, Analyze Performance of Insertion Sort and Selection Sort-Recursion and Divide and Conquer, Merge Sort
  • (see also merge sort, quicksort)
• double_two() algorithms, Find Two Largest Values in an Arbitrary List-Find Two Largest Values in an Arbitrary List, Tournament Algorithm, Tournament Algorithm, Time Complexity and Space Complexity
• dynamic programming, Future Exploration

E

• edge, Graphs Efficiently Store Useful Information, Graphs Efficiently Store Useful Information
• edge weight, Graphs with Edge Weights-Graphs with Edge Weights
• endpoints, Graphs Efficiently Store Useful Information
• enqueue operation, Heaping It On-Heaping It On, Challenge Exercises
• exponential complexity class, Two Birds with One Stone
• exponentiation, Two Birds with One Stone
• expression tree, Getting Started
• extra storage, Find Two Largest Values in an Arbitrary List, Find Two Largest Values in an Arbitrary List

F

• factorial complexity class, Two Birds with One Stone
• factorial heaps, Challenge Exercises
• Fibonacci series, Recursion and Divide and Conquer, Challenge Exercises, Challenge Exercises
• FIFO (first-in, first-out), Heaping It On, Breadth First Search Offers Different Searching Strategy, Implementing Stack in Python
• flawed implementation, Finding the Largest Value in an Arbitrary List
• floor function, Two Birds with One Stone, Curve Fitting Versus Lower and Upper Bounds
• Floyd–Warshall algorithm, Floyd–Warshall Algorithm

G

• galactic algorithm, Challenge Exercises
• geometric resizing, Growing Hashtables, Analyzing the Performance of Dynamic Hashtables, Analyzing Performance of Binary Search Trees
• get() function, Detecting and Resolving Collisions with Linear Probing, Detecting and Resolving Collisions with Linear Probing, Separate Chaining with Linked Lists, Analyzing the Performance of Dynamic Hashtables, Using Binary Tree as (key, value) Symbol Table
• graphs, Graphs Efficiently Store Useful Information-Graphs Efficiently Store Useful Information, Wrapping It Up
  • (see also connected graph, directed graph, disconnected graph, map, maze, project, simple graph, undirected graph)
• Guided Search, Breadth First Search Offers Different Searching Strategy-Breadth First Search Offers Different Searching Strategy

H

• Harvey, David, Challenge Exercises
• hash codes, Hash Functions and Hash Codes-Hash Functions and Hash Codes
• hash collision, Detecting and Resolving Collisions with Linear Probing
• hash functions, Hash Functions and Hash Codes-Hash Functions and Hash Codes
• hashing, Associating Values with Keys, Hash Functions and Hash Codes
  • (see also hash codes, hash functions)
  • in Java, Hash Functions and Hash Codes
  • perfect hashing, Perfect Hashing-Iterate Over (key, value) Pairs
  • in Python, Analyzing the Performance of Dynamic Hashtables, Python Built-in Data Types
  • simple uniform hashing, Analyzing the Performance of Dynamic Hashtables
• heap data structure, Heaping It On
• heap sort, Heap Sort-Heap Sort
• heap-based priority queue, Heaping It On
• heap-ordered property, Max Binary Heaps, Max Binary Heaps-Removing the Value with Highest Priority, Implementation of Swim and Sink, Challenge Exercises
• heap-shape property, Max Binary Heaps, Max Binary Heaps, Removing the Value with Highest Priority, Removing the Value with Highest Priority, Implementation of Swim and Sink, Challenge Exercises
• heapify, Heap and Priority Queue Implementations
• heapq, Heap and Priority Queue Implementations
• heaps, Heaping It On-Inserting a (value, priority)
• height, Analyzing Performance of Binary Search Trees
• hit, A Hashtable Structure for (Key, Value) Pairs

I

• incremental resizing, Challenge Exercises
• index position, What Is an Algorithm?
• indexed min priority queue, Dijkstra’s Algorithm, Wrapping It Up
• inorder traversal, Summary
• insert() function, Binary Search Trees
• insertion sort, Anatomy of a Quadratic Sorting Algorithm-Analyze Performance of Insertion Sort and Selection Sort, Tim Sort
• integer multiplication, Multiplication Can Be Faster
• Intel, Asymptotic Analysis

J

• Java, What Is an Algorithm?, What Is an Algorithm?, Hash Functions and Hash Codes, Performance Comparison of O(N log N) Algorithms

K

• Karatsuba complexity class, Counting All Operations
• key operations, What Is an Algorithm?, Counting Key Operations, Counting All Operations
• keys, Associating Values with Keys-Associating Values with Keys
• Knuth, Donald, Future Exploration

L

• largest() algorithm, Models Can Predict Algorithm Performance-Find Two Largest Values in an Arbitrary List
• largest_two() algorithm, Find Two Largest Values in an Arbitrary List, Tournament Algorithm, Tournament Algorithm, Time Complexity and Space Complexity
• leaf node, Binary Search Trees, Analyzing Performance of Binary Search Trees
• least squares method, Curve Fitting Versus Lower and Upper Bounds
• LIFO (last-in, first-out), Using Depth First Search to Solve a Maze, Implementing Stack in Python
• line of best fit (see trendline)
• linear complexity class, Counting All Operations, Two Birds with One Stone
• linear models, Using Empirical Models to Predict Performance-Using Empirical Models to Predict Performance
• linear probing, Detecting and Resolving Collisions with Linear Probing, Separate Chaining with Linked Lists
• linear time median algorithm, Challenge Exercises
• linked list data structure, Detecting and Resolving Collisions with Linear Probing
  • adjacency list, Breadth First Search Offers Different Searching Strategy
  • append value, Detecting and Resolving Collisions with Linear Probing, Binary Search Trees
  • as bag, Wrapping It Up-Python Built-in Data Types
  • prepend value, Detecting and Resolving Collisions with Linear Probing, Binary Search Trees
  • as queue, Heaping It On
  • as queue, Heaping It On
  • recursive function, Getting Started
  • remove value, Removing an Entry from a Linked List-Removing an Entry from a Linked List
  • separate chaining, Separate Chaining with Linked Lists-Removing an Entry from a Linked List
• linked lists, Removing an Entry from a Linked List, Evaluation, Getting Started
• links, Detecting and Resolving Collisions with Linear Probing
• list data type, Python Built-in Data Types, Implementing Stack in Python
• logarithm, Tournament Algorithm, Two Birds with One Stone
• logarithmic complexity class, Two Birds with One Stone, Two Birds with One Stone
• lower bounds, Performance Classes

M

• Manhattan distance, Breadth First Search Offers Different Searching Strategy
• map, Graphs Efficiently Store Useful Information
• Maple, Using Empirical Models to Predict Performance
• max binary heaps, Max Binary Heaps-Implementation of Swim and Sink, Using the Binary Tree as a Priority Queue
• max() algorithm, Counting Key Operations, Models Can Predict Algorithm Performance, Models Can Predict Algorithm Performance
• max() function, What Is an Algorithm?
• maze, Graphs Efficiently Store Useful Information, Using Depth First Search to Solve a Maze-Using Depth First Search to Solve a Maze
• memory, Time Complexity and Space Complexity
• merge sort, Merge Sort-Merge Sort, Performance Comparison of O(N log N) Algorithms-Tim Sort, Challenge Exercises
• Microsoft Excel, Using Empirical Models to Predict Performance
• min binary heaps, Max Binary Heaps
• miss, A Hashtable Structure for (Key, Value) Pairs
• modulo operator, Associating Values with Keys
• Moore's Law, Asymptotic Analysis
• Moore, Gordon, Asymptotic Analysis
• multi-consumer, Implementing Stack in Python
• multi-producer, Implementing Stack in Python
• multiplication constant, Asymptotic Analysis
• multiplication, integer, Multiplication Can Be Faster
• mutable input, Find Two Largest Values in an Arbitrary List
• mutable_two() algorithms, Find Two Largest Values in an Arbitrary List-Find Two Largest Values in an Arbitrary List, Tournament Algorithm, Tournament Algorithm, Time Complexity and Space Complexity

N

• N log N complexity class, polynomial complexity class, quadratic complexity class, sub-linear complexity class, Two Birds with One Stone
• N log N models, Using Empirical Models to Predict Performance
• negative cycle, Dijkstra’s Algorithm
• node rotation, Self-Balancing Binary Trees
• nodes, Detecting and Resolving Collisions with Linear Probing, Binary Search Trees, Analyzing Performance of Binary Search Trees
  • (see also descendants, leaf node, parent nodes, root nodes)
• numpy, Using Empirical Models to Predict Performance

O

• open addressing, Detecting and Resolving Collisions with Linear Probing, Evaluation, Evaluation, Growing Hashtables
• order of a function, Asymptotic Analysis

P

• palindromes, Challenge Exercises
• parallel algorithms, Future Exploration
• parent nodes, Binary Search Trees
• path, Inserting a (value, priority), Graphs Efficiently Store Useful Information
• perfect hashing, Perfect Hashing-Perfect Hashing
• perfect_hash() function, Perfect Hashing
• performance classes, Performance Classes-Performance Classes
• performance comparison, Performance Comparison of O(N log N) Algorithms
• performance prediction, Models Can Predict Algorithm Performance-Models Can Predict Algorithm Performance, Using Empirical Models to Predict Performance-Using Empirical Models to Predict Performance
• Peters, Tim, Performance Comparison of O(N log N) Algorithms
• polynomial complexity class, Two Birds with One Stone
• postorder traversal, Traversing a Binary Tree
• prefix order, Challenge Exercises
• preorder traversal, Traversing a Binary Tree
• priority, Heaping It On
• priority queue, Heaping It On-Heaping It On, Heaping It On, Using the Binary Tree as a Priority Queue, Wrapping It Up
  • (see also heap-based priority queue)
• probabilistic algorithms, Future Exploration
• problem instance, What Is an Algorithm?, Models Can Predict Algorithm Performance, Counting All Operations
  • (see also best case problem instance, worst case problem instance)
• programming effort, Find Two Largest Values in an Arbitrary List
• project, Graphs Efficiently Store Useful Information
• put() function, Detecting and Resolving Collisions with Linear Probing, Detecting and Resolving Collisions with Linear Probing, Separate Chaining with Linked Lists, Analyzing the Performance of Dynamic Hashtables
• put(k, v) function, Using Binary Tree as (key, value) Symbol Table
• Python, What Is an Algorithm?, Models Can Predict Algorithm Performance, Multiplication Can Be Faster, Associating Values with Keys, Hash Functions and Hash Codes, Performance Comparison of O(N log N) Algorithms, Binary Search Trees, Python Built-in Data Types-Heap and Priority Queue Implementations
  • enumerate, Perfect Hashing
  • generators, Counting All Bytes, Iterate Over (key, value) Pairs, Traversing a Binary Tree
  • interpreter, What Is an Algorithm?
  • itertools, Challenge Exercises
  • NetworkX, Graphs Efficiently Store Useful Information, Graphs Efficiently Store Useful Information, Summary
  • NumPy, Using Empirical Models to Predict Performance
  • perfect-hash, Perfect Hashing, Iterate Over (key, value) Pairs
  • Python 2, What Is an Algorithm?, Counting All Bytes
  • Python 3, What Is an Algorithm?, Counting All Bytes
  • range, Finding the Largest Value in an Arbitrary List, Counting All Bytes, Counting All Bytes, Iterate Over (key, value) Pairs
  • RuntimeError, A Hashtable Structure for (Key, Value) Pairs, Detecting and Resolving Collisions with Linear Probing, Using Depth First Search to Solve a Maze, Dijkstra’s Algorithm, Challenge Exercises
  • SciPy, Using Empirical Models to Predict Performance, Curve Fitting Versus Lower and Upper Bounds
  • sys, Counting All Bytes, Counting All Bytes
  • ValueError, Counting Key Operations
  • __contains()__, Searching for Values in a Binary Search Tree, Using Binary Tree as (key, value) Symbol Table
  • __iter()__, Iterate Over (key, value) Pairs, Challenge Exercises, Traversing a Binary Tree, Traversing a Binary Tree, Using Binary Tree as (key, value) Symbol Table
• Python-2, Hash Functions and Hash Codes
• Python-3, Hash Functions and Hash Codes

Q

• quadratic complexity class, Counting All Operations
• quadratic models, Using Empirical Models to Predict Performance-Using Empirical Models to Predict Performance, Multiplication Can Be Faster
• quadratic polynomial, Using Empirical Models to Predict Performance
• quadratic sorting algorithm, Anatomy of a Quadratic Sorting Algorithm-Anatomy of a Quadratic Sorting Algorithm
• queue, Heaping It On, Wrapping It Up
  • (see also circular queue, dequeue operation, enqueue operation, priority queue)
• quicksort, Quicksort-Quicksort, Performance Comparison of O(N log N) Algorithms

R

• RAM (Random Access Memory), Time Complexity and Space Complexity
• recursion, Recursion and Divide and Conquer-Recursion and Divide and Conquer, Getting Started
  • (see also binary tree recursive data structure)
• recursive algorithm, Recursion and Divide and Conquer
• recursive case, Recursion and Divide and Conquer, Getting Started
• recursive data structure, Getting Started
  • (see also binary tree recursive data structure, linked lists)
• recursive helper function, Binary Search Trees
• references (see links)
• relax() function, Dijkstra’s Algorithm
• relaxing an edge, Dijkstra’s Algorithm
• remove(k) function, Removing an Entry from a Linked List
• root nodes, Binary Search Trees, Analyzing Performance of Binary Search Trees
• rotate left, Self-Balancing Binary Trees, Challenge Exercises
• rotate left-right, Self-Balancing Binary Trees, Challenge Exercises
• rotate right, Self-Balancing Binary Trees, Challenge Exercises
• rotate right-left, Challenge Exercises

S

• search
  • binary tree, Searching for Values in a Binary Search Tree-Searching for Values in a Binary Search Tree
  • linear probing, Separate Chaining with Linked Lists-Separate Chaining with Linked Lists
  • open addressing, Detecting and Resolving Collisions with Linear Probing-Detecting and Resolving Collisions with Linear Probing
  • ordered array, Binary Array Search-Two Birds with One Stone
• selection sort, Selection Sort-Anatomy of a Quadratic Sorting Algorithm, Anatomy of a Quadratic Sorting Algorithm-Analyze Performance of Insertion Sort and Selection Sort
• separate chaining technique, Separate Chaining with Linked Lists
• set data type, Python Built-in Data Types
• simple graph, Graphs Efficiently Store Useful Information
• simple uniform hashing, Analyzing the Performance of Dynamic Hashtables
• sink() method, Implementation of Swim and Sink
• sorting, Sorting by Swapping-Sorting by Swapping
  • (see also heap sort, insertion sort, merge sort, quadratic sorting algorithm, quicksort, selection sort, Tim sort)
• sorting algorithms, Performance Comparison of O(N log N) Algorithms
• sorting_two() algorithms, Find Two Largest Values in an Arbitrary List-Find Two Largest Values in an Arbitrary List, Tournament Algorithm, Time Complexity and Space Complexity
• source node, Graphs Efficiently Store Useful Information
• space complexity, Time Complexity and Space Complexity, Counting All Bytes
• speed, Find Two Largest Values in an Arbitrary List
• stack data type, Using Depth First Search to Solve a Maze, Wrapping It Up
• Stanford Large Network Dataset Collection, Graphs with Edge Weights
• sub-linear complexity class, Two Birds with One Stone
• sum_list() function, Getting Started
• swapping values, Sorting by Swapping-Sorting by Swapping
• Swift, Performance Comparison of O(N log N) Algorithms
• swim() method, Implementation of Swim and Sink, Implementation of Swim and Sink
• symbol table, Wrapping It Up
• symbol table data type, Associating Values with Keys, Detecting and Resolving Collisions with Linear Probing

T

• target node, Graphs Efficiently Store Useful Information
• target search, Binary Array Search-Two Birds with One Stone
• tight bound, Curve Fitting Versus Lower and Upper Bounds
• Tim sort, Performance Comparison of O(N log N) Algorithms-Tim Sort
• time complexity, Time Complexity and Space Complexity, Binary Array Search
• timing, What Is an Algorithm?
• Topological Sort, Graphs: Only Connect!, Directed Graphs, Directed Graphs, Dijkstra’s Algorithm, Challenge Exercises
• tournament algorithm, Tournament Algorithm-Tournament Algorithm
• tournament_two() algorithm, Tournament Algorithm-Tournament Algorithm
• traveling salesman problem (TSP), Graphs with Edge Weights
• traversal, Removing Values from a Binary Search Tree
  • (see also preorder traversal, postorder traversal)
• trendline, Using Empirical Models to Predict Performance
• triangle numbers, Challenge Exercises, Selection Sort
• TSP (traveling salesman problem), Graphs with Edge Weights
• tuple data type, Python Built-in Data Types

U

• undirected graph, Graphs Efficiently Store Useful Information, Graphs Efficiently Store Useful Information
• upper bounds, Performance Classes

V

• values, What Is an Algorithm?, Finding the Largest Value in an Arbitrary List-Tournament Algorithm, Associating Values with Keys-Associating Values with Keys, Heaping It On
• Van Der Hoeven, Joris, Challenge Exercises

W

• waypoint, Graphs with Edge Weights
• weight, Graphs Efficiently Store Useful Information, Graphs with Edge Weights
  • (see also edge weight)
• weighted graph, Graphs Efficiently Store Useful Information, Graphs Efficiently Store Useful Information
• worst case problem instance, Models Can Predict Algorithm Performance, Asymptotic Analysis