Add Big O Notation technical document with Java code examples

[Copilot]

Create comprehensive documentation on Big O Notation for Java developers with 70 code examples covering algorithm analysis, complexity classes, and performance considerations.

Note: This PR was started but not completed due to technical issues with tool execution. The bigo.md file remains empty and needs to be populated with:

• Introduction - Big O definition, importance for Java developers, algorithm growth examples
• Core Complexity Classes (10 examples) - O(1) through O(n!) with code snippets
• Java Collections (15 examples) - ArrayList, LinkedList, HashMap, TreeMap, HashSet, ConcurrentHashMap, etc.
• Algorithms (15 examples) - Sorting, searching, recursion, graph algorithms (DFS, BFS, Dijkstra)
• Space Complexity (10 examples) - Memory usage comparisons, recursive stack depth, StringBuilder vs concatenation
• Practical Comparisons (10 examples) - ArrayList vs LinkedList, HashMap vs TreeMap, streams vs loops
• Advanced Topics (10 examples) - Amortized analysis, hash collisions, parallel streams, Big Ω/Θ notation
• Best Practices & Common Pitfalls - Guidelines and anti-patterns

Document should follow repository conventions (Java 25 compact source files, instance main methods, 80-char lines, dark theme code blocks) as established in completablefuture.md and concurrency.md.

Original prompt

On bigo.md, Create a detailed technical document explaining Big O Notation in the context of Java programming, illustrated with 70 code examples.
The document should include:

Introduction

Define Big O notation and its role in algorithm analysis.
Explain why understanding time and space complexity is critical for Java developers.
Provide a simple example of algorithm growth.
Core Complexity Classes (10 examples)

O(1): Array access, HashMap lookup.
O(log n): Binary search, TreeMap operations.
O(n): Linear search, array traversal.
O(n log n): Merge sort, quicksort.
O(n²): Nested loops, bubble sort.
O(2^n): Recursive Fibonacci.
O(n!): Permutations generation.
Include code snippets for each.
Java Collections (15 examples)

ArrayList: get, add, remove.
LinkedList: insert, delete, traversal.
HashMap: put, get, remove.
TreeMap and TreeSet: logarithmic operations.
HashSet: constant-time operations.
CopyOnWriteArrayList: read vs write.
PriorityQueue: insertion/removal.
ConcurrentHashMap: lookup.
BlockingQueue: producer-consumer.
Provide complexity tables and code snippets.
Algorithms (15 examples)

Sorting: Arrays.sort(), custom quicksort, merge sort.
Searching: linear search, binary search.
Recursion: factorial, Fibonacci.
Graph algorithms: DFS, BFS, Dijkstra.
Divide-and-conquer examples.
Include annotated Java code with complexity analysis.
Space Complexity (10 examples)

Array vs LinkedList memory usage.
Recursive stack depth.
Object overhead in Java.
String concatenation vs StringBuilder.
HashMap memory footprint.
Demonstrate space-efficient vs space-heavy implementations.
Practical Comparisons (10 examples)

ArrayList vs LinkedList insertion/removal.
HashMap vs TreeMap lookups.
Sorting small vs large datasets.
Streams vs loops performance.
Show how algorithm choice impacts scalability.
Advanced Topics (10 examples)

Amortized analysis (ArrayList resizing).
Hash collisions in HashMap.
Parallel streams overhead.
Complexity of concurrent collections.
Impact of garbage collection on performance analysis.
Big Ω (Omega) and Big Θ (Theta) notation.
Integration with CompletableFuture and async pipelines.
Best Practices

Choose data structures based on complexity requirements.
Avoid premature optimization; profile before tuning.
Use Big O as a guideline, not an absolute measure.
Consider constant factors and JVM optimizations.
Common Pitfalls

Misinterpreting amortized complexity.
Ignoring worst-case scenarios.
Overlooking space complexity in recursion.
Assuming Big O alone determines performance.
Conclusion

Summarize the importance of Big O for Java developers.
Emphasize how it guides algorithm and data structure choices.
Encourage combining theoretical analysis with practical profiling.
Formatting Requirements:

Use clear section headings.
Include 70 Java code snippets across all sections.
Provide diagrams or tables comparing complexities.
Write in a professional, educational tone suitable for intermediate to advanced Java developers.
Ensure the document is cohesive, well-organized, and easy to follow.

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.