---
# System prepended metadata

title: 0 to FAANG DSA Bootcamp Syllabus

---

# 0 to FAANG DSA Bootcamp Syllabus
## NOTE:
* **All topics will contain problems from LeetCode Easy to Hard, explained in an easy to understand manner**.
* **Complete Custom Implementation of all Data Structures and Algorithms**
## Lectures
* Introduction to Programming <input type="checkbox" checked disabled>
* Introduction to Java <input type="checkbox" checked disabled>
    * How it works
    * Flowcharts & Pseudocode
    * Flow of the program
    * Setup Installation
    * Input and Output in Java
    * Data-types
    * Coding best practices
* Arrays <input type="checkbox" checked disabled>
    * Introduction
    * Memory management
    * Input and Output
    * ArrayList Introduction
    * Sorting
        * Insertion Sort
        * Selection Sort
        * Bubble Sort
        * Count Sort
        * Radix Sort
    * Searching <input type="checkbox" checked>
        * Linear Search
        * Binary Search
        * Modified Binary Search
    * Sliding window
    * Two Pointer
    * Subarray Questions
* Strings
    * How Strings work
    * Comparison of methods
    * Operations in Strings
    * StringBuilder in java
* Maths for DSA
    * Complete Bitwise Operators
    * Prime numbers
    * HCF / LCM
    * Sieve of Eratosthenes
    * Newton's Square Root Method
    * Number Theory
    * Euclidean algorithm
    * Advanced Concepts for CP (later in course)
        * Bitwice + DP
        * Extended Euclidean algorithm
        * Modulo Properties
        * Modulo Multiplicative Inverse
        * Linear Diophantine Equations
        * Fremat's Theorem
        * Wilson's Theorem
        * Lucas Theorem
        * Chinese Remainder Theorem
* Functions
    * Solving the above math problems in code
    * Scoping in Java
    * Shadowing
    * Variable Length Arguments
    * (more content in OOP such as overloading etc)
* Space and Time Complexity Analysis
    * 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
    * O 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
        * Cyclic Sort
    * Backtracking
        * Sudoku Solver
        * N-Queens
        * N-Knights
        * Maze problems
    * Recursion String Problems
    * Recursion Array Problems
    * Recursion Pattern Problems
    * Subset 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
* Stacks
* Queues
* Linked List
    * Introduction
    * Fast and slow pointer
    * Cycle Detection
    * Single and Doubly LinkedList
    * Reversal of LinkedList
* Dynamic Programming
    * Many interview patterns here such as 0/1 knapsack
* Binary Trees
    * DFS
    * BFS
    * AVL Trees
    * Segment Tree
* Square Root Decomposition
* Heaps & Priority Queue
* Two Heaps Method
    * Many interview patterns
        * k-way merge
        * top k elements
        * much more
* Hashmaps
    * Introduction
    * Theory - how it works
    * Comparisons of various forms
    * Limitations and how to solve
    * Map using LinkedList
    * Map using Has
    * Chaining
    * Probing
* Tries
* Graphs
    * Introduction
    * BFS
    * DFS
    * Working with graph components
    * Minimum Spanning Trees
    * Kruskal Algorithm
    * Prims Algorithm
    * Dijkstra's shortest path algorithm
    * Topological Sort







