This repository contains resources and implementations for core DSA concepts and fundamental Java programming topics.
- Flowcharts & Pseudocodes
- Variables & Data Types
- Conditional Statements
- Operators
- For loop, While loop, Do-while loop
- Patterns
- Functions
- Introduction to Arrays
- Searching & Sorting
- Linear search
- Binary search
- Selection sort
- Bubble sort
- Insertion sort
- Count sort
 
- 2D Arrays
- Strings
- ArrayLists
- Linked lists
- Insertion and deletion operations
- Midpoint of linked list
- Merging sorted linked lists
- Reversing a linked list
 
- Stacks and Queues
- Stack using arrays and linked list
- Queue using arrays
- Dynamic queue class
- Circular queue
 
- Binary Trees & BST
- Introduction to Binary Trees
- Tree traversals
- Height and LCA of tree
- Binary Search Trees
- Insertion and deletion in BST
- Types of balanced BSTs
 
- Heaps/Priority Queues
- Min/Max heaps
- Heap Sort
- Priority Queues implementation
- Insert and Delete operations
 
- Hashing (Maps & Sets)
- Hashmaps
- Hashsets
- Implementation details
 
- Tries
- Basic operations and implementation
 
- Graphs
- Introduction and terminology
- Graph traversals (DFS and BFS)
- Weighted and directed graphs
- Minimum Spanning Trees
- Cycle Detection
- Dijkstra's algorithm
- Bellman Ford Algorithm
 
- Segment Trees
- Creation and range queries
 
- Recursion, Backtracking, Divide & Conquer
- Principle of mathematical induction
- Factorial, Fibonacci using recursion
- Recursion with arrays and strings
- 2D array recursion
- Merge sort and quick sort
 
- Bit Manipulation
- Binary number system
- Bitwise operators
- Bit operations
- Fast exponentiation
 
- Time & Space Complexity
- Order complexity analysis
- Theoretical complexity analysis
- Analysis of searching and recursive algorithms
 
- Greedy Algorithms
- Introduction to greedy approach
- Classical problem solving
 
- Fundamentals of DP
- Memoization
- Knapsack, Factorial, Fibonacci using DP
- Longest Common Subsequence
- Edit distance
- Matrix Chain Multiplication
- Objects & Classes
- Constructors and related concepts
- Abstraction, Encapsulation
- Inheritance, Polymorphism
- Abstract classes
- Interfaces
- 
Trees (Advanced) - AVL Trees
- Red-Black Trees
- B-Trees
 
- 
Advanced Graph Algorithms - Network Flow
- Bipartite Matching
- Advanced Path Algorithms
 
- 
Advanced Data Structures - Disjoint Set Union (Union-Find)
- Fenwick Trees (Binary Indexed Trees)
 
- 
Advanced Sorting - RadixSort
- CountingSort optimization
 
- 
String Algorithms - KMP Algorithm
- Rabin-Karp
- Suffix Arrays and Trees
- String Matching
 
- 
Object-Oriented Programming in Depth - Design patterns implementation
 
- 
Exception Handling - Custom exceptions
- Exception chaining
- Try-with-resources
- Best practices
 
- 
Java Collections Framework - Advanced collections usage
- Performance characteristics
- Custom implementations
- Collections utility methods
- Concurrent collections
 
- 
Generics - Type erasure
- Bounded type parameters
- Wildcards
- Generic methods and classes
 
- 
Multithreading and Concurrency - Thread lifecycle and states
- Synchronization mechanisms
- Locks and atomic variables
- Thread pools and executors
- CompletableFuture
- Fork/Join framework
 
- 
Java I/O and NIO - File handling
- Serialization
- Non-blocking I/O
- Memory-mapped files
 
- 
Functional Programming - Lambda expressions
- Method references
- Functional interfaces
- Stream API advanced operations
 
- 
Reflection and Annotations - Dynamic class loading
- Metaprogramming
- Custom annotations
- Annotation processors
 
- 
Java Database Connectivity (JDBC) - Connection pooling
- Prepared statements
- Batch processing
- Transaction management
 
- 
Java APIs - Date and Time API
- Optional class
- Regular Expressions
- Internationalization
 
- Graph algorithms visualizer
- Dynamic programming problem solver
- Custom data structure library
- Multithreaded application examples
- Design patterns showcase
- Books
- Online courses
- Practice websites
- Community forums
Feel free to contribute to this repository by adding implementations, improving existing code, or suggesting additional topics.