Please enable JavaScript.

Coggle requires JavaScript to display documents.

Components of a system - Coggle Diagram

- - - - Data Structures
      - Algorithms
        
        Algorithm Commponents
        
        Inputs
        
        Data
        
        Data Structures
        
        Primitive
        
        7 more items...
        
        Derived
        
        4 more items...
        
        Linear
        
        4 more items...
        
        Non-Linear
        
        3 more items...
        
        User-Defined
        
        3 more items...
        
        Outputs
        
        Processes
        
        Arithmatic
        
        Relational Operations
        
        Logical Operation
        
        Bitwise Operations
        
        Control structure
        
        loop statement
        
        Recurssion
        
        algorithm techniques
        
        Algorithms Classified by Technique
        
        1. Brute Force Algorithms
        
        Linear Search
        
        Bubble Sort
        
        Selection Sort
        
        Generating all subsets of a set (Power Set)
        
        Traveling Salesman Problem (TSP) (Exhaustive search)
        
        2. Divide and Conquer Algorithms
        
        Merge Sort
        
        Quick Sort
        
        Binary Search
        
        Karatsuba Algorithm (Fast Multiplication)
        
        Strassen’s Algorithm (Matrix Multiplication)
        
        Closest Pair of Points Problem
        
        3. Dynamic Programming (DP) Algorithms
        
        Fibonacci Number Calculation
        
        Longest Common Subsequence (LCS)
        
        Longest Increasing Subsequence (LIS)
        
        0/1 Knapsack Problem
        
        Matrix Chain Multiplication
        
        Floyd-Warshall Algorithm (All-Pairs Shortest Paths)
        
        Edit Distance (String Matching)
        
        Coin Change Problem
        
        4. Greedy Algorithms
        
        Dijkstra’s Algorithm (Shortest Path in Graph)
        
        Prim’s Algorithm (Minimum Spanning Tree)
        
        Kruskal’s Algorithm (Minimum Spanning Tree)
        
        Huffman Coding (Data Compression)
        
        Fractional Knapsack Problem
        
        Activity Selection Problem
        
        5. Backtracking Algorithms
        
        N-Queens Problem
        
        Sudoku Solver
        
        Hamiltonian Cycle Problem
        
        Graph Coloring
        
        Subset Sum Problem
        
        Word Search in a Grid
        
        6. Branch and Bound Algorithms
        
        Traveling Salesman Problem (Optimized version)
        
        0/1 Knapsack Problem (with bounding function)
        
        N-Queens Problem (optimized)
        
        7. Graph Traversal Algorithms
        
        Breadth-First Search (BFS)
        
        Depth-First Search (DFS)
        
        Topological Sorting
        
        Strongly Connected Components (Tarjan’s Algorithm, Kosaraju’s Algorithm)
        
        8. Randomized Algorithms
        
        Quick Sort (Random Pivot)
        
        Randomized Primality Testing (Miller-Rabin)
        
        Monte Carlo Algorithm (for approximations)
        
        Las Vegas Algorithm (Randomized search trees)
        
        9. Bit Manipulation Algorithms
        
        Counting Set Bits (Brian Kernighan’s Algorithm)
        
        Finding the Only Non-Repeated Element in an Array (XOR Method)
        
        Checking if a Number is a Power of Two
        
        Fast Exponentiation (Binary Exponentiation)
        
        10. Approximation Algorithms
        
        Traveling Salesman Problem (Greedy Approximation)
        
        Vertex Cover Problem (Approximation using Matching)
        
        Set Cover Problem (Greedy Approximation)
        
        K-Center Clustering
        
        Each technique is used to solve specific types of problems efficiently. 🚀
      - Program
        
        OOD
        
        SOLID
        
        S - Single Responsibility Principle (SRP)
        
        A class should have only one reason to change (one responsibility).
        
        O - Open/Closed Principle (OCP)
        
        Software entities should be open for extension but closed for modification.
        
        L - Liskov Substitution Principle (LSP)
        
        Subtypes must be substitutable for their base types without altering the correctness of the program.
        
        I - Interface Segregation Principle (ISP)
        
        A class should not be forced to depend on interfaces it does not use (small, specific interfaces are better).
        
        D - Dependency Inversion Principle (DIP)
        
        High-level modules should not depend on low-level modules; both should depend on abstractions.
        
        OOP
        
        Abstraction
        
        Polymorphism
        
        Types of Polymorphism
        
        Compile-Time Polymorphism (Static Binding)
        
        Function Overloading
        
        Operator Overloading
        
        Template Functions (C++)
        
        Run-Time Polymorphism (Dynamic Binding)
        
        Method Overriding
        
        Virtual Functions (C++)
        
        Abstract Classes and Interfaces
        
        Dynamic Method Dispatch (Java)
        
        Function Overloading (Compile-Time Polymorphism)
        
        Overloading in C++, Java, C#
        
        Method Overloading vs. Method Overriding
        
        Constructor Overloading
        
        Operator Overloading (C++ Specific)
        
        Default Arguments in Function Overloading
        
        Method Overriding (Run-Time Polymorphism)
        
        Virtual Functions (C++ Concept)
        
        Dynamic Method Dispatch (Java, C# Concept)
        
        Base Class and Derived Class Method Overriding
        
        Super Keyword (Calling Parent Class Methods in Overriding - Java, Python, C#)
        
        Virtual Functions (C++ Specific)
        
        Virtual Function Mechanism
        
        Pure Virtual Functions & Abstract Classes
        
        Virtual Table (vtable) and vptr Mechanism
        
        Late Binding vs. Early Binding
        
        Abstract Classes and Interfaces
        
        Abstract Class vs. Interface (Java, C#)
        
        Multiple Interface Implementation
        
        Using Interfaces for Polymorphism
        
        Dependency Injection with Interfaces
        
        Dynamic Method Dispatch (Java, C#)
        
        How Dynamic Dispatch Works in OOP
        
        Using override Keyword (C#)
        
        Polymorphism and Reflection
        
        Polymorphism in Design Patterns
        
        Strategy Pattern (Dynamic Behavior Selection)
        
        Factory Method Pattern (Using Polymorphism to Instantiate Objects)
        
        Decorator Pattern (Runtime Behavior Modification)
        
        Visitor Pattern (Applying Operations to Different Object Types Dynamically)
        
        Abstract Classes
        
        Interfaces
        
        Pure Virtual Functions (C++ Specific)
        
        Method Overriding (Polymorphism in Abstraction)
        
        Multiple Inheritance vs. Interface-Based Abstraction
        
        Dependency Injection (Using Abstraction to Decouple Components)
        
        Abstract Data Types (ADT)
        
        Encapsulation vs. Abstraction (Comparison)
        
        Encapsulation
        
        Access Modifiers (Public, Private, Protected, Internal, etc.)
        Getter and Setter Methods (Encapsulation of Data)
        
        Inheritance
        
        Single Inheritance
        
        Multiple Inheritance
        
        Multilevel Inheritance
        
        Hierarchical Inheritance
        
        Hybrid Inheritance (Combination of Different Types)
        
        Base Class and Derived Class Relationships
        
        Method Overriding (Polymorphism in Inheritance)
        
        Virtual Functions (C++ Specific for Runtime Polymorphism)
        
        Super and Subclass Relationships
        
        Composition vs. Inheritance (When to Use Which)
        
        Inheritance in Design Patterns (Factory Method, Template Method, etc.)
        
        Design Patterns
        
        Creational Design Patterns (Object Creation)
        
        Singleton
        
        Factory Method
        
        Abstract Factory
        
        Builder
        
        Prototype
        
        Structural Design Patterns (Object Composition)
        
        Adapter
        
        Bridge
        
        Composite
        
        Decorator
        
        Facade
        
        Flyweight
        
        Proxy
        
        Behavioral Design Patterns (Object Interaction)
        
        Chain of Responsibility
        
        Command
        
        Interpreter
        
        Iterator
        
        Mediator
        
        Memento
        
        Observer
        
        State
        
        Strategy
        
        Template Method
        
        Visitor
        
        Concurrent Design Patterns (Multithreading & Concurrency)
        
        Active Object
        
        Balking
        
        Barrier
        
        Double Checked Locking
        
        Leader/Followers
        
        Monitor Object
        
        Read-Write Lock
        
        Thread Pool
        
        Thread-Local Storage
        
        Data Structures