Skip to content

GETTING_STARTED.md

Latest commit

 

History

History
283 lines (211 loc) · 6.2 KB

GETTING_STARTED.md

File metadata and controls

283 lines (211 loc) · 6.2 KB

Getting Started with DSA Practice Ground

Welcome! This guide will help you get started with your DSA learning journey.

🎯 Your First Steps

1. Set Up Your Environment

Install Requirements:

Clone and Build:

# Clone the repository
git clone <your-repo-url>
cd data-structures-self-learning

# Build the project
mvn clean install

# Verify everything works
mvn test

2. Choose Your Starting Point

Complete Beginner? Start here:

  1. Linear Search (wiki/LinearSearch.md)
  2. Stack (wiki/Stack.md)
  3. Bubble Sort (wiki/BubbleSort.md)

Some Programming Experience? Try:

  1. Binary Search (wiki/BinarySearch.md)
  2. LinkedList (wiki/LinkedList.md)
  3. Merge Sort (wiki/MergeSort.md)

Preparing for Interviews? Focus on:

  1. All searching algorithms
  2. All sorting algorithms
  3. Graph (BFS/DFS)
  4. Dynamic Programming basics

3. Your First Implementation

Let's implement Linear Search together:

Step 1: Read the Guide

cat wiki/LinearSearch.md
# or open in your IDE

Step 2: Open the File

src/main/java/com/dsa/algorithms/searching/LinearSearch.java

Step 3: Implement

public int search(int[] arr, int target) {
    // Your implementation here
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

Step 4: Test

# Open the test file
src/test/java/com/dsa/algorithms/searching/LinearSearchTest.java

# Uncomment the test:
@Test
void testSearchFound() {
    int[] arr = {5, 2, 8, 12, 1, 6};
    assertEquals(3, linearSearch.search(arr, 12));
}

# Run the test
mvn test -Dtest=LinearSearchTest

Step 5: Celebrate! 🎉

You just implemented and tested your first algorithm!

📚 Learning Strategy

The 4-Step Process

For each topic:

  1. Read - Spend 10-15 minutes understanding the concept
  2. Implement - Write the code (struggle is okay!)
  3. Test - Run tests and debug
  4. Reflect - Think about what you learned

Daily Practice Plan

Beginner (1 hour/day):

  • 15 min: Read wiki guide
  • 30 min: Implement
  • 15 min: Test and debug

Intermediate (2 hours/day):

  • 20 min: Read guide
  • 60 min: Implement multiple methods
  • 40 min: Test and optimize

Advanced (2-3 hours/day):

  • Multiple algorithms per day
  • Focus on optimization
  • Solve related LeetCode problems

🎓 Learning Tips

Do's ✅

  • Read the wiki guide first
  • Think about edge cases (empty input, single element, etc.)
  • Draw diagrams on paper
  • Take breaks when stuck
  • Celebrate small wins
  • Ask questions in discussions

Don'ts ❌

  • Don't copy-paste solutions from the internet
  • Don't skip the wiki guides
  • Don't ignore failing tests
  • Don't give up after 5 minutes
  • Don't skip "easy" topics

🔍 When You're Stuck

Try this sequence:

  1. Re-read the wiki guide (5 minutes)
  2. Draw the problem on paper (10 minutes)
  3. Look at test cases for hints (5 minutes)
  4. Take a 15-minute break (walk, coffee, etc.)
  5. Try again with fresh eyes (15 minutes)
  6. Search for high-level concepts (not code) online (10 minutes)
  7. Ask for help in discussions (explain what you've tried)

📊 Track Your Progress

Create a file MY_PROGRESS.md in the root directory:

# My Learning Journey

## Week 1
- [x] Linear Search - Completed 2025-01-15
- [x] Stack - Completed 2025-01-16
- [ ] Binary Search - In progress

## Challenges Faced
- Struggled with binary search edge cases
- Learned about integer overflow in mid calculation

## Next Week Goals
- Complete all searching algorithms
- Start on sorting algorithms

🎯 Setting Goals

Short-term (1-2 weeks)

  • Complete 5 basic algorithms
  • Understand O(n) vs O(log n)
  • Write your first test from scratch

Medium-term (1 month)

  • Implement all basic data structures
  • Understand all common sorting algorithms
  • Complete 20 LeetCode easy problems using these concepts

Long-term (3 months)

  • Implement all algorithms in this repo
  • Understand advanced topics (graphs, DP)
  • Ready for technical interviews

📖 Recommended Order

Week 1: Foundations

  1. Linear Search
  2. Binary Search
  3. Bubble Sort
  4. Stack
  5. Queue

Week 2: Data Structures

  1. ArrayList
  2. LinkedList
  3. Binary Search Tree
  4. Min Heap

Week 3: Algorithms

  1. Insertion Sort
  2. Merge Sort
  3. Quick Sort
  4. DFS/BFS

Week 4: Advanced

  1. Trie
  2. Graph
  3. Dijkstra's
  4. Dynamic Programming

🛠️ IDE Shortcuts

IntelliJ IDEA

  • Run test: Ctrl+Shift+F10 (Win) / Cmd+Shift+R (Mac)
  • Debug: Shift+F9
  • Format code: Ctrl+Alt+L (Win) / Cmd+Option+L (Mac)

VS Code

  • Run test: Click "Run Test" above test method
  • Debug: Click "Debug Test"
  • Format: Shift+Alt+F (Win) / Shift+Option+F (Mac)

🎥 Video Resources

While implementing, these might help:

📝 Taking Notes

Consider keeping notes for each topic:

# Binary Search Notes

## Key Insight
- Only works on sorted arrays
- Halves the search space each time

## Gotcha
- Use `left + (right - left) / 2` to avoid overflow

## When to use
- Large sorted datasets
- Need O(log n) performance

🤝 Join the Community

  • Star the repository
  • Fork and track your progress
  • Share your learning journey
  • Help others in discussions

🎉 Celebrate Milestones

  • ✨ First algorithm implemented
  • 🌟 All tests passing
  • 🎯 First data structure complete
  • 🚀 First advanced algorithm
  • 🏆 All algorithms implemented

Remember: Everyone starts as a beginner. The key is to start and keep going!

📧 Need Help?

  • Open an issue for bugs
  • Start a discussion for questions
  • Check existing issues for common problems

Ready to start? Pick your first algorithm and dive in! 🚀

Happy Learning! 💻