Sigma 9.0

Segment Trees

What will you learn?

Prerequisites

Flowchart Components

Sum of 2 Numbers

Calculate Simple Interest

Max of 3 Numbers

Find if a Number is Prime or not

Sum of first N natural numbers

Boilerplate Code

Output in Java

Print a Pattern

Variables in Java

Data Types in Java

Sum of a & b

Comments in Java

Input in Java

Sum of a & b (Input from User)

Product of a & b

Area of a Circle

Type Conversion

Type Casting

Type Promotion in Expression

How does Java code run?

Arithmetic Operators

Unary Operators

Relational Operators

Logical Operators

Assignment Operators

Print the largest of 2 numbers

Print if number is Odd or Even

else if

Income Tax Calculator

Print the largest of 3 numbers

Ternary Operator

Check if a student will Pass or Fail

Switch statement

Calculator

while Loop

Print numbers from 1 to 10

Print numbers from 1 to n

Sum of first N natural numbers

for Loop

Print Square pattern

Print reverse of a number

Reverse the given number

do while Loop

Break statement

Question - break keyword

Continue statement

Question - continue keyword

Check if a number is Prime or not

Inverted Star Pattern

Half Pyramid Pattern

Character Pattern

Special Note

Syntax - Function Code Demo

Syntax with Parameters

Parameters v/s Arguments

What happens in memory? (Call Stack)

Call by Value (in Java)

Product of a & b

Find Factorial

Find Binomial Coefficient

Inbuilt v/s User defined Methods

Function Overloading

Overloading using Parameters

Overloading using Data Types

Check if a number is Prime or not

Check Prime (Optimized)

Primes in Range

Binary to Decimal

Code - Binary to Decimal

Decimal to Binary

Code - Decimal to Binary

Method Scope

Block Scope

Dry Run - Hollow Rectangle Pattern

Inverted & Rotated Half Pyramid

Inverted Half Pyramid Pattern with Numbers

Floyd's Triangle Pattern

0-1 Triangle Pattern

Butterfly Pattern

Butterfly Pattern Code (explanation continued as well)

Solid Rhombus Pattern

Hollow Rhombus Pattern

Diamond Pattern

Arrays - Creation

Arrays - Input, Output & Update

Arrays as Function Arguments

Linear Search

Largest in Array

Binary Search

Binary Search Code

Reverse an Array

Pairs in Array

Print Subarrays

Max Subarray Sum - II (Prefix Sum)

Max Subarray Sum - III (Kadane's Algorithm)

Trapping Rainwater

Trapping Rainwater - Code

Best Time to Buy & Sell Stock

Bubble Sort

Bubble Sort Code

Selection Sort

Selection Sort Code

Insertion Sort

Insertion Sort Code

Inbuilt Sort

Counting Sort

Counting Sort Code

Real life examples

Representation of 2D Arrays

Creation of 2D Arrays

2D Arrays in Memory

Spiral Matrix

Spiral Matrix Code

Diagonal Sum

Search in Sorted Matrix

Search in Sorted Matrix Code

Input/Output

String Length

String Concatenate

String charAt Method

Check if a String is Palindrome

Question - Shortest Path

String Functions - compare

String Functions - substring

Print Largest String

Why Strings are Immutable?

StringBuilder

Convert Letters to Uppercase

String Compression

Binary Number System

Bitwise Operators

Binary AND

Binary OR

Binary XOR

Binary 1's Complement

Binary Left Shift

Binary Right Shift

Check if Odd or Even

Get ith Bit

Set ith Bit

Clear ith Bit

Update ith bit

Clear last i bits

Clear range of bits

Check if a number is power of 2 or not

Count set bits in a number

Fast Exponentiation

Fast Exponentiation Code

Access Modifiers

Getters & Setters

Encapsulation

Constructors

Type of Constructors

Copy Constructor

Shallow & Deep Copy

Destructors

Inheritance

Single level Inheritance

Multi level Inheritance

Hierarchial Inheritance

Hybrid Inheritance

Polymorphism

Method Overloading

Method Overriding

Packages in Java

Abstraction

Abstract Classes

Interfaces

Static keyword

Super keyword

Solved Questions Practice

Print numbers in decreasing order

Stack overflow

Print numbers in increasing order

Find Factorial of N

Print sum of N natural numbers

Print Nth Fibonacci number

Check if array is sorted or not

First Occurrence

Last Occurrence

Print x to the power n

Print x to the power n (Optimized)

Tiling Problem Code

Remove Duplicates in a String

Friends Pairing Problem

Binary Strings Problem

Binary Strings Problem Code

Stack Analysis - Binary Strings

Merge Sort (Basic + Space Optimized)

Merge Sort Code

Quick Sort

Quick Sort Code

Worst Case in Quick Sort

Sorted & Rotated Array Search

Sorted & Rotated Array Code

What is Time Complexity?

Constant Time Complexity

Big O Notation

Big Omega & Theta Notation

Common Complexities

Space Complexity

Simple Loop Analysis

Nested Loop 1 Analysis

Nested Loop 2 Analysis

Nested Loop 3 Analysis

Bubble Sort Analysis

Binary Search Analysis

Recursive Complexity Analysis (Factorial)

Sum of N numbers Analysis

Fibonacci Analysis

Merge Sort Analysis

Recurrence Relation - Merge Sort

Power Function I - Analysis

Power Function II - Analysis

Power Function III - Analysis

How to approach Coding Questions?

Types of Backtracking

Backtracking on Arrays

Find Subsets

Find Subsets Code

Find Permutations

Find Permutations Code

N Queens - all ways

N Queens - Time Complexity

N Queens - count ways

N Queens - print one solution

Grid Ways

Grid Ways Code

Grid Ways Trick

Sudoku

Sudoku Code

Operations on ArrayList

Size of ArrayList

Print Reverse

Find Maximum

Swap 2 Numbers

Sorting an ArrayList

ArrayList (Implementation in Java)

Multi-dimensional ArrayLists

Container with Most Water (Brute Force)

Container with Most Water (2 Pointer Approach)

Container wMW v/s Trapping Rainwater

Pair Sum - 1 (Brute Force)

Pair Sum - 1 (2 Pointer Approach)

Pair Sum - 2

Pair Sum - 2 (Code)

Head & Tail in LL

Add First in LL

Add Last in LL

Print a LL

Add in the Middle of LL

Size of a LL

Remove First in LL

Remove Last in LL

Iterative Search

Recursive Search

Reverse a Linked List

Find and Remove Nth Node from End

Check if LL is Palindrome

Check if LL is Palindrome (Code)

Detecting Cycle Code

Removing Cycle in LL

Removing Cycle Code

Removing Cycle Explanation (Math)

Java Collections Framework

LL in Collections Framework

Merge Sort on LL

Merge Sort on LL (Code)

Zig Zag Linked List

Zig Zag LL Code

Doubly LL

Reverse a Doubly LL

Circular LL (Approach)

Stack using ArrayList

Stack using Linked List

Stack using Collections Framework

Push at Bottom of Stack

Reverse a String using a Stack

Reverse a Stack

Stock Span Problem

Next greater element

Next greater element Code

Valid Parentheses Code

Duplicate Parentheses

Duplicate Parentheses Code

Maximum Rectangular Area in Histogram

Max Rectangular Area in Histogram (Code)

Queues using Arrays

Circular Queue using Arrays

Queue using LL

Queue using JCF

Queue using Two Stacks

Stack using 2 Queues

First Non-Repeating Letter

Interleave two halves of a Queue

Queue Reversal

Deque (Double Ended Queue)

Deque in JCF

Implement Stack using Deque

Implement Queue using Deque

Activity Selection

Activity Selection Code

Activity Selection Explanation

Fractional Knapsack

Fractional Knapsack Code

Minimum Sum absolute difference pairs

Maximum length chain of pairs

Indian Coins

Job Sequencing Problem

Chocola Problem

Chocola Problem Code

Levels & Sub-trees in a Tree

Pop Quiz

Build Tree Preorder

Build Tree Preorder Code

Preorder Traversal

Inorder Traversal

Postorder Traversal

Level order Traversal

Height of a Tree

Count of Nodes of a Tree

Sum of Nodes

Diameter of a Tree (Approach2)

Subtree of another tree

Subtree of another tree Code

Top View of a Tree (Basics)

Top View of a Tree (Approach)

Top View of a Tree (Code)

Lowest Common Ancestor (Approach1)

Lowest Common Ancestor (Approach2)

Minimum Distance between 2 Nodes

Kth ancestor of Node

Transform to Sum Tree

Concept of Search in BST

Build a BST

Search in a BST

Delete a Node

Print in Range

Root to Leaf Path

Validate BST

Mirror a BST

Convert BST to Balanced BST

Size of Largest BST in BT

Size of Largest BST in BT (Code)

AVL Trees

PQ in JCF

PQ for Objects

Introduction to Heaps

Heap Implementation (using CBT)

Insert in Heap

Peek from Heap

Remove from Heap

Heap Sort

Nearby Cars

Connect N Ropes with Minimum Cost

Weakest Soldier

Sliding Window Maximum

HashMap

HashMap Operations

Iteration on HashMaps

HashMap Implementation

HashMap Implementation Code

Special Note

LinkedHashMap

TreeMap

Majority Element

Valid Anagram

HashSet

Iteration on HashSets

LinkedHashSet

TreeSet

Count Distinct Elements

Union & Intersection

Find Itinerary for Tickets

Largest Subarray with Sum 0

Subarray Sum Equal to K

What is a Trie?

Creating a Trie

Insertion

Searching

Word Break Problem

Prefix Problem

startsWith Problem

Unique Substrings

Longest Word with all Prefixes

Types of Graphs (Based on Edge)

Graph Representations

Graph Applications

Creating a Graph (Adjacency List)

BFS (Breadth First Search)

DFS (Depth First Search)

Has Path? (using DFS)

Cycle in Graphs

Cycle Detection (Undirected Graph) - DFS

Bipartite Graph

Cycle Detection (Directed graph) - DFS

Extra Read

Topological Sorting (using DFS)

Topological Sort using BFS (Code)

All Paths from Source to Target

Dijkstra's Algorithm

Dijkstra's Algorithm (Code)

Bellman Ford (Code)

What is MST?

Prim's Algorithm

Prim's Code

Cheapest Flights within K Stops (Code)

Connecting Cities

Connecting Cities (Code)

Disjoint Set Union

Kruskal's Algorithm

Flood Fill Algorithm

Bridge in Graph (Tarjan's Algorithm)

Articulation Point (Tarjan's Algorithm)

What is DP? (Definition)

Ways of DP

7 Important Concepts

Climbing Stairs (Recursion)

Climbing Stairs (Memoization DP)

Climbing Stairs Variation

Climbing Stairs (Tabulation DP)

0-1 Knapsack (Recursion)

0-1 Knapsack (Memoization)

0-1 Knapsack (Tabulation)

Target Sum Subset (Tabulation)

Target Sum Subset (Code)

Unbounded Knapsack (Tabulation)

Rod Cutting

Longest Common Subsequence (Recursion)

LCS (Memoization)

LCS (Tabulation)

Longest Increasing Subsequence

Edit Distance (Explanation)

Edit Distance (Code)

String Conversion

Wildcard Matching (Code)

Catalan's Number (Recursion + Memoization)

Catalan's Number (Tabulation)

Count BSTs

Mountain Ranges

Matrix Chain Multiplication (Recursion)

MCM (Memoization)

MCM (Tabulation)

Minimum Partitioning

Minimum Array Jumps (Explanation)

Minimum Array Jumps (Code)

Count & Meaning of Nodes

Creation of ST

Queries on ST

Update on ST

Max/Min Segment Tree (Creation)

Max/Min Segment Tree (Query/Update)