Problem Solving Practice in Java

Welcome to my problem-solving practice repository. 👋

This repository is where I practice Data Structures and Algorithms in Java, mainly through Codeforces-style problems and structured lessons from Big-O Coding courses.

The focus is not only on solving algorithmic problems, but also on improving practical problem-solving skills such as reading input carefully, handling file-based data, parsing problem statements, choosing the right data structures, and writing efficient Java solutions.

🚀 About This Repository

This repository is dedicated to practicing algorithmic problem solving through structured topics, hands-on exercises, and competitive-programming-style challenges.

The practice includes:

• Codeforces-style problems
• Big-O Coding course exercises
• Topic-based data structures and algorithms
• Problems that require input/output handling
• Problems that involve reading, parsing, and processing data
• Java implementation practice

Compared with standard curated problem lists, this repository puts more focus on problem statement analysis, data handling, edge cases, and implementation details.

🎯 Goals

• Keep a consistent problem-solving habit
• Strengthen algorithmic thinking
• Practice Java implementation
• Improve reading and parsing of problem statements
• Handle input/output and file-based data correctly
• Learn common data structures and algorithms through structured topics
• Build efficient and optimized solutions
• Review and improve solutions over time

🧠 Practice Approach

For each problem, I try to focus on:

• Understanding the problem statement carefully
• Identifying input/output requirements
• Parsing data correctly
• Thinking through a simple approach first
• Choosing the right data structure or algorithm
• Handling edge cases
• Writing clean and efficient Java code
• Reviewing time and space complexity
• Revisiting similar problems to reinforce learning

📚 Topics Covered

The repo is organized around core data structure and algorithm topics:

• Algorithmic Complexity
• Data Abstraction
• Array and String
• Sorting
• Prefix Sum
• Two Pointers
• Sliding Window
• Fast and Slow Pointers
• Binary Search
• Stack and Queue
• Linked List
• Recursion
• Backtracking
• Bit Manipulation
• Greedy
• Divide and Conquer
• Hash Table
• Tree
• Binary Search Tree
• Heap / Priority Queue
• Trie
• Graph
• Graph Traversal
• Shortest Path
• Minimum Spanning Tree
• Disjoint Set Union
• Dynamic Programming
• String Algorithms
• Segment Tree
• Number Theory
• Math and Geometry

📂 Project Structure

root/
├── DSA/
│   ├── Abstraction/
│   ├── BellmanFord/
│   ├── BinarySearch/
│   ├── BinarySearchTree/
│   ├── BreadthFirstSearch/
│   ├── Complexity/
│   ├── DepthFirstSearch/
│   ├── Dijkstra/
│   ├── DisjointSetUnion/
│   ├── DynamicArrayAndString.SuffixStructures/
│   ├── DynamicProgramming.CoinChange/
│   ├── FastAndSlowPointers/
│   ├── Heap/
│   ├── KWayMerge/
│   ├── LinkedList/
│   ├── MergeInterval/
│   ├── ModifiedBinarySearch/
│   ├── PrefixSum/
│   ├── Prim/
│   ├── Recursion/
│   ├── SlidingWindow/
│   ├── Sorting/
│   ├── StackAndQueue/
│   ├── TopKthElements/
│   ├── Trie/
│   ├── TwoHeap/
│   └── TwoPointers/
├── README.md
└── build files