Scribd
Upload
13 views

5 Algorithm For Coding Interview

Algorithm

Uploaded by

Narendhiran “Narendhiran D” D
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
13 views

5 Algorithm For Coding Interview

Algorithm

Uploaded by

Narendhiran “Narendhiran D” D
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

1.

Top K Elements

Definition:
The "Top K Elements" problem involves finding the `k` largest or smallest elements in a
dataset. This is commonly used in scenarios where you want to quickly access the most
relevant or significant items, like the top 10 trending videos on YouTube.

Example:
Given an array `[3, 1, 5, 12, 2, 11]` and `k = 3`, the top 3 largest elements are `[12, 11, 5]`.

Explanation:
One efficient way to solve this problem is by using a Min Heap (for finding the largest
elements). You can maintain a heap of size `k` as you iterate through the array, ensuring
that only the largest `k` elements remain in the heap.

Diagram:
Imagine a Min Heap where each element is inserted. The smallest element at the root of
the heap is removed when the size exceeds `k`, ensuring that only the largest `k`
elements remain.

5
/\
12 11 (Min Heap with Top 3 Largest Elements)

2. Sliding Window

Definition:
The Sliding Window technique is used to solve problems involving a contiguous block of
elements in an array or string. It involves moving a window (of fixed size or dynamic)
across the data to process or calculate something efficiently.

Example:
Given an array `[1, 3, -1, -3, 5, 3, 6, 7]` and window size `k = 3`, find the maximum for each
sliding window position.

Explanation:
You move the window from the start to the end of the array, maintaining the maximum (or
any required computation) for the current window. This can be done using a deque to
keep track of maximums, leading to an O(n) solution.
Diagram:

Array: [1, 3, -1, -3, 5, 3, 6, 7]


Windows: [1, 3, -1] -> [3, -1, -3] -> [-1, -3, 5] -> ...
Max Values: 3 3 5 ...

3. Backtracking

Definition:
Backtracking is a recursive technique for solving problems incrementally, where you try
to build a solution piece by piece, and backtrack as soon as you realize that the current
piece cannot lead to a valid solution.

Example:
Finding all possible solutions to the N-Queens problem, where N queens are placed on
an NxN chessboard such that no two queens threaten each other.

Explanation:
Backtracking involves placing a queen in one column at a time and recursively trying to
solve the problem for the next column. If placing a queen in a particular position leads to
a conflict, you backtrack and try the next position.

Diagram:

N-Queens on 4x4 Board:


Q... ...Q
..Q. .Q..
.Q.. Q...
...Q ..Q.

(Backtrack when no valid moves are available)


4. Dynamic Programming (DP)

Definition:
Dynamic Programming is an optimization technique used to solve problems by breaking
them down into simpler subproblems, solving each subproblem once, and storing their
solutions to avoid redundant computations.

Example:
Finding the minimum number of coins needed to make a certain amount, given different
coin denominations.

Explanation:
The problem is broken down into smaller problems where you calculate the minimum
coins needed for smaller amounts and build up to the required amount using these
solutions.

Diagram:

Example for amount = 11 with coins [1, 5, 6, 8]:

DP Table:
[0, 1, 2, 3, 1, 2, 1, 2, 1, 2, 2, 3] (Each index represents the minimum coins for that amount)

Solution:
11 -> 6 + 5 -> Coin 6, Coin 5

5. Breadth-First Search (BFS)

Definition:
BFS is a graph traversal algorithm that explores all nodes at the present depth level
before moving on to nodes at the next depth level. It uses a queue to keep track of the
nodes to be explored.

Example:
Traversing a tree level by level or finding the shortest path in an unweighted graph.

Explanation:
Starting from the root node, you explore all its neighbors before moving to their
neighbors, ensuring that you visit nodes in a breadth-first manner.
Diagram:

Graph:
1
/\
2 3
/| |\
45 67

BFS Traversal:
1 -> 2, 3 -> 4, 5, 6, 7 (Level by level)

6. Depth-First Search (DFS)

Definition:
DFS is a graph traversal algorithm that explores as far as possible along a branch before
backtracking. It uses a stack (either explicitly or via recursion) to keep track of the path.

Example:
Traversing a tree or graph in depth-first order, or solving maze problems.

Explanation:
Starting from the root node, DFS explores each branch to its deepest point before
backtracking to explore the next branch. It can be implemented either iteratively using a
stack or recursively.

Diagram:

Graph:
1
/\
2 3
/| |\
45 67

DFS Traversal:
1 -> 2 -> 4 -> Backtrack -> 5 -> Backtrack -> 3 -> 6 -> Backtrack -> 7

You might also like