# Progress Tracker

[me-imfhd]

    # Progress Tracker

DSA

• [ ] Complete Git & GitHub Course
• [x] Introduction to Programming
  • • [x] Types of languages
  • • [x] Memory management
• [x] Flow of the program
  • • [x] Flowcharts
  • • [x] Pseudocode
• [x] Introduction to Java
  • • [x] Introduction
  • • [x] How it works
  • • [x] Setup Installation
  • • [x] Input and Output in Java
  • • [x] Conditionals & Loops in Java
    • • [x] if else
    • • [x] loops
    • • [x] Switch statements
  • • [x] Data types
  • • [x] Coding best practices
• [x] Functions
  • • [x] Introduction
  • • [x] Scoping in Java
  • • [x] Shadowing
  • • [x] Variable Length Arguments
  • • [x] Overloading
• [ ] Arrays
  • • [x] Introduction
  • • [x] Memory management
  • • [x] Input and Output
  • • [x] ArrayList Introduction
  • • [ ] Sorting
    • • [ ] Insertion Sort
    • • [ ] Selection Sort
    • • [ ] Bubble Sort
    • • [ ] Cyclic Sort (Merge sort etc after recursion)
  • [x] Searching
    • • [x] Linear Search
    • • [x] Binary Search
    • • [x] Modified Binary Search
    • • [x] Binary Search Interview questions
    • • [x] Binary Search on 2D Arrays
• [ ] Pattern questions
• [ ] Strings
  • [ ] Introduction
  • [ ] How Strings work
  • [ ] Comparison of methods
  • [ ] Operations in Strings
  • [ ] StringBuilder in java
• [ ] Maths for DSA
  • • [ ] Introduction
  • • [ ] Complete Bitwise Operators
  • • [ ] Prime numbers
  • • [ ] HCF / LCM
  • • [ ] Sieve of Eratosthenes
  • • [ ] Newton's Square Root Method
  • • [ ] Number Theory
  • • [ ] Euclidean algorithm
• [ ] Space and Time Complexity Analysis
  • • [ ] Introduction
  • • [ ] Comparion of various cases
  • • [ ] Solving Linear Recurrence Relations
  • • [ ] Solving Divide and Conquer Recurrence Relations
  • • [ ] Big-O, Big-Omega, Big-Theta Notations
  • • [ ] Get equation of any relation easily - best and easiest approach
  • • [ ] Complexity discussion of all the problems we do
  • • [ ] Space Complexity
  • • [ ] Memory Allocation of various languages
  • • [ ] NP Completeness and Hardness
• [ ] Recursion
  • • [ ] Introduction
  • • [ ] Why recursion?
  • • [ ] Flow of recursive programs - stacks
  • • [ ] Convert recursion to iteration
  • • [ ] Tree building of function calls
  • • [ ] Tail recursion
  • • [ ] Sorting:
      • • [ ] Merge Sort
      • • [ ] Quick Sort
  • • [ ] Backtracking
      • • [ ] Sudoku Solver
      • • [ ] N-Queens
      • • [ ] N-Knights
      • • [ ] Maze problems
  • • [ ] Recursion String Problems
  • • [ ] Recursion Array Problems
  • • [ ] Recursion Pattern Problems
  • • [ ] Subset Questions
  • • [ ] Recursion - Permutations, Dice Throws etc Questions
• [ ] Object Oriented Programming
  • • [ ] Introduction
  • • [ ] Classes & its instances
  • • [ ] this keyword in Java
  • • [ ] Properties
      • • [ ] Inheritance
      • • [ ] Abstraction
      • • [ ] Polymorphism
      • • [ ] Encapsulation
  • • [ ] Overloading & Overriding
  • • [ ] Static & Non-Static
  • • [ ] Access Control
  • • [ ] Interfaces
  • • [ ] Abstract Classes
  • • [ ] Singleton Class
  • • [ ] final, finalize, finally
  • • [ ] Exception Handling
• [ ] Linked List
  • • [ ] Introduction
  • • [ ] Singly and Doubly Linked List
  • • [ ] Circular Linked List
  • • [ ] Fast and slow pointer
  • • [ ] Cycle Detection
  • • [ ] Reversing of LinekdList
  • • [ ] Linked List Interview questions
• [ ] Stacks & Queues
  • • [ ] Introduction
  • • [ ] Interview problems
  • • [ ] Push efficient
  • • [ ] Pop efficient
  • • [ ] Queue using Stack and Vice versa
  • • [ ] Circular Queue
• [ ] Dynamic Programming
  • • [ ] Introduction
  • • [ ] Recursion + Recursion DP + Iteration + Iteration Space Optimized
  • • [ ] Complexity Analysis
  • • [ ] 0/1 Knapsack
  • • [ ] Subset Questions
  • • [ ] Unbounded Knapsack
  • • [ ] Subseq questions
  • • [ ] String DP
• [ ] Trees
  • • [ ] Introduction
  • • [ ] Binary Trees
  • • [ ] Binary Search Trees
  • • [ ] DFS
  • • [ ] BFS
  • • [ ] AVL Trees
  • • [ ] Segment Tree
  • • [ ] Fenwick Tree / Binary Indexed Tree
• [ ] Heaps
  • • [ ] Introduction
  • • [ ] Theory
  • • [ ] Priority Queue
  • • [ ] Two Heaps Method
  • • [ ] k-way merge
  • • [ ] top k elements
  • • [ ] interval problems
• [ ] Hashmaps
  • • [ ] Introduction
  • • [ ] Theory - how it works
  • • [ ] Comparisons of various forms
  • • [ ] Limitations and how to solve
  • • [ ] Map using LinkedList
  • • [ ] Map using Hash
  • • [ ] Chaining
  • • [ ] Probing
  • • [ ] Huffman-Encoder
• [ ] Tries
• [ ] Graphs
  • • [ ] Introduction
  • • [ ] BFS
  • • [ ] DFS
  • • [ ] Working with graph components
  • • [ ] Minimum Spanning Trees
  • • [ ] Kruskal Algorithm
  • • [ ] Prims Algorithm
  • • [ ] Dijkstra’s shortest path algorithm
  • • [ ] Topological Sort
  • • [ ] Bellman ford
  • • [ ] A* pathfinding Algorithm
• [ ] Greedy Algorithms

Advanced concepts apart from interviews

• [ ] Fast IO
• [ ] File handling
• [ ] Bitwise + DP
• [ ] Extended Euclidean algorithm
• [ ] Modulo Multiplicative Inverse
• [ ] Linear Diophantine Equations
• [ ] Matrix Exponentiation
• [ ] Mathematical Expectation
• [ ] Catalan Numbers
• [ ] Fermat’s Theorem
• [ ] Wilson's Theorem
• [ ] Euler's Theorem
• [ ] Lucas Theorem
• [ ] Chinese Remainder Theorem
• [ ] Euler Totient
• [ ] NP-Completeness
• [ ] Multithreading
• [ ] Fenwick Tree / Binary Indexed Tree
• [ ] Square Root Decomposition

Originally posted by @DivSriv in https://github.com/kunal-kushwaha/DSA-Bootcamp-Java/issues/679#issuecomment-1159684931

[rishiraj88]

Gratitude to all contributors... always! I am proud to be a member here. And, promise to assess the present state and add further value here.

[SheikNR]

Anything to add?