Data Structures And Algorithms With Java

Master Java Programming & Data Structures

What you'll learn

Core Java Programming – Syntax, data types, control structures, functions, and exception handling.

Object-Oriented Programming (OOP) – Concepts like classes, objects, inheritance, polymorphism, abstraction, and encapsulation in Java.

Design Principles – Industry-standard principles such as SOLID, DRY, KISS, and YAGNI to write clean, maintainable code.

Design Patterns & Machine Coding – Introduction to common design patterns and how to approach machine coding rounds in interviews.

Linear Data Structures – Implementation and use cases of Arrays, ArrayLists, LinkedLists, Stacks, Queues, and HashMaps in Java.

Non-Linear Data Structures – Understanding Trees (BST, AVL), Heaps (Min/Max), Tries, and Graphs along with traversal algorithms like DFS and BFS.

Bit Manipulation – In-depth understanding of how bits work, including binary-decimal conversions and low-level operations.

Space and Time Complexity – Learn how to analyze the efficiency of your code using Big-O notation.

Requirements

Basic familiarity with programming concepts (helpful but not mandatory)

Description

Welcome to the ultimate Java programming course by Piyush Garg — designed for beginners, intermediate learners, and seasoned developers who want to master Java and data structures from the ground up.In this comprehensive course, we begin with the core fundamentals of Java, covering syntax, object-oriented programming (OOP), and essential design principles like SOLID, DRY, and KISS. Whether you're new to programming or a college student aiming to strengthen your Java skills, this course is your go-to guide. We'll progress gradually, ensuring crystal-clear understanding of each topic.Java, being the most popular programming language, powers over 90% of Fortune 500 companies, Android applications, and financial systems. Its strong support for OOP makes it the ideal choice for aspiring software engineers.You’ll also learn to implement and work with both linear and non-linear data structures. In the linear section, we cover Arrays, ArrayLists, LinkedLists, Stacks, Queues, and HashMaps — the building blocks of any efficient program. Then, we dive into advanced topics like Trees (BST, AVL), Heaps (Min/Max), Tries, and Graphs, including key traversal algorithms like DFS and BFS.This course is packed with coding challenges to help you solidify concepts and prepare for technical interviews and machine coding rounds.By the end, you’ll be confident in Java and equipped to master Data Structures and Algorithms with ease.

Overview

Section 1: Introduction

Lecture 1 How Java Works

Lecture 2 Setting up Java and Intellij Idea

Section 2: Basics

Lecture 3 Hello World

Lecture 4 Data Types in Java

Lecture 5 Non Primitive Data Types

Lecture 6 Variables and Constants in Java

Lecture 7 Basic Athematic Operators

Lecture 8 Taking Input from User

Lecture 9 Conditional Statements in Java

Lecture 10 Switch Statements in Java

Lecture 11 Loops in Java

Lecture 12 What are Arrays?

Lecture 13 Arrays in Java

Lecture 14 Arrays in Java Part 2

Lecture 15 2D Arrays in Java

Lecture 16 Dynamic Arrays using Lists

Lecture 17 Exception and Exception Handling

Lecture 18 Array Data Structure

Lecture 19 HashMap Data Structure

Lecture 20 Set Data Structure

Section 3: Object Oriented Programming with Java

Lecture 21 Introduction to OOPS

Lecture 22 Benefits of OOPS

Lecture 23 Methods and this keyoword

Lecture 24 Constructor

Lecture 25 Getters and Setters

Lecture 26 Static Keyword

Lecture 27 Pillars of OOPS

Lecture 28 Pillars of OOPS Part 2

Lecture 29 Abstract Classes and Methods

Lecture 30 Interfaces

Lecture 31 OOPS Practice Question - 1

Section 4: Design Principles and Patterns

Lecture 32 DRY

Lecture 33 KISS and YAGNI

Lecture 34 S.O.L.I.D Principles

Lecture 35 Singleton Design Pattern

Lecture 36 Factory Design Pattern

Lecture 37 Builder Design Pattern

Lecture 38 Adapter Design Pattern

Lecture 39 Bridge Design Pattern

Lecture 40 Proxy Design Pattern

Lecture 41 Command Design Pattern

Lecture 42 Observer Design Pattern

Lecture 43 Iterator Design Pattern

Section 5: Data Structure and Algorithms

Lecture 44 Space and Time Complexity

Lecture 45 Constant Space Time Complexity

Lecture 46 Linear Space Time Complexity

Lecture 47 What is DSA?

Lecture 48 Logarithmic Space Time Complexity

Lecture 49 Quadratic Space Time Complexity

Lecture 50 Quick Recap

Section 6: Fundamentals

Lecture 51 Basics of Binary and Decimal Number System

Lecture 52 Bitwise Operators

Lecture 53 Left Shift and Right Shift

Lecture 54 Counting Bits

Lecture 55 Convert Binary to Decimal

Lecture 56 Convert Decimal to Binary

Lecture 57 Reverse and Integer

Lecture 58 Power of two

Lecture 59 Compliment Base 10 Integer

Section 7: Basic Maths

Lecture 60 Prime Number

Lecture 61 Sieve of Eratosthenes

Lecture 62 Factorial of Number

Section 8: Basics of Recursion

Lecture 63 Introduction to Recursion

Lecture 64 X to the Power n

Section 9: Linear Data Structures

Lecture 65 Introduction

Lecture 66 Getting Started with Arrays

Lecture 67 Understanding Memory Allocation

Lecture 68 Dynamic Arrays

Lecture 69 Create Array from Scratch

Lecture 70 Find Index using Linear Search

Lecture 71 Removing Elements

Lecture 72 Min and Max in Array

Lecture 73 Reverse an Array

Lecture 74 Adding support to Dynamic Size Arrays

Section 10: Problem Solving - Arrays

Lecture 75 Single Number

Lecture 76 Two Sum

Lecture 77 Sort Colors

Lecture 78 Merge Sorted Arrays

Lecture 79 Move Zeros

Lecture 80 Intersect Arrays

Lecture 81 Check if Array is Sorted and Rotated

Section 11: Linked Lists

Lecture 82 Introduction

Lecture 83 Understanding Memory Allocation

Lecture 84 Working with Built-In LinkedList

Lecture 85 Types of LinkedList

Lecture 86 Creating LinkedList from Scratch

Lecture 87 Traversing LinkedList

Lecture 88 Reverse LinkedList

Lecture 89 Delete Node from Beginning

Lecture 90 Delete Node From End

Lecture 91 Kth Node From End

Lecture 92 Traversing Linked List

Lecture 93 Reverse Linked List

Section 12: Problem Solving - LinkedList

Lecture 94 Swap Pairs

Lecture 95 Reverse in K groups

Lecture 96 Cyclic Detection

Lecture 97 Find Middle of LinkedList

Lecture 98 Detect & Remove Loop

Lecture 99 Remove Duplicates

Section 13: Stacks

Lecture 100 Introduction

Lecture 101 Working with Stack Class

Lecture 102 Creating Own Stack

Lecture 103 Remove Elements from Top

Lecture 104 Peek Elements

Lecture 105 Stack Overflow

Lecture 106 Stack Underflow

Lecture 107 Creating Stack using LinkedList

Section 14: Problem Solving Stacks

Lecture 108 Two Stacks

Lecture 109 Reverse Strings

Lecture 110 Valid Parentheses

Lecture 111 Insert An Element At its bottom

Lecture 112 Reverse Stack

Lecture 113 Sort Stack

Lecture 114 Redundant Brackets

Lecture 115 Celebrity Problem

Lecture 116 Min Stack O(n)

Lecture 117 Min Stack O(1)

Section 15: Queues

Lecture 118 Introduction

Lecture 119 Working with Queues in Java

Lecture 120 Reverse Queue

Lecture 121 Creating Own Queue

Lecture 122 Dequeue from Queue

Lecture 123 Bug in Queue

Lecture 124 Fixing Bug in Circular Arrays

Lecture 125 Building Queue using Stacks

Lecture 126 Priority Queues

Lecture 127 Build Priority Queue

Section 16: Queue Part - 2

Lecture 128 Design Circular Queue

Lecture 129 Design Double Ended Queue

Lecture 130 Reverse Queue using Recursion

Lecture 131 First Negative Integer in window size K

Lecture 132 Reverse First K elements of Queue

Lecture 133 Interleave the first half of queue with second one

Section 17: HashMaps

Lecture 134 Introduction

Lecture 135 HashMap Java

Lecture 136 Non Repeated Char

Lecture 137 First Repeated Char

Lecture 138 Hash Function

Lecture 139 Open Addressing

Lecture 140 Double Hashing

Lecture 141 Building Own HashMap

Lecture 142 Chaining

Lecture 143 Getting Data

Lecture 144 Quadratic Probing

Lecture 145 Remove Data

Section 18: Non Linear Data Structures

Lecture 146 Introduction

Section 19: Binary Trees

Lecture 147 Introduction

Lecture 148 Understanding Binary and Binary Search Trees

Lecture 149 Building Binary Search Tree

Lecture 150 Travelling Nodes

Lecture 151 Find Element in Tree

Lecture 152 Tree Traversals

Lecture 153 Pre-Order

Lecture 154 In-Order

Lecture 155 Post Order

Lecture 156 Depth and Height

Lecture 157 Minimum Value in Tree

Lecture 158 Equality Checking

Lecture 159 Validating Binary Tree

Lecture 160 Nodes at K distance

Lecture 161 Level Order Traverasal

Section 20: Mastering Binary Trees

Lecture 162 Diameter

Lecture 163 Balanced or Not

Lecture 164 Sum Tree or Not

Lecture 165 Zig Zag Traversal

Lecture 166 Boundary Traversal

Lecture 167 Vertical Order Traversal

Lecture 168 Top View

Lecture 169 Bottom View

Lecture 170 Right View

Lecture 171 Diagonal Traversal

Lecture 172 Sum of nodes of longest path

Lecture 173 LCA of Binary Tree

Lecture 174 Minimum Time to Burn Tree

Lecture 175 Morris Traversal

Lecture 176 Flatten Binary Tree

Section 21: Binary Search Trees

Lecture 177 In-order Predecessor and Succesor

Lecture 178 Kth Smallest/Largest in BST

Lecture 179 LCA in BST

Lecture 180 Normal BST to Balanced

Lecture 181 Merge Two Binary Trees

Lecture 182 Largest BST in Binary Tree

Section 22: AVL Trees

Lecture 183 Introduction

Lecture 184 Understanding Rotations

Lecture 185 LeftRight and RightLeft Rotations

Lecture 186 Creating an AVL Tree from Scratch

Lecture 187 Detecting Imbalanced Node

Lecture 188 Detecting Rotations - 1

Lecture 189 Detecting Rotations - 2

Lecture 190 Implementing Left and Right Rotations

Section 23: Heaps

Lecture 191 Introduction

Lecture 192 Heap Insert Logic

Lecture 193 Creating Heap from Scratch

Lecture 194 Removing Element Logic

Lecture 195 Heapify

Lecture 196 K-th Smallest Element

Lecture 197 Check if Binary Tree is a Valid Max Heap

Lecture 198 Smallest Range in K Lists

Section 24: Tries

Lecture 199 Introduction

Lecture 200 Building TRIE from Scratch

Lecture 201 Autocomplete using TRIE

Lecture 202 Removing Elements from TRIE

Lecture 203 Longest Common Prefix

Section 25: Graphs

Lecture 204 Introduction

Lecture 205 Adjacency Matrix and Adjacency List

Lecture 206 Building Graph from Scratch

Lecture 207 Traversal - Breadth First Search

Lecture 208 Traversal - Depth First Search

Lecture 209 Cyclic Detection in Graph

Lecture 210 Topological Sort

Lecture 211 Kahn's Algorithm

Lecture 212 Refactoring Graphs to OOPS Style

Lecture 213 Building Directed Weighted Graph

Lecture 214 Shortest Path Algorithm

Lecture 215 Shortest Path Algorithm - Code

Section 26: Undirected Graphs

Lecture 216 Introduction

Lecture 217 Cyclic Detection

Lecture 218 Dijkstra's Algorithm

Lecture 219 Coding Dijkstra's Algorithm

Lecture 220 Minimum Spanning Tree

Lecture 221 Prim's Algorithm

Lecture 222 Prim's Algorithm Code

Section 27: Algorithms

Lecture 223 Recursion

Lecture 224 Recursion Memory Stack

Lecture 225 Fibonacci Series

Lecture 226 Climb Stairs

Lecture 227 Say Digits

Lecture 228 Reverse Strings

Lecture 229 Check for Pallindrome

Section 28: Mastering Recursion - Part 2

Lecture 230 Subset / Subsequences of String

Lecture 231 Phone Keypad Problem

Lecture 232 Permutation of String

Section 29: Sorting Algorithms

Lecture 233 Bubble Sort

Lecture 234 Selection Sort

Lecture 235 Insertion Sort

Lecture 236 Merge Sort

Lecture 237 Quick Sort

Section 30: Searching Algorithms

Lecture 238 Linear Search

Lecture 239 Binary Search

Lecture 240 Binary Search Recursive

Lecture 241 Exponential Search

Beginners who want to start programming and are looking for a structured, beginner-friendly introduction to Java and core programming concepts.,College and university students studying computer science or related fields who want to build a solid foundation in Java and data structures.,Aspiring software engineers preparing for internships, job interviews, and machine coding rounds at top tech companies.,Java developers looking to refresh or deepen their understanding of core concepts, OOP, and data structures.,Competitive programming enthusiasts who want to improve their grasp of Java's implementation of complex data structures.,Professionals preparing for technical interviews who need a strong revision of linear and non-linear data structures using Java.