Table of Contents

1. Introduction
2. Algorithm Analysis
○ Big O Notation
○ Time and Space Complexity
○ Amortized Analysis
3. Data Structures
○ Arrays
○ Linked Lists
○ Stacks and Queues
○ Trees
○ Graphs
○ Hash Tables
○ Heaps (Priority Queues)
○ Tries (Prefix Trees)
○ Union-Find (Disjoint Set)
○ Bloom Filters
4. Algorithms
○ Sorting Algorithms
○ Searching Algorithms
○ Recursion and Backtracking
○ Dynamic Programming
○ Greedy Algorithms
○ Divide and Conquer
○ Graph Algorithms
■ Traversal (DFS, BFS)
■ Shortest Path (Dijkstra's, Bellman-Ford)
■ Minimum Spanning Tree (Kruskal's, Prim's)
■ Topological Sorting
○ String Algorithms
■ Pattern Matching (KMP, Rabin-Karp)
■ Suffix Trees and Arrays
5. Advanced Topics
○ Complexity Classes (P, NP, NP-Complete)
○ Parallel Algorithms
○ Cache and Memory Optimization
6. Common Problem-Solving Patterns
7. Coding Interview Strategies
8. Practice Problems with Solutions
9. Additional Resources
1. Introduction
Data Structures and Algorithms are essential for efficient problem-solving in computer science.
A strong grasp of these concepts allows you to write optimized code and demonstrates your
ability to think critically during technical interviews.

2. Algorithm Analysis
Big O Notation

Definition:

● Big O Notation describes the upper bound of an algorithm's running time or space
requirements in terms of input size (n).
● It provides a way to compare the efficiency of different algorithms.

Common Time Complexities:

● O(1): Constant time

● O(log n): Logarithmic time
● O(n): Linear time
● O(n log n): Linearithmic time
● O(n²): Quadratic time
● O(n³): Cubic time
● O(2ⁿ): Exponential time
● O(n!): Factorial time

Rules:

● Drop Constants: O(2n) → O(n)

● Drop Lower Order Terms: O(n + log n) → O(n)

Example:

// O(n)
void printAllElements(int[] array) {
for (int element : array) {
System.out.println(element);
}
}
Time and Space Complexity

● Time Complexity: Amount of time an algorithm takes to complete as a function of the

input size.
● Space Complexity: Amount of memory space required by an algorithm as a function of
the input size.

Why Important:

● Helps in choosing the most efficient algorithm for a problem.

● Essential for optimizing performance, especially for large inputs.

Amortized Analysis

● Definition: Average time per operation over a worst-case sequence of operations.

● Use Case: Data structures like dynamic arrays and splay trees where occasional
expensive operations occur.

Example:

● In a dynamic array (ArrayList in Java), resizing happens occasionally. Over many

insertions, the average time per insertion remains O(1).

3. Data Structures
Arrays

Definition:

● A collection of elements stored at contiguous memory locations.

● Elements are accessible via indices.

Characteristics:

● Fixed Size: In static arrays.

● Random Access: O(1) time complexity for accessing elements.

Operations:

● Access: O(1)
● Search:
○ Linear Search: O(n)
○ Binary Search (sorted array): O(log n)
 ● Insertion/Deletion:
○ At end: O(1)
○ At beginning or middle: O(n)

Dynamic Arrays:

● ArrayList in Java: Resizable array implementation.

● Capacity vs. Size:
○ Capacity: Total number of elements the array can hold.
○ Size: Number of elements currently in the array.

Example in Java:

int[] numbers = new int[5]; // Static array

numbers[0] = 10;

ArrayList<Integer> dynamicNumbers = new ArrayList<>(); // Dynamic

array
dynamicNumbers.add(10);

Interview Tips:

● Be familiar with array manipulation techniques.

● Understand how dynamic arrays resize and the impact on performance.

Linked Lists

Definition:

● A linear data structure where each element (node) contains data and a reference (link) to
the next node.

Types:

1. Singly Linked List: Nodes have a reference to the next node.

2. Doubly Linked List: Nodes have references to both the next and previous nodes.
3. Circular Linked List: The last node points to the first node.

Operations Complexity:
 ● Access by Index: O(n)
● Search: O(n)
● Insertion/Deletion:
○ At head: O(1)
○ At tail: O(1) if tail reference is maintained; otherwise O(n)
○ At middle: O(n)

Singly Linked List Node Class:

java
Copy code
class ListNode {
int data;
ListNode next;
ListNode(int data) {
this.data = data;
this.next = null;
}
}

Common Operations:

Reversing a Linked List

ListNode reverse(ListNode head) {

ListNode prev = null;
ListNode current = head;
while (current != null) {
ListNode nextNode = current.next;
current.next = prev;
prev = current;
current = nextNode;
}
return prev;
}

1.
Detecting a Cycle (Floyd's Tortoise and Hare Algorithm)

boolean hasCycle(ListNode head) {

ListNode slow = head;
ListNode fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
if (slow == fast) {
return true;
}
}
return false;
}

2.

Interview Tips:

● Be comfortable with pointer manipulation.

● Understand edge cases (e.g., empty list, single node).
● Practice problems involving linked lists (e.g., merge two sorted lists, remove nth node
from end).

Stacks and Queues

Stacks

● Definition: LIFO (Last-In, First-Out) data structure.

● Main Operations:
○ Push: Add an element to the top.
○ Pop: Remove and return the top element.
○ Peek/Top: View the top element without removing it.
● Time Complexity:
○ Push/Pop/Peek: O(1)

Implementation in Java:
Stack<Integer> stack = new Stack<>();
stack.push(10);
int topElement = stack.pop();

Use Cases:

● Expression evaluation and syntax parsing.

● Backtracking algorithms (e.g., maze solving).
● Function call management in recursion.

Queues

● Definition: FIFO (First-In, First-Out) data structure.

● Main Operations:
○ Enqueue: Add an element to the end.
○ Dequeue: Remove and return the front element.
○ Peek/Front: View the front element without removing it.
● Time Complexity:
○ Enqueue/Dequeue/Peek: O(1)

Implementation in Java:

Queue<Integer> queue = new LinkedList<>();

queue.add(10); // Enqueue
int frontElement = queue.remove(); // Dequeue

Use Cases:

● Order processing systems.

● Breadth-First Search (BFS) in graphs.
● Handling requests in servers.

Interview Tips:

● Implement a stack using queues and vice versa.

● Understand deque (double-ended queue) and its operations.

Trees
Binary Trees

● Definition: A tree data structure where each node has at most two children, referred to
as the left child and the right child.

Traversal Methods:

In-order Traversal (Left, Root, Right): Used to retrieve data from BST in sorted order.

void inOrder(TreeNode node) {

if (node == null) return;
inOrder(node.left);
System.out.print(node.data + " ");
inOrder(node.right);
}

1.

Pre-order Traversal (Root, Left, Right): Used to create a copy of the tree.

void preOrder(TreeNode node) {

if (node == null) return;
System.out.print(node.data + " ");
preOrder(node.left);
preOrder(node.right);
}

2.

Post-order Traversal (Left, Right, Root): Used to delete the tree.

void postOrder(TreeNode node) {

if (node == null) return;
postOrder(node.left);
postOrder(node.right);
System.out.print(node.data + " ");
}

3.
Level-order Traversal (Breadth-First): Uses a queue to traverse nodes level by level.
java
Copy code
void levelOrder(TreeNode root) {
if (root == null) return;
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
TreeNode node = queue.remove();
System.out.print(node.data + " ");
if (node.left != null) queue.add(node.left);
if (node.right != null) queue.add(node.right);
}
}

4.

Binary Tree Node Class:

class TreeNode {
int data;
TreeNode left, right;
TreeNode(int data) {
this.data = data;
left = right = null;
}
}

Binary Search Trees (BSTs)

● Definition: A binary tree where for each node:

○ All nodes in the left subtree have values less than the node's value.
○ All nodes in the right subtree have values greater than the node's value.
Operations:

● Search: O(log n) average, O(n) worst-case (unbalanced tree)

● Insert: O(log n) average, O(n) worst-case
● Delete: O(log n) average, O(n) worst-case

Search Operation:

TreeNode search(TreeNode root, int key) {

if (root == null || root.data == key) return root;
if (key < root.data)
return search(root.left, key);
else
return search(root.right, key);
}

Insert Operation:

java
Copy code
TreeNode insert(TreeNode root, int key) {
if (root == null) return new TreeNode(key);
if (key < root.data)
root.left = insert(root.left, key);
else if (key > root.data)
root.right = insert(root.right, key);
return root;
}

Interview Tips:

● Understand self-balancing trees (AVL, Red-Black Trees).

● Be prepared to discuss tree balancing and its importance.
● Practice implementing BST operations.
Heaps (Priority Queues)

Definition:

● A specialized tree-based data structure satisfying the heap property:

○ Max Heap: Parent node is greater than or equal to its children.
○ Min Heap: Parent node is less than or equal to its children.
● Implemented using arrays for efficiency.

Operations Complexity:

● Insert: O(log n)
● Extract Max/Min: O(log n)
● Find Max/Min: O(1)

Heapify Operation:

void maxHeapify(int[] heap, int size, int i) {

int largest = i;
int left = 2 * i + 1; // Left child index
int right = 2 * i + 2; // Right child index

if (left < size && heap[left] > heap[largest])

largest = left;

if (right < size && heap[right] > heap[largest])

largest = right;

if (largest != i) {
int temp = heap[i];
heap[i] = heap[largest];
heap[largest] = temp;
maxHeapify(heap, size, largest);
}
}

Use Cases:

● Implementing priority queues.

● Efficiently finding the k largest (or smallest) elements.
● Heap Sort algorithm.
Interview Tips:

● Understand the array representation of heaps.

● Be able to implement both min-heap and max-heap.
● Practice problems involving heaps (e.g., merge k sorted lists).

Hash Tables

Definition:

● Data structure that maps keys to values using a hash function to compute an index into
an array of buckets or slots.

Characteristics:

● Average Time Complexity:

○ Insert/Search/Delete: O(1)
● Collision Handling Techniques:
○ Chaining: Each bucket contains a linked list of entries.
○ Open Addressing: Probing for empty slots (linear probing, quadratic probing,
double hashing).

Hash Function:

● Converts a key into an index.

● Should minimize collisions and distribute keys uniformly.

Example in Java:

Map<String, Integer> hashMap = new HashMap<>();

hashMap.put("apple", 2);
int value = hashMap.get("apple"); // Returns 2

Interview Tips:

● Understand hash functions and their importance.

● Be familiar with collision resolution strategies.
● Practice designing a hash table from scratch.

Graphs
Definition:

● A collection of nodes (vertices) and edges connecting some pairs of nodes.

Types:

● Directed Graph (Digraph): Edges have a direction.

● Undirected Graph: Edges have no direction.
● Weighted Graph: Edges have weights or costs.

Representations:

1. Adjacency Matrix:
○ 2D array of size VxV (V: number of vertices).
○ Space Complexity: O(V²)
○ Efficient for dense graphs.
2. Adjacency List:
○ An array of lists.
○ Space Complexity: O(V + E) (E: number of edges)
○ Efficient for sparse graphs.

Graph Traversal Algorithms:

1. Depth-First Search (DFS):

○ Uses a stack (can be implemented recursively).
○ Explores as far as possible along each branch before backtracking.

void DFS(int v, boolean[] visited, List<Integer>[] adjList) {

visited[v] = true;
System.out.print(v + " ");
for (int u : adjList[v]) {
if (!visited[u]) {
DFS(u, visited, adjList);
}
}
}

2. Breadth-First Search (BFS):

○ Uses a queue.
 ○ Explores all neighbors of a vertex before moving to the next level.

void BFS(int s, int V, List<Integer>[] adjList) {

boolean[] visited = new boolean[V];
Queue<Integer> queue = new LinkedList<>();
visited[s] = true;
queue.add(s);
while (!queue.isEmpty()) {
int v = queue.poll();
System.out.print(v + " ");
for (int u : adjList[v]) {
if (!visited[u]) {
visited[u] = true;
queue.add(u);
}
}
}
}

3.

Applications:

● DFS: Topological sorting, detecting cycles.

● BFS: Shortest path in unweighted graphs, level-order traversal.

Interview Tips:

● Understand the differences between DFS and BFS.

● Be able to implement both traversal algorithms.
● Familiarize yourself with common graph problems (e.g., connected components, cycle
detection).
Tries (Prefix Trees)

Definition:

● A tree-like data structure used to store associative data structures, typically strings.

Characteristics:

● Each node represents a character.

● Paths from the root to leaves represent words.
● Time Complexity:
○ Insert/Search: O(m), where m is the length of the key.

Trie Node Class:

class TrieNode {
TrieNode[] children = new TrieNode[26]; // For lowercase English
letters
boolean isEndOfWord;
TrieNode() {
isEndOfWord = false;
}
}

Operations:

Insertion:

void insert(String key) {

TrieNode node = root;
for (char ch : key.toCharArray()) {
int index = ch - 'a';
if (node.children[index] == null)
node.children[index] = new TrieNode();
node = node.children[index];
}
node.isEndOfWord = true;
}
 1.

Search:

boolean search(String key) {

TrieNode node = root;
for (char ch : key.toCharArray()) {
int index = ch - 'a';
if (node.children[index] == null)
return false;
node = node.children[index];
}
return node.isEndOfWord;
}

2.

Applications:

● Auto-completion features.
● Spell checkers.
● IP routing.

Interview Tips:

● Be able to implement insertion and search operations.

● Understand space optimization techniques (e.g., using hash maps or compressing
nodes).

Union-Find (Disjoint Set)

Definition:

● A data structure that keeps track of elements partitioned into disjoint subsets.
● Supports two operations:
○ Find: Determine which subset an element is in.
○ Union: Merge two subsets into a single subset.
Implementation:

● Parent Array: Each element points to its parent.

● Union by Rank: Attach the smaller tree to the root of the larger tree.
● Path Compression: Flatten the structure of the tree whenever Find is used.

Example:

class UnionFind {
int[] parent;
int[] rank;
UnionFind(int size) {
parent = new int[size];
rank = new int[size];
for (int i = 0; i < size; i++)
parent[i] = i;
}

int find(int x) {
if (parent[x] != x)
parent[x] = find(parent[x]); // Path compression
return parent[x];
}

void union(int x, int y) {

int xRoot = find(x);
int yRoot = find(y);
if (xRoot == yRoot) return;
if (rank[xRoot] < rank[yRoot])
parent[xRoot] = yRoot;
else if (rank[yRoot] < rank[xRoot])
parent[yRoot] = xRoot;
else {
parent[yRoot] = xRoot;
rank[xRoot]++;
}
}
}
Applications:

● Kruskal's algorithm for Minimum Spanning Tree.

● Network connectivity.
● Cycle detection in undirected graphs.

Interview Tips:

● Understand the optimization techniques.

● Practice implementing Union-Find with path compression and union by rank.

4. Algorithms
Sorting Algorithms

Bubble Sort

● Concept: Repeatedly swap adjacent elements if they are in the wrong order.
● Time Complexity: O(n²)
● Space Complexity: O(1)
● Stability: Stable

Implementation:

void bubbleSort(int[] arr) {

int n = arr.length;
boolean swapped;
for (int i = 0; i < n - 1; i++) {
swapped = false;
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// Swap arr[j] and arr[j+1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = true;
}
}
if (!swapped) break; // Optimization
}
}

When to Use: Simple to implement, but inefficient for large datasets.

Selection Sort

● Concept: Repeatedly select the minimum element from the unsorted portion and move it
to the sorted portion.
● Time Complexity: O(n²)
● Space Complexity: O(1)
● Stability: Not stable (can be made stable with modifications)

Implementation:

void selectionSort(int[] arr) {

int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int minIdx = i;
for (int j = i + 1; j < n; j++)
if (arr[j] < arr[minIdx])
minIdx = j;
// Swap arr[minIdx] and arr[i]
int temp = arr[minIdx];
arr[minIdx] = arr[i];
arr[i] = temp;
}
}

Insertion Sort

● Concept: Build the sorted array one element at a time by comparing and inserting
elements into their correct position.
● Time Complexity: O(n²)
● Space Complexity: O(1)
● Stability: Stable
Implementation:

void insertionSort(int[] arr) {

int n = arr.length;
for (int i = 1; i < n; ++i) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}

When to Use: Efficient for small datasets or nearly sorted data.

Merge Sort

● Concept: Divide the array into halves, recursively sort each half, and merge the sorted
halves.
● Time Complexity: O(n log n)
● Space Complexity: O(n)
● Stability: Stable

Implementation:

void mergeSort(int[] arr, int l, int r) {

if (l < r) {
int m = (l + r) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
void merge(int[] arr, int l, int m, int r) {
// Sizes of two subarrays
int n1 = m - l + 1;
int n2 = r - m;

// Temporary arrays
int[] L = new int[n1];
int[] R = new int[n2];

// Copy data to temp arrays

System.arraycopy(arr, l, L, 0, n1);
System.arraycopy(arr, m + 1, R, 0, n2);

// Merge temp arrays

int i = 0, j = 0, k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k++] = L[i++];
} else {
arr[k++] = R[j++];
}
}
// Copy remaining elements
while (i < n1) arr[k++] = L[i++];
while (j < n2) arr[k++] = R[j++];
}

When to Use: Preferred for large datasets where stability is required.

Quick Sort

● Concept: Pick a pivot element, partition the array around the pivot, and recursively sort
partitions.
● Time Complexity:
○ Average Case: O(n log n)
○ Worst Case: O(n²) (when the smallest or largest element is always chosen as
pivot)
● Space Complexity: O(log n) (due to recursive calls)
 ● Stability: Not stable

Implementation:

void quickSort(int[] arr, int low, int high) {

if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

int partition(int[] arr, int low, int high) {

int pivot = arr[high]; // Pivot
int i = (low - 1); // Index of smaller element
for (int j = low; j < high; j++) {
if (arr[j] <= pivot) {
i++;
// Swap arr[i] and arr[j]
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// Swap arr[i+1] and arr[high] (pivot)
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1;
}

When to Use: Efficient for large datasets; however, care must be taken to avoid worst-case
scenarios.
Heap Sort

● Concept: Build a heap from the data, then repeatedly extract the maximum element
from the heap and reconstruct the heap.
● Time Complexity: O(n log n)
● Space Complexity: O(1)
● Stability: Not stable

Implementation:

void heapSort(int[] arr) {

int n = arr.length;
// Build heap
for (int i = n / 2 - 1; i >= 0; i--)
maxHeapify(arr, n, i);
// Extract elements
for (int i = n - 1; i >= 0; i--) {
// Move current root to end
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// Heapify reduced heap
maxHeapify(arr, i, 0);
}
}

void maxHeapify(int[] arr, int n, int i) {

int largest = i;
int l = 2 * i + 1; // left child
int r = 2 * i + 2; // right child

if (l < n && arr[l] > arr[largest])

largest = l;
if (r < n && arr[r] > arr[largest])
largest = r;

if (largest != i) {
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;
 maxHeapify(arr, n, largest);
}
}

When to Use: When constant space is a requirement.

Counting Sort

● Concept: Counts the number of occurrences of each unique element.

● Time Complexity: O(n + k), where k is the range of input.
● Space Complexity: O(k)
● Stability: Stable

Limitations:

● Only works for integers within a specific range.

● Not efficient if the range of input data (k) is significantly greater than the number of
objects to be sorted (n).

Radix Sort

● Concept: Processes each digit of the numbers, starting from the least significant digit to
the most significant digit.
● Time Complexity: O(d*(n + k)), where d is the number of digits.
● Space Complexity: O(n + k)
● Stability: Stable

When to Use: Efficient for sorting numbers with fixed digit length.

Searching Algorithms

Linear Search

● Concept: Sequentially checks each element until a match is found or the list is
exhausted.
● Time Complexity: O(n)
Implementation:

int linearSearch(int[] arr, int key) {

for (int i = 0; i < arr.length; i++) {
if (arr[i] == key)
return i;
}
return -1; // Not found
}

Binary Search

● Concept: Repeatedly divides the sorted array in half to locate the target value.
● Time Complexity: O(log n)
● Prerequisite: The array must be sorted.

Iterative Implementation:

int binarySearch(int[] arr, int key) {

int low = 0, high = arr.length - 1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (arr[mid] == key)
return mid;
else if (arr[mid] < key)
low = mid + 1;
else
high = mid - 1;
}
return -1; // Not found
}
Recursive Implementation:

int binarySearchRecursive(int[] arr, int low, int high, int key) {

if (low > high)
return -1; // Not found
int mid = low + (high - low) / 2;
if (arr[mid] == key)
return mid;
else if (arr[mid] < key)
return binarySearchRecursive(arr, mid + 1, high, key);
else
return binarySearchRecursive(arr, low, mid - 1, key);
}

Interview Tips:

● Be cautious with integer overflow when calculating mid.

● Understand variants like finding the first or last occurrence, or insertion point.

Recursion and Backtracking

Recursion

● Definition: A method where the solution to a problem depends on solutions to smaller

instances of the same problem.

Key Components:

● Base Case: Condition under which the recursion ends.

● Recursive Case: The function calls itself with a smaller problem.

Example: Factorial Function

int factorial(int n) {
if (n == 0) return 1; // Base case
return n * factorial(n - 1); // Recursive case
}
Tail Recursion:

● A recursive function where the recursive call is the last operation.

● Some languages optimize tail calls to prevent stack overflow (Java does not).

Backtracking

● Definition: An algorithmic technique for solving problems recursively by trying to build a

solution incrementally, removing solutions that fail to satisfy the constraints at any point.

Applications:

● Solving puzzles (e.g., Sudoku).

● Generating permutations and combinations.
● N-Queens problem.

Example: N-Queens Problem

void solveNQueens(int n) {
int[] board = new int[n];
placeQueen(board, 0, n);
}

boolean placeQueen(int[] board, int row, int n) {

if (row == n) {
// All queens placed successfully
printBoard(board);
return true;
}
boolean success = false;
for (int col = 0; col < n; col++) {
if (isSafe(board, row, col)) {
board[row] = col;
success = placeQueen(board, row + 1, n) || success;
}
}
return success;
}

boolean isSafe(int[] board, int row, int col) {

for (int i = 0; i < row; i++) {
if (board[i] == col || Math.abs(board[i] - col) == row - i)
 return false;
}
return true;
}

Interview Tips:

● Understand how to prune the search space to improve efficiency.

● Be able to explain the recursion tree and backtracking process.

Dynamic Programming (DP)

Definition:

● A method for solving complex problems by breaking them down into simpler
subproblems.
● It is applicable when the problem has overlapping subproblems and optimal
substructure.

Approaches:

Memoization (Top-Down): Store the results of expensive function calls and return the cached
result when the same inputs occur again.

int fib(int n, Map<Integer, Integer> memo) {

if (n <= 1) return n;
if (memo.containsKey(n)) return memo.get(n);
int result = fib(n - 1, memo) + fib(n - 2, memo);
memo.put(n, result);
return result;
}
 1.

Tabulation (Bottom-Up): Build up a table in a bottom-up manner and use it to solve the
problem.
java
Copy code
int fib(int n) {
if (n <= 1) return n;
int[] dp = new int[n + 1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}

2.

Common DP Problems:

● Knapsack Problem
● Longest Common Subsequence (LCS)
● Coin Change Problem
● Edit Distance

Interview Tips:

● Recognize patterns indicating overlapping subproblems.

● Start with a recursive solution, then optimize with DP.
● Be able to define the state and formulate the recurrence relation.

Greedy Algorithms

Definition:

● An algorithmic paradigm that builds up a solution piece by piece, always choosing the
next piece that offers the most immediate benefit.
Characteristics:

● Locally Optimal Choice: The choice that seems the best at the moment.
● Global Optimal Solution: Not always guaranteed, but works for problems with the
greedy-choice property.

Common Greedy Algorithms:

● Huffman Coding: For optimal prefix codes in data compression.

● Dijkstra's Algorithm: Shortest path in a graph with non-negative edge weights.
● Prim's and Kruskal's Algorithms: Finding Minimum Spanning Tree.

Interview Tips:

● Understand when a greedy algorithm produces an optimal solution.

● Be prepared to prove or justify the correctness.

Divide and Conquer

Definition:

● An algorithm design paradigm based on multi-branched recursion.

● Steps:
○ Divide: Break the problem into smaller subproblems.
○ Conquer: Solve the subproblems recursively.
○ Combine: Merge the solutions of the subproblems.

Applications:

● Merge Sort
● Quick Sort
● Binary Search
● Karatsuba Algorithm for Multiplication

Interview Tips:

● Identify whether a problem can be broken into independent subproblems.

● Be able to write recursive solutions and understand base cases.
Graph Algorithms

Shortest Path Algorithms

1. Dijkstra's Algorithm:
○ Purpose: Find the shortest path from a single source to all other vertices in a
graph with non-negative edge weights.
○ Time Complexity: O((V + E) log V) using a min-priority queue.
2. Bellman-Ford Algorithm:
○ Purpose: Handles graphs with negative edge weights (but no negative cycles).
○ Time Complexity: O(V * E)
3. Floyd-Warshall Algorithm:
○ Purpose: Find shortest paths between all pairs of vertices.
○ Time Complexity: O(V³)

Interview Tips:

● Understand the differences and when to use each algorithm.

● Be familiar with detecting negative cycles using Bellman-Ford.

Minimum Spanning Tree (MST)

1. Prim's Algorithm:
○ Approach: Builds the MST by adding the cheapest edge from the tree to a
vertex not yet in the tree.
○ Time Complexity: O(E log V)
2. Kruskal's Algorithm:
○ Approach: Builds the MST by adding the smallest edges while avoiding cycles.
○ Time Complexity: O(E log E)

Interview Tips:

● Be able to implement both algorithms.

● Understand Union-Find data structure for Kruskal's algorithm.

Topological Sorting

● Definition: Linear ordering of vertices in a Directed Acyclic Graph (DAG) such that for
every directed edge UV, vertex U comes before V.
● Algorithms:
○ DFS-based method.
○ Kahn's algorithm (uses BFS).
Interview Tips:

● Understand cycle detection in graphs.

● Be able to implement topological sort.

String Algorithms

Pattern Matching

1. Naïve Approach:
○ Check for the pattern at every possible position in the text.
○ Time Complexity: O(n * m)
2. Knuth-Morris-Pratt (KMP) Algorithm:
○ Purpose: Efficiently search for a pattern in a text.
○ Time Complexity: O(n + m)
○ Concept: Preprocess the pattern to create a longest proper prefix which is also
suffix (LPS) array.

LPS Array Construction:

void computeLPSArray(String pat, int M, int[] lps) {

int length = 0;
lps[0] = 0; // lps[0] is always 0
int i = 1;
while (i < M) {
if (pat.charAt(i) == pat.charAt(length)) {
length++;
lps[i] = length;
i++;
} else {
if (length != 0) {
length = lps[length - 1];
} else {
lps[i] = 0;
i++;
}
}
}
}
 3. Rabin-Karp Algorithm:
○ Purpose: Use hashing to find any one of a set of pattern strings in a text.
○ Time Complexity:
■ Average: O(n + m)
■ Worst: O(nm)

Suffix Trees and Arrays

● Suffix Tree:
○ A compressed trie of all the suffixes of a given string.
○ Applications:
■ Pattern matching.
■ Longest common substring.
● Suffix Array:
○ An array of starting indices of suffixes of a string sorted lexicographically.
○ Advantages over Suffix Trees:
■ Requires less memory.
■ Easier to implement.

5. Advanced Topics
Complexity Classes

● P: Problems solvable in polynomial time.

● NP: Problems verifiable in polynomial time.
● NP-Complete: Problems to which every NP problem can be reduced in polynomial time.
● NP-Hard: At least as hard as the hardest problems in NP; not necessarily in NP.

Interview Tips:

● Understand the significance of P vs. NP.

● Be familiar with classic NP-Complete problems (e.g., Traveling Salesman, Knapsack).

Parallel Algorithms

● Algorithms designed to take advantage of multi-core processors.

● Concepts like MapReduce for processing large data sets.
Cache and Memory Optimization

● Understanding of how algorithms interact with CPU cache.

● Techniques like loop unrolling and blocking.

6. Common Problem-Solving Patterns

● Two Pointers Technique
● Sliding Window Technique
● Fast and Slow Pointers
● Merge Intervals
● Top K Elements
● Tree BFS/DFS
● Union Find for Disjoint Sets

Interview Tips:

● Recognize patterns in problems.

● Practice problems involving these patterns.

7. Coding Interview Strategies

● Clarify the Problem: Ask questions to ensure understanding.
● Plan the Approach: Think aloud and discuss potential solutions.
● Write Clean Code: Use proper naming conventions and structure.
● Test Cases: Consider edge cases and test your code.
● Optimize: Discuss time and space complexities.
● Communicate: Explain your thought process.

8. Practice Problems with Solutions

1. Arrays and Strings
○ Problem: Reverse words in a string.
○ Solution: Split the string, reverse the array of words, join back.
2. Linked Lists
○ Problem: Add two numbers represented by linked lists.
○ Solution: Use recursion or stack to handle different lengths.
 3. Trees
○ Problem: Check if a binary tree is balanced.
○ Solution: Recursively check height and balance factor.
4. Graphs
○ Problem: Find if a path exists between two nodes.
○ Solution: Use BFS or DFS.
5. Dynamic Programming
○ Problem: Longest Palindromic Substring.
○ Solution: Use DP table to store palindromic states.
6. Sorting and Searching
○ Problem: Find kth largest element.
○ Solution: Use QuickSelect algorithm.

9. Additional Resources
● Books:
○ "Introduction to Algorithms" by Cormen et al.
○ "Algorithms" by Robert Sedgewick and Kevin Wayne
● Online Platforms:
○ LeetCode: Extensive problem sets for practice.
○ HackerRank: Practice coding and compete.
○ GeeksforGeeks: Tutorials and practice problems.
● Tutorials:
○ Coursera: Algorithms courses by top universities.
○ MIT OpenCourseWare: Free lecture notes and videos.

Final Advice:

● Practice Regularly: Consistency improves problem-solving skills.

● Understand Fundamentals: Deep understanding trumps memorization.
● Simulate Interviews: Mock interviews help reduce anxiety.
● Learn from Mistakes: Review incorrect solutions to improve.