Skip to content

I. Assis

Binary

Initializing search

Posts
Publication
CV
Course Notes
DevKB
Awesome People

I. Assis

Posts
Posts
- 2023
  2023
  - Matrix Decomposition
Publication
Publication
- Journals & Conferences
- Talks
- Open-Source
  Open-Source
CV
CV
Course Notes
Course Notes
DevKB
DevKB
- 🌉 Data Structure
  🌉 Data Structure
  - List
    List
    
    Array
    Array
    
    Static
    
    Dynamic
    
    Linked
    Linked
    
    ADT
    
    Singly
    
    Circular
    
    Doubly
    
    Doubly: Efficient
    
    Header
    
    Polynomial
    
    Unrolled
    
    Array vs. Linked
    
    Skip
  - Stack
    Stack
    
    ADT
    
    Overflow
    
    Underflow
    
    Operation
    
    implement: by Array
    
    implement: by Linked List
    
    Application
    Application
    
    Polish Notation
    
    Infix and Postfix
    
    Evaluation: Postfix
    
    Evaluation: Prefix
  - Heap
    Heap
    
    Binary
  - Queue
    Queue
    
    ADT
    
    implement: by Array
    
    Implement: by Linked List
    
    operation: Insert
    
    operation: Delete
    
    Circular
    
    Priority
    Priority
    
    Adt
    
    Implement: by Linked List
    
    Double-Ended
  - Set
    Set
    
    Queue
    Queue
    
    ADT
    
    Pros
    
    Cons
    
    Fast Union / Slow Find
    
    Fast Union / Quick Find
    
    Path Compression
    
    Application
  - Map
    Map
    
    ADT
  - Tree
    Tree
    
    Binary
    Binary
    
    Memory
    
    Traversal: Threaded: Queueless
    
    Traversal: Threaded: Stackless
    
    Types
    
    Expression
    
    Expression
    
    XOR
    
    XOR
    
    Binary Search
    Binary Search
    
    Create by Traversal
    
    Operations
    
    Traversal
    
    AVL
    AVL
    
    Operation
    
    Red-Black
    Red-Black
    
    Operation
    
    Multiway
    Multiway
    
    B
    
    B+
    
    Generic
    
    n-Ary
    
    Variations
  - Graph
    Graph
    
    Representation
    Representation
    
    Adjacency: Matrix
    
    Adjacency: List
    
    Modelling
    
    Modelling
    
    Visualization
    
    Visualization
    
    Traversal
    Traversal
    
    Depth-First Traversal (DFS)
    
    Breadth-First Traversal (BFS)
    
    Sort
    Sort
    
    Topological
    
    App
    App
    
    Connected Circles
    
    Nine Tails
    
    Weighted
    Weighted
    
    Representation
    
    Modelling
    
    Minimal Spanning Tree
    Minimal Spanning Tree
    
    Prim
    
    Kruskal
    
    Shortest Path
    
    App
    App
    
    Weighted Nine Tails
  - File
    File
    
    Classification
    
    Operation
    
    Organization
    
    Organization
    
    Sequence
    
    Sequence Index
    
    Relative
    
    Inverted
  - String
    String
    
    Hash Table
    
    Tree: Binary Search
    
    Tries
    
    Tree: Ternary Search
    
    Tree: Suffix
- 🏭 Algorithm
  🏭 Algorithm
  - Design
    Design
    
    Classification
    
    Class: by Implementation
    
    Class: by Design Method
    
    Classification: Other
  - Complexity
    Complexity
    
    Polynomial vs. Exponential
    
    Decision: Problem
    
    Decision: Procedure
    
    Class
    
    Type
    
    Reduction
  - Recursion
    Recursion
    
    What
    
    Why
    
    Format
    
    Memory
    
    recursionIteration
    
    Case
    Case
    
    2^n
    
    x^n
    
    1 + 2 + … + n
    
    Directory Size
    
    Tower of Hanoi
  - Backtracking
    Backtracking
    
    What
    
    Why
    
    Format
    
    Memory
    
    Case
  - Sort
    Sort
    
    Classification
    
    Bubble
    
    Selection
    
    Selection: Recursive
    
    Insertion
    
    Shell
    
    Merge
    
    Heap
    
    Quick
    
    Tree
    
    Linear
    
    Counting
    
    Bucket/Bin
    
    Radix
    
    Topological
    
    External
    
    Comparison
  - Search
    Search
    
    Linear: Sequential
    
    Linear: Unordered
    
    Linear: Ordered/Sorted
    
    Binary Binary
    Table of contents
    
    Implement
    
    Implement Recursive
    
    Complexity
    
    Time
    
    Space
    
    Drawback
    
    Interpolation
    
    Symbol Table
    
    Hash
    
    String
  - Select
    Select
    
    Sort
    
    Partition
    
    Linear
    
    k-Smallest Element
  - Symbol
    Symbol
    
    Table
    
    Table: Comparison
    
    Table: Implementation
  - Hash
    Hash
    
    vs. Direct Address
    
    Component
    
    Table
    
    Collision: Open Addressing
    
    Collision: Separate Chaining
    
    Load Factor
    
    Rehash
    
    Map with Hash
    
    Set with Hash
    
    Achieving O(1)
    
    When not Use
    
    Technique
    
    Bloom Filter
    
    Code
    
    Function
  - String
    String
    
    Matching
    
    Brute Force
    
    Matching: Rabin-Karp
    
    Matching: Finite Automata
    
    KMP
    
    Boyer-Moore
  - Greedy
    Greedy
    
    Strategy
    
    Always works?
    
    Implement
    
    Pros
    
    Cons
  - Divide & Conquer
    Divide & Conquer
    
    Strategy
    
    Always works?
    
    Pros
    
    Cons
    
    Theorem
  - Dynamic Programming
    Dynamic Programming
    
    Property
    
    vs. Greedy vs. Divide & Conquer
    
    Approach
    
    Implement
    
    Longest Common Subsequence
  - Bitwise Programming
- 🧬 Design Pattern
  🧬 Design Pattern
  - Creational
    Creational
    
    Builder
    
    Factory
    
    Factory: Abstract
    
    Monostate
    
    Prototype
    
    Singleton
  - Behavioral
    Behavioral
    
    Chain of Responsability
    
    Command
    
    Iterator
    
    Memento
    
    Observer
    
    State
    
    Strategy
    
    Template
  - Structural
    Structural
    
    Adapter
    
    Bridge
    
    Composite
    
    Façade
    
    Flyweight
    
    Mediator
    
    Proxy
  - Other
    Other
    
    Dependency Injection
- 🎸 System Design
  🎸 System Design
  - Intro
    Intro
    
    Fundamentals
    
    Client-Server
    
    Network Protocols
    
    Storage
    
    Latency and Throughput
    
    Availability
    
    Caching
    
    Proxy
    
    Load Balancer
    
    Hashing
    
    Database: Relational
    
    Store: Key-Value
    
    Store: Paradigm
    
    Replication
    
    P2P Network
    
    Polling
    
    Stream
    
    Configuration
    
    Rate Limiting
    
    Logging & Monitoring
    
    MapReduce
    
    HTTPS
    
    API Design
  - Cloud Design Pattern
    Cloud Design Pattern
    
    Cache-Aside
    
    Circuit Breaker
    
    Compesating Transaction
    
    Competing Consumer
    
    Compute Resource Consolidation
    
    External Configuration Store
    
    Federated Identity
    
    Gatekeeper
    
    Endpoint Monitoring
    
    Index Table
    
    Leader Election
    
    Materialized View
    
    Pipe Filter
    
    Priority Queue
    
    Queue-Based Load Leveling
    
    Runtime Reconfiguration
    
    Scheduler Agent Supervisor
    
    Sharding
    
    Static Content Hosting
    
    Subscriber
    
    Throttling
    
    Valet Key
    
    Command & Query Responsability Segregation
    
    Event Sourcing
    
    Publisher
    
    Retry
  - Distributed System
    Distributed System
    
    Asynchronous Messaging
    
    Autoscaling
    
    Caching
    
    Compute Partitioning
    
    Data: Consistency
    
    Data: Partitioning
    
    Data: Replication
    
    Instrumentation
    
    Telemetry
    
    Multiple Data Center Deployment
    
    Service Metering
    
    Telemetry
  - Cases
    Cases
    
    Algo Expert
    
    Code Deployment System
    
    Stock Broker
    
    FB News Feed
    
    Google Drive
    
    Reddit API
    
    Netflix
    
    Uber API
    
    Slack
    
    Air BnB
- 👷 Javascript
  👷 Javascript
  - Functional Programming
  - this
Awesome People
Awesome People

Table of contents

Implement
Implement Recursive
Complexity
- Time
- Space
Drawback

Binary¶

Implement¶

Implement Recursive¶

Complexity¶

Time¶

Space¶

Drawback¶

Last update: 2022-11-29
Created: 2022-11-29

Dynamic systems, learning theory.

Made with Material for MkDocs