Who Should Take This Course?

Understanding Data Structures

Types of Data Structures

An Overview of Big-O

Introduction to Data Structures

Introduction to Arrays

Arrays in Different Programming Languages

Problem 1: Running Sum of 1d Array (easy)

Solution: Running Sum of 1d Array (easy)

Problem 2: Contains Duplicate (easy)

Solution: Contains Duplicate

Problem 3: Left and Right Sum Differences (easy)

Solution: Left and Right Sum Differences (easy)

Problem 4: Find the Highest Altitude (easy)

Solution: Find the Highest Altitude  (easy)

Array

Introduction to Matrix

Problem 1: Richest Customer Wealth (easy)

Solution: Richest Customer Wealth (easy) 

Problem 2: Matrix Diagonal Sum (easy)

Solution: Matrix Diagonal Sum (easy) 

Problem 3: Row With Maximum Ones(easy)

Solution: Row With Maximum Ones(easy) 

Matrix

Introduction to Stack

Operations on Stack

Implementing Stack Data Structure

Applications of Stack

Problem 1: Balanced Parentheses (easy)

Solution: Balanced Parentheses

Problem 2: Reverse a String (easy)

Solution: Reverse a String

Problem 3: Decimal to Binary Conversion (medium)

Solution: Decimal to Binary Conversion 

Problem 4: Next Greater Element (easy)

Solution: Next Greater Element

Problem 5: Sorting a Stack (easy)

Solution: Sorting a Stack 

Problem 6: Simplify Path (medium)

Solution: Simplify Path 

Problem 7: Remove All Adjacent Duplicates In String (medium)

Solution: Remove All Adjacent Duplicates In String 

Problem 8: Removing Stars From a String (medium)

Solution: Removing Stars From a String 

Problem 9: Make The String Great (easy)

Solution: Make The String Great 

Stack

Introduction to Queues

Working with Simple Queues

Diving Deeper – Circular Queues and Deques

Applications and Advanced Concepts 

Problem 1: Reverse a Queue (easy)

Solution: Reverse a Queue 

Problem 2: Implement Stack using Queues

Solution: Implement Stack using Queues (easy)

Problem 3: Generate Binary Numbers from 1 to N

Solution: Generate Binary Numbers from 1 to N (medium)

Problem 4: Palindrome Check using Queue (easy)

Solution: Palindrome Check using Queue 

Problem 5: Zigzag Iterator (medium)

Solution: Zigzag Iterator 

Problem 6: Max of All Subarrays of Size 'k'

Solution: Max of All Subarrays of Size 'k'  (medium)

Queue

Introduction to LinkedList

Operations on Singly Linked List

Operations on Doubly Linked List

Problem 1: Reverse Linked List (easy)

Solution: Reverse Linked List 

Problem 2: Remove Duplicates from Sorted List (easy)

Solution: Remove Duplicates from Sorted List 

Problem 3: Merge Two Sorted Lists (easy)

Solution: Merge Two Sorted Lists 

Problem 4: Find if Doubly Linked List is a Palindrome (easy)

Solution: Find if Doubly Linked List is a Palindrome

Problem 5: Swap Nodes in Pairs (medium)

Solution: Swap Nodes in Pairs

LinkedList

Introduction to Tree

Binary Search Tree (BST) 

Maximum Depth (or Height)  of Binary Tree (easy)

Solution: Maximum Depth (or Height)  of Binary Tree 

Balanced Binary Tree (easy)

Solution: Balanced Binary Tree  

Minimum Difference Between BST Nodes (easy)

Solution: Minimum Difference Between BST Nodes  

Range Sum of BST (easy)

Solution: Range Sum of BST 

Kth Smallest Element in a BST (medium)

Solution: Kth Smallest Element in a BST 

Closest Binary Search Tree Value (medium)

Solution: Closest Binary Search Tree Value 

Merge Two Binary Trees (medium)

Solution: Merge Two Binary Trees 

Tree & Binary Search Tree

Introduction to Hashing

Introduction to Hash Tables

Issues with Hash Tables

Problem 1: First Non-repeating Character (easy)

Solution: First Non-repeating Character  (easy)

Problem 2: Largest Unique Number (easy)

Solution: Largest Unique Number (easy) 

Problem 3: Maximum Number of Balloons (easy)

Solution: Maximum Number of Balloons (easy) 

Problem 4: Longest Palindrome(easy)

Solution: Longest Palindrome(easy) 

Problem 5: Ransom Note (easy)

Solution: Ransom Note (easy) 

Hash Table (aka Hashmap or Dictionary)

Introduction to HashSets

Problem 1: Counting Elements (easy)

Solution: Counting Elements (easy) 

Problem 2: Jewels and Stones (easy)

Solution: Jewels and Stones (easy)

Problem 3: Unique Number of Occurrences (easy)

Solution: Unique Number of Occurrences (easy) 

Problem 4: Longest Substring Without Repeating Characters (medium)

Solution: Longest Substring Without Repeating Characters (medium) 

HashSet

Introduction to Heap

Take Gifts From the Richest Pile(easy)

Solution: Take Gifts From the Richest Pile(easy) 

Sort Characters By Frequency (easy)

Solution: Sort Characters By Frequency (easy) 

Minimum Cost to Connect Sticks(medium)

Solution: Minimum Cost to Connect Sticks(medium) 

Find the Median of a Number Stream (medium)

Solution: Find the Median of a Number Stream

Heap

Introduction to Graph

Graph Representations

Graph as an Abstract Data Type (ADT)

Graph Traversal - Depth First Search(DFS)

Graph Traversal - Breadth First Search (BFS)

Problem  1: Find if Path Exists in Graph(easy)

Solution: Find if Path Exists in Graph(easy) 

Problem 2: Number of Provinces (medium)

Solution: Number of Provinces (medium) 

Problem 3: Minimum Number of Vertices to Reach All Nodes(medium)

Solution: Minimum Number of Vertices to Reach All Nodes(medium)

Graph

Introduction to Trie

Implement Trie (Prefix Tree) (medium)

Solution: Implement Trie (Prefix Tree)

Index Pairs of a String (easy)

Solution: Index Pairs of a String

Extra Characters in a String (medium)

Solution: Extra Characters in a String

Search Suggestions System (medium)

Solution: Search Suggestions System

Design Add and Search Words Data Structure (medium)

Solution: Design Add and Search Words Data Structure

Trie (aka Prefix Tree)

Introduction to Greedy Algorithm

Valid Palindrome II (easy)

Solution: Valid Palindrome II

Maximum Length of Pair Chain (medium)

Solution: Maximum Length of Pair Chain

Minimum Add to Make Parentheses Valid (medium)

Solution: Minimum Add to Make Parentheses Valid

Remove Duplicate Letters (medium)

Solution: Remove Duplicate Letters

Largest Palindromic Number (Medium)

Solution: Largest Palindromic Number

Removing Minimum and Maximum From Array  (medium)

Solution:  Removing Minimum and Maximum From Array

Greedy Algorithm

Introduction to Divide and Conquer Algorithm

Majority Element (easy)

Solution: Majority Element

Longest Nice Substring (easy)

Solution: Longest Nice Substring

Sort List (medium)

Solution: Sort List

Beautiful Array (medium)

Solution: Beautiful Array

Median of Two Sorted Arrays (medium)

Solution: Median of Two Sorted Arrays

Divide and Conquer Algorithm

Grokking Data Structures & Algorithms for Coding Interviews

In simple terms, a HashSet is a collection or a group of unique elements. Think of it as a party where everyone has a different name; no two people can have the same name. In coding terms, this means HashSets do not allow duplicate values. 

## The Difference at a Glance: HashTable vs. HashSet
HashTable is like a dictionary, full of word (key) and definition (value) pairs. In contrast, HashSet is more like a unique-word collector, not bothered about definitions, just the words.


## Core Characteristics of HashSets
   
- **Uniqueness**: 
The first thing to remember about HashSets is that every element is unique. It’s like having a basket of fruits, and no two fruits in it are the same. This uniqueness is the superpower of HashSets!

- **Null Elements**: 
A HashSet can include a null element. It’s like having an empty slot in your fruit basket, and that’s perfectly okay!

- **Order**: 
When it comes to order, HashSets like to keep it casual. They do not guarantee any specific order of the elements. It’s like reaching into your fruit basket blindfolded – you never know which fruit you’ll grab first!

## Internal Working of a HashSet
   
- **Handling Duplicates**: 
So, what happens when HashSets encounter a duplicate? They simply ignore it! If you try to add a fruit that’s already in your basket, HashSet will just keep the original and discard the duplicate.

- **Hashing Function**: 
HashSets, like HashTables, use a hashing function to decide where each element should go. It’s like assigning a specific spot in your basket for each fruit based on its name.

- **Resizing the Set**: 
What happens when your basket gets full? When a HashSet starts running out of room, they increase the basket size to make space for more unique elements.


In the next section, we will solve some problems related to HashSets.