Please enable JavaScript.

Coggle requires JavaScript to display documents.

Data Structures and Algorithms in Python (9 12 (9 12 (9 10 (Maps, Hash…

- - - - Maps, Hash Tables, and Skip Lists
        
        Maps and Dictionaries
        
        Hash Tables
        
        Sorted Maps
        
        Skip Lists
        
        Sets, Multisets, and Multimaps
      - Priority Queues
        
        Implementing a Priority Queue
        
        Heaps
        
        Sorting with a Priority Queue
        
        Adaptable Priority Queues
        
        The Priority Queue Abstract Data Type
    - - Search Trees
        
        Binary Search Trees
        
        Balanced Search Trees
        
        AVL Trees
        
        Splay Trees
        
        (2,4) Trees
        
        Red-Black Trees
      - Sorting and Selection
        
        Why Study Sorting Algorithms?
        
        Merge-Sort
        
        Quick-Sort
        
        Studying Sorting through an Algorithmic Lens
        
        Comparing Sorting Algorithms
        
        Python’s Built-In Sorting Functions
        
        Selection
- - - - Stacks, Queues, and Deques
        
        Stacks
        
        Queues
        
        Double-Ended Queues
      - Array-Based Sequences
        
        Low-Level Arrays
        
        Dynamic Arrays and Amortization
        
        Efficiency of Python’s Sequence Types
        
        Using Array-Based Sequences
        
        Multidimensional Data Sets
        
        Python’s Sequence Types
    - - Linked Lists
        
        Singly Linked Lists
        
        Circularly Linked Lists
        
        Doubly Linked Lists
        
        The Positional List ADT
        
        Sorting a Positional List
        
        Case Study: Maintaining Access Frequencies
        
        Link-Based vs. Array-Based Sequences
      - Trees
        
        General Trees
        
        Binary Trees
        
        Implementing Trees
        
        Tree Traversal Algorithms
        
        Case Study: An Expression Tree
- - - - Graph Algorithms
        
        Graphs
        
        Data Structures for Graphs
        
        Graph Traversals
        
        Transitive Closure
        
        Directed Acyclic Graphs
        
        Shortest Paths
        
        Minimum Spanning Trees
      - Text Processing
        
        Pattern-Matching Algorithms
        
        Dynamic Programming
        
        Text Compression and the Greedy Method
        
        Tries
        
        Abundance of Digitized Text
    - - Memory Management and B-Trees
        
        Memory Management
        
        Memory Hierarchies and Caching
        
        External Searching and B-Trees
        
        External-Memory Sorting
- - - - Python Primer
        
        Objects in Python
        
        Expressions, Operators, and Precedence
        
        Control Flow
        
        Functions
        
        Simple Input and Output
        
        Exception Handling
        
        Iterators and Generators
        
        Additional Python Conveniences
        
        Scopes and Namespaces
        
        Modules and the Import Statement
        
        Python Overview
      - Object-Oriented Programming
        
        Goals, Principles, and Patterns
        
        Software Development
        
        Class Definitions
        
        Inheritance
        
        Namespaces and Object-Orientation
        
        Shallow and Deep Copying
    - - Algorithm Analysis
        
        Experimental Studies
        
        The Seven Functions Used in This Book
        
        Asymptotic Analysis
        
        Simple Justification Techniques
      - Recursion
        
        Illustrative Examples
        
        Analyzing Recursive Algorithms
        
        Recursion Run Amok
        
        Further Examples of Recursion
        
        Designing Recursive Algorithms
        
        Eliminating Tail Recursion