Data Structures, Algorithms, System Design, Design Patterns, TypeScript, and Code Refactoring Practice
Welcome to my GitHub repository! 🎉 This space is dedicated to practicing and exploring various topics in Data Structures, Algorithms, System Design, Design Patterns, TypeScript, and Code Refactoring. Here, I will be regularly uploading content that covers:
- Data Structures: Implementations, operations, and applications.
- Algorithms: Problem-solving techniques, optimizations, and best practices.
- System Design: Architectural principles, scalability, and performance considerations.
- Design Patterns: Common patterns in software engineering and their use cases.
- TypeScript Problems: Practical challenges and solutions in TypeScript.
- Code Refactoring: Improving existing code for readability, maintainability, and performance.
Each topic will be organized into its own directory with related code, explanations, and resources. Here’s an overview:
- Arrays
- Dynamic Arrays
- Sparse Arrays
- Linked Lists
- Singly Linked List
- Doubly Linked List
- Circular Linked List
- Strings
- String Matching Algorithms (KMP, Rabin-Karp, etc.)
- Palindrome Checks
- Anagram Detection
- Trees
- Binary Trees
- Binary Search Trees (BST)
- AVL Trees
- Red-Black Trees
- Segment Trees
- Interval Trees
- B-Trees
- Graphs
- Adjacency Matrix & List
- Directed & Undirected Graphs
- Weighted Graphs
- Cyclic & Acyclic Graphs
- Topological Sorting
- Strongly Connected Components (SCC)
- Hashing
- Hash Tables
- Hash Maps
- Open Addressing & Separate Chaining
- Heaps
- Min Heap
- Max Heap
- Fibonacci Heap
- Stacks
- Stack Using Arrays/Linked Lists
- Expression Evaluation (Infix, Prefix, Postfix)
- Balanced Parentheses
- Queues
- Circular Queue
- Priority Queue
- Deque (Double-ended Queue)
- Tries
- Prefix Trees
- Suffix Trees
- Binary Search Trees
- Insertion & Deletion
- Traversal (Inorder, Preorder, Postorder)
- Skip Lists
- Insertion, Deletion, and Search Operations
- Disjoint Set (Union-Find)
- Path Compression & Union by Rank
- Fenwick Tree (Binary Indexed Tree)
- Range Queries & Point Updates
- Matrix
- Sparse Matrix Representation
- Matrix Multiplication
- Transpose of Matrix
- Sorting Algorithms
- Quick Sort
- Merge Sort
- Heap Sort
- Counting Sort
- Radix Sort
- Bucket Sort
- Searching Algorithms
- Binary Search
- Depth-First Search (DFS)
- Breadth-First Search (BFS)
- Exponential Search
- Dynamic Programming
- Longest Common Subsequence (LCS)
- 0/1 Knapsack Problem
- Coin Change Problem
- Matrix Chain Multiplication
- Greedy Algorithms
- Huffman Coding
- Dijkstra’s Algorithm
- Prim’s & Kruskal’s Algorithms for Minimum Spanning Tree (MST)
- Fractional Knapsack
- Divide and Conquer
- Quickselect
- Karatsuba Algorithm for Fast Multiplication
- Backtracking
- N-Queens Problem
- Sudoku Solver
- Subset Sum Problem
- Graph Algorithms
- Shortest Path Algorithms (Bellman-Ford, Floyd-Warshall)
- Graph Coloring
- Minimum Cut/Max Flow (Ford-Fulkerson)
- Eulerian and Hamiltonian Paths
- Advanced Data Structures
- Suffix Arrays
- Segment Trees with Lazy Propagation
- Persistent Data Structures
- Mathematical Algorithms
- Prime Number Algorithms (Sieve of Eratosthenes)
- GCD, LCM (Euclidean Algorithm)
- Fast Exponentiation
- Number Theoretic Algorithms (Fermat's Little Theorem)
- String Algorithms
- Z-Algorithm
- Aho-Corasick Algorithm
- Suffix Array Construction
- Longest Repeated Substring
- Optimization Algorithms
- Simulated Annealing
- Genetic Algorithms
- Hill Climbing
- Scalability
- Horizontal vs Vertical Scaling
- Load Balancing Techniques
- Caching Strategies (CDN, Memcached, Redis)
- Database Design
- Database Sharding
- SQL vs NoSQL
- CAP Theorem
- Indexing & Query Optimization
- Microservices Architecture
- Service Discovery
- API Gateway
- Circuit Breaker Pattern
- Event-Driven Architecture
- Distributed Systems
- Consistent Hashing
- Distributed Consensus (Paxos, Raft)
- Data Partitioning
- Distributed File Systems (HDFS, Ceph)
- Concurrency & Parallelism
- Thread Pools
- Asynchronous Programming
- Lock-Free Data Structures
- Actor Model
- Security Design
- Authentication & Authorization (OAuth, JWT)
- Data Encryption (SSL/TLS, AES)
- Secure Design Patterns
- Threat Modeling
- Network Design
- CDN Design
- Reverse Proxy
- WebSockets & Long Polling
- RESTful vs GraphQL APIs
- Fault Tolerance
- High Availability Design
- Auto-Scaling & Self-Healing
- Redundancy & Replication
- Disaster Recovery Planning
- Messaging Systems
- Message Queues (RabbitMQ, Kafka)
- Pub/Sub Systems
- Event Sourcing
- Search Systems
- Full-Text Search Engines (Elasticsearch, Solr)
- Indexing Techniques
- Ranking Algorithms (TF-IDF, PageRank)
- Real-Time Systems
- Real-Time Data Streaming
- WebRTC for Video Conferencing
- Real-Time Collaboration Tools
- Big Data Design
- Data Warehousing (Redshift, BigQuery)
- MapReduce
- ETL Pipelines
- Creational Patterns
- Singleton
- Factory Method
- Abstract Factory
- Builder
- Prototype
- Structural Patterns
- Adapter
- Decorator
- Proxy
- Composite
- Facade
- Flyweight
- Behavioral Patterns
- Observer
- Strategy
- Command
- Chain of Responsibility
- State
- Mediator
- Memento
- Template Method
- Concurrency Patterns
- Thread Pool
- Future
- Producer-Consumer
- Read-Write Lock
- Scheduler
- Architectural Patterns
- MVC (Model-View-Controller)
- MVVM (Model-View-ViewModel)
- Layered Architecture
- Event-Driven Architecture
- Microservices
- Other Design Patterns
- Dependency Injection
- Lazy Initialization
- Null Object
- Service Locator
- Repository Pattern
- TypeScript Basics
- Type Annotations
- Interfaces vs Types
- Enums & Literal Types
- Advanced TypeScript
- Generics
- Utility Types (Partial, Pick, Omit, etc.)
- Mapped Types
- Conditional Types
- TypeScript with React
- TypeScript in React Components
- Context API with TypeScript
- Hooks with TypeScript
- TypeScript in Node.js
- TypeScript with Express
- TypeORM with TypeScript
- TypeScript with REST APIs
- Testing TypeScript Code
- Jest with TypeScript
- TypeScript & TDD
- Writing Unit Tests for TypeScript Code
- Refactoring Basics
- Code Smells
- Refactoring Techniques (Extract Method, Inline Variable, etc.)
- Improving Readability and Maintainability
- Refactoring Patterns
- Replace Conditional with Polymorphism
- Decompose Conditional
- Replace Magic Numbers with Named Constants
- Functional Refactoring
- Immutable Data Structures
- Pure Functions
- Higher-Order Functions
- Object-Oriented Refactoring
- Encapsulation Refactoring
- Composition Over Inheritance
- SOLID Principles Application
- Refactoring Legacy Code
- Testing Legacy Code Before Refactoring
- Incremental Refactoring
- Handling Technical Debt
- Performance Refactoring
- Memory Optimization
- Lazy Loading & Caching
- Code Profiling and Optimization
This repository serves as both a personal learning tool and a resource for others who are interested in understanding these crucial topics in computer science and software engineering. I will be sharing not only code implementations but also my understanding, insights, and the thought process behind each topic.
While this is primarily for my own practice, contributions are welcome! If you have suggestions, improvements, or additional topics, feel free to open an issue or submit a pull request.
Thank you for visiting! Stay tuned for regular updates and happy coding! 🚀