Forem: Quipoin

Two Pointer Technique in Java: The Trick That Replaces Nested Loops

Quipoin — Fri, 01 May 2026 09:04:04 +0000

Many array problems look like they need nested loops.

That means O(n²) time.

But with one simple idea — Two Pointers —
you can often reduce it to O(n).

What is Two Pointer Technique?

Instead of using one loop,
you use two indices (pointers):

From opposite ends
Or moving in the same direction

Helps reduce unnecessary work

Example 1: Two Sum (Sorted Array)

public static int[] twoSumSorted(int[] arr, int target) {
int left = 0, right = arr.length - 1;

while (left < right) {
    int sum = arr[left] + arr[right];

    if (sum == target) return new int[]{left, right};
    else if (sum < target) left++;
    else right--;
}

return new int[]{-1, -1};

}

Idea:

If sum is small → move left
If sum is large → move right

Example 2: Remove Duplicates

public static int removeDuplicates(int[] arr) {
if (arr.length == 0) return 0;

int writeIndex = 1;

for (int readIndex = 1; readIndex < arr.length; readIndex++) {
    if (arr[readIndex] != arr[readIndex - 1]) {
        arr[writeIndex++] = arr[readIndex];
    }
}

return writeIndex;

}
Idea:

One pointer reads
One pointer writes

Example 3: Container With Most Water

public static int maxArea(int[] height) {
int left = 0, right = height.length - 1, max = 0;

while (left < right) {
    max = Math.max(max,
        (right - left) * Math.min(height[left], height[right])
    );

    if (height[left] < height[right]) left++;
    else right--;
}

return max;

}

Idea:

Move pointer with smaller height

The Real Insight

Two pointers eliminate unnecessary comparisons

Instead of checking all pairs,
you move intelligently.

Key Insights

Works best on sorted arrays
Can be used for in-place operations
Reduces O(n²) → O(n)

For More: https://www.quipoin.com/tutorial/data-structure-with-java/two-pointer-technique

Sliding Window in Java: The Trick That Replaces Nested Loops

Quipoin — Tue, 28 Apr 2026 05:40:58 +0000

Many beginners write nested loops for subarray problems.

That leads to O(n²) time complexity.

But what if you could solve the same problem in O(n)?

That’s where Sliding Window comes in.

What is Sliding Window?

Imagine a window covering part of the array.

Instead of recalculating everything:

You remove one element
You add one element

Reuse previous computation

Fixed-Size Sliding Window

Problem:

Find maximum sum of subarray of size k

public static int maxSumFixedWindow(int[] arr, int k) {
int windowSum = 0;

for (int i = 0; i < k; i++) windowSum += arr[i];

int maxSum = windowSum;

for (int i = k; i < arr.length; i++) {
    windowSum = windowSum - arr[i - k] + arr[i];
    maxSum = Math.max(maxSum, windowSum);
}

return maxSum;

}

Complexity:

Time → O(n)
Space → O(1)

Fixed-Size Sliding Window
💡 Problem:

Find maximum sum of subarray of size k

public static int maxSumFixedWindow(int[] arr, int k) {
int windowSum = 0;

for (int i = 0; i < k; i++) windowSum += arr[i];

int maxSum = windowSum;

for (int i = k; i < arr.length; i++) {
    windowSum = windowSum - arr[i - k] + arr[i];
    maxSum = Math.max(maxSum, windowSum);
}

return maxSum;

}
⏱️ Complexity:
Time → O(n)
Space → O(1)

Variable-Size Sliding Window

Problem:

Find longest subarray with sum ≤ target

public static int longestSubarraySumAtMost(int[] arr, int target) {
int left = 0, sum = 0, maxLen = 0;

for (int right = 0; right < arr.length; right++) {
    sum += arr[right];

    while (sum > target) {
        sum -= arr[left];
        left++;
    }

    maxLen = Math.max(maxLen, right - left + 1);
}

return maxLen;

}

Complexity:

Time → O(n)

The Real Insight

👉 Sliding window avoids recomputation

Instead of:

Recalculating sum every time

You:

Adjust window dynamically

Key Insights

Fixed window → size stays constant
Variable window → expand & shrink
Removes need for nested loops

For More: https://www.quipoin.com/tutorial/data-structure-with-java/sliding-window-basics

Stop Recomputing Sums: Learn Prefix Sum Technique

Quipoin — Sun, 26 Apr 2026 11:34:52 +0000

Imagine being asked multiple times:

“What’s the sum from index L to R?”

If you loop every time, your solution becomes slow.

But what if you could answer every query in O(1)?

That’s exactly what Prefix Sum does.

What is Prefix Sum?

Prefix sum stores cumulative sums.

Each index stores sum from 0 to i

int[] arr = {3, 1, 4, 2};
int[] prefix = new int[arr.length];

prefix[0] = arr[0];
for (int i = 1; i < arr.length; i++) {
prefix[i] = prefix[i-1] + arr[i];
}

Result:

prefix = [3, 4, 8, 10]

Why Prefix Sum is Powerful

Without prefix sum:

Each query → O(n)

With prefix sum:

Preprocessing → O(n)
Each query → O(1)

Range Sum Formula

Use this:

S(L,R)=prefix[R]−prefix[L−1]

Special case:

If L = 0 → just prefix[R]

Implementation

public static int rangeSum(int[] prefix, int L, int R) {
if (L == 0) return prefix[R];
return prefix[R] - prefix[L-1];
}

The Real Insight

Do work once → reuse many times

Instead of solving each query separately,
you precompute smartly.

Applications

Range sum queries
Subarray sum problems
Equilibrium index
2D prefix sum (matrix problems)

For More: https://www.quipoin.com/tutorial/data-structure-with-java/prefix-sum-technique

Multi-Dimensional Arrays Made Simple (With Java Examples)

Quipoin — Sat, 25 Apr 2026 05:10:40 +0000

At some point, 1D arrays are not enough.

What if you need to represent:

A chess board
A game grid
A matrix

That’s where multi-dimensional arrays come in.

What is a 2D Array?

A 2D array is simply an array of arrays.

Think of it like a table:

Rows
Columns

Declaration & Initialization

// Declaration
int[][] matrix = new int[3][4];

// Initialization
int[][] grid = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

Accessing Elements

int element = grid[1][2]; // 6

First index = row
Second index = column

Traversing a 2D Array

for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}

Time Complexity: O(n × m)

Visit each row and column

Jagged Arrays

Unlike normal 2D arrays, rows can have different lengths.

int[][] jagged = new int[3][];
jagged[0] = new int[2];
jagged[1] = new int[3];
jagged[2] = new int[1];

Useful when data is not uniform

The Real Insight

2D arrays = array of arrays
Memory is not always perfectly rectangular
Jagged arrays give flexibility

Key Insights

Access → arr[row][col]
Traversal → nested loops
Jagged arrays → flexible rows
Used in grids, DP, matrices

For More: https://www.quipoin.com/tutorial/data-structure-with-java/multi-dimensional-arrays

Reverse, Rotate, Merge: The Patterns That Unlock DSA

Quipoin — Sat, 25 Apr 2026 05:02:56 +0000

Most beginners try to memorize DSA problems.

But interviews don’t test memory — they test patterns.

If you master just these 3 array problems, you’ll unlock a huge part of DSA.

1. Reverse an Array
Idea:

Swap elements from both ends until you reach the middle.

public static void reverse(int[] arr) {
int left = 0, right = arr.length - 1;
while (left < right) {
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++; right--;
}
}

Complexity:

Time → O(n)
Space → O(1)

2. Rotate Array by k Positions
Idea:

Instead of shifting one-by-one, use 3 reversals.

public static void rotate(int[] arr, int k) {
k = k % arr.length;
reverse(arr, 0, arr.length - 1);
reverse(arr, 0, k - 1);
reverse(arr, k, arr.length - 1);
}
private static void reverse(int[] arr, int start, int end) {
while (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++; end--;
}
}

Complexity:

Time → O(n)
Space → O(1)

3. Merge Two Sorted Arrays
Idea:

Use two pointers and always pick the smaller element.

public static int[] merge(int[] a, int[] b) {
int[] result = new int[a.length + b.length];
int i = 0, j = 0, k = 0;

while (i < a.length && j < b.length) {
    if (a[i] < b[j]) result[k++] = a[i++];
    else result[k++] = b[j++];
}

while (i < a.length) result[k++] = a[i++];
while (j < b.length) result[k++] = b[j++];

return result;

}

Complexity:

Time → O(n + m)
Space → O(n + m)

The Real Insight

These problems are not random.

They teach you:

Two-pointer technique
In-place modification
Efficient traversal
Pattern thinking

Key Insights

Reverse → swapping technique
Rotate → smart use of reverse
Merge → two pointers

These patterns repeat in advanced problems

For More: https://www.quipoin.com/tutorial/data-structure-with-java/array-problems

Reverse, Rotate, Merge: The Patterns That Unlock DSA

Quipoin — Fri, 24 Apr 2026 11:18:42 +0000

Most beginners try to memorize DSA problems.

But interviews don’t test memory — they test patterns.

If you master just these 3 array problems, you’ll unlock a huge part of DSA.

1. Reverse an Array
Idea:

Swap elements from both ends until you reach the middle.

public static void reverse(int[] arr) {
int left = 0, right = arr.length - 1;
while (left < right) {
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
left++; right--;
}
}

Complexity:

Time → O(n)
Space → O(1)

2. Rotate Array by k Positions
Idea:

Instead of shifting one-by-one, use 3 reversals.

Complexity:

Time → O(n)
Space → O(1)

3. Merge Two Sorted Arrays
Idea:

Use two pointers and always pick the smaller element.

public static int[] merge(int[] a, int[] b) {
int[] result = new int[a.length + b.length];
int i = 0, j = 0, k = 0;

while (i < a.length && j < b.length) {
    if (a[i] < b[j]) result[k++] = a[i++];
    else result[k++] = b[j++];
}

while (i < a.length) result[k++] = a[i++];
while (j < b.length) result[k++] = b[j++];

return result;

}

Complexity:

Time → O(n + m)
Space → O(n + m)

The Real Insight

These problems are not random.

They teach you:

Two-pointer technique
In-place modification
Efficient traversal
Pattern thinking

Key Insights

Reverse → swapping technique
Rotate → smart use of reverse
Merge → two pointers

These patterns repeat in advanced problems

For More: https://www.quipoin.com/tutorial/data-structure-with-java/array-problems

Traversal, Insertion, Deletion The Truth About Array Performance

Quipoin — Mon, 20 Apr 2026 10:41:24 +0000

Arrays look simple… but the way operations behave on them can make or break your performance.

Why is accessing an element instant, but inserting in the middle slow?

Let’s break it down in the simplest way possible.

1. Traversal (Visiting Elements)

Traversal means visiting each element one by one.

for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}

// Enhanced loop
for (int num : arr) {
System.out.println(num);
}

Time Complexity: O(n)

You must visit every element
No shortcut possible

2. Insertion
Case 1: Insert at End

If space is available → O(1)
Just place the element

Case 2: Insert at Middle

public static void insert(int[] arr, int pos, int value) {
for (int i = arr.length - 1; i > pos; i--) {
arr[i] = arr[i - 1];
}
arr[pos] = value;
}

Time Complexity: O(n)

Why slow?
Because elements need to shift right

3. Deletion

Case 1: Delete from End
Simply remove → O(1)

Case 2: Delete from Middle

public static void delete(int[] arr, int pos) {
for (int i = pos; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
}
}

Time Complexity: O(n)

Again, shifting required (left side)

The Real Insight

Arrays are fast for reading
But slow for modifying in the middle

Because of one reason:

Shifting elements = extra work = O(n)

Key Insights

Traversal → O(n)
Insert at end → O(1)
Insert in middle → O(n)
Delete from end → O(1)
Delete from middle → O(n)

For More: https://www.quipoin.com/tutorial/data-structure-with-java/array-operations

Why Arrays Are So Fast (And Why It Matters in DSA)

Quipoin — Sun, 19 Apr 2026 07:09:38 +0000

Before you jump into advanced Data Structures like stacks, queues, or hash tables, there’s one concept you must fully understand Arrays.

If arrays are unclear, everything else in DSA will feel complicated.

Let’s fix that in the simplest way possible.

What is an Array?

Think of an array like a row of lockers.

Each locker:

Has a fixed position (index)
Stores one value
Can be accessed instantly if you know the index

In Java, an array stores elements:

Of the same type
In continuous memory locations

Why Arrays Are Fast (O(1) Access)

Arrays allow direct access using index.

Example:

int[] arr = {2, 3, 5, 7};
System.out.println(arr[2]); // 5

No searching required
Direct memory access
That’s why time complexity is O(1)

Key Properties of Arrays

Fixed Size → cannot change after creation
Contiguous Memory → stored in a continuous block
Index-Based Access → starts from 0
Homogeneous → same data type

Array Declaration in Java

// Declaration
int[] numbers;

// Allocation
numbers = new int[5];

// Initialization
int[] primes = {2, 3, 5, 7};
String[] names = new String[]{"Alice", "Bob"};

Accessing Elements

int first = primes[0]; // 2
primes[2] = 11; // update value
int length = primes.length;

Key Insights

Arrays are objects in Java
They come with a .length property
Default values:

int → 0
boolean → false
object → null

For More: https://www.quipoin.com/tutorial/data-structure-with-java/array-introduction

How to Solve Complex Problems Step-by-Step (Backtracking Explained)

Quipoin — Sat, 18 Apr 2026 05:26:36 +0000

Ever faced a problem where you need to try all possible solutions… but don’t know how?

That’s where Backtracking comes in.

What is Backtracking?

Backtracking is a technique where you:

Try a solution
If it fails → go back
Try another path

It’s like solving a maze:

Take a path
Hit a dead end
Go back and try another route

Where is Backtracking Used?

N-Queens problem
Sudoku solver
Generating subsets
Permutations & combinations
Rat in a maze

General Backtracking Template

void backtrack(parameters) {
if (solution found) {
process solution;
return;
}

for (int candidate : candidates) {
    if (isValid(candidate)) {
        makeChoice(candidate);

        backtrack(updatedParameters);

        undoChoice(candidate); // backtrack
    }
}

}

Example: Generate All Subsets

void subsets(int[] nums, int index, List current, List> result) {
result.add(new ArrayList<>(current));

for (int i = index; i < nums.length; i++) {
    current.add(nums[i]);

    subsets(nums, i + 1, current, result);

    current.remove(current.size() - 1); // backtrack
}

}

Key Idea

Backtracking works in 3 steps:

Choose
Explore
Undo (Backtrack)

This ensures all possibilities are explored.

Important Note

Time complexity is often exponential
But pruning (skipping invalid paths early) improves performance

For More: https://www.quipoin.com/tutorial/data-structure-with-java/backtracking-basics

Recursion vs Iteration: Which One Should You Use?

Quipoin — Sun, 12 Apr 2026 05:23:25 +0000

Do you prefer clean code… or fast code?

In programming, many problems can be solved in two ways:

Recursion
Iteration (loops)

Both work… but they behave very differently.

So the real question is:
Which one should you use?

What is Recursion?

Recursion is when a function calls itself to solve smaller parts of a problem.

Pros:

Short and elegant code
Matches mathematical definitions
Perfect for trees, graphs, divide & conquer

Cons:

Uses extra memory (call stack)
Can be slower
Risk of stack overflow

What is Iteration?

Iteration uses loops (for, while) to repeat steps until a condition is met.

Pros:

Faster in most cases
Uses constant memory
No risk of stack overflow

Cons:

Code can be longer
Harder to write for complex problems

Example: Fibonacci
Recursive Approach (Slow)

static int fibRecursive(int n) {
if (n <= 1) return n;
return fibRecursive(n-1) + fibRecursive(n-2);
}

Time Complexity: O(2ⁿ)

Iterative Approach (Efficient)

static int fibIterative(int n) {
if (n <= 1) return n;

int prev2 = 0, prev1 = 1, current = 0;

for (int i = 2; i <= n; i++) {
    current = prev1 + prev2;
    prev2 = prev1;
    prev1 = current;
}

return current;

}

Time Complexity: O(n)

When Should You Use What?
Use Recursion when:

Problem has recursive structure
Working with trees or graphs
Using divide & conquer

Use Iteration when:

Performance matters
Input size is large
You want to avoid memory overhead

If you are learning DSA step-by-step, check more guides here:

quipoin.com

Why Recursion Confuses Most Beginners

Quipoin — Sat, 11 Apr 2026 08:08:12 +0000

Recursion is one of the most powerful…
and confusing concepts in programming 😳

Let’s break it down in the simplest way possible.

Real-Life Example

Think of a Russian doll:

You open one → another inside
Open again → another inside

Same pattern repeats

This is exactly how recursion works.

What is Recursion?

Recursion is a technique where a function calls itself to solve a smaller version of the same problem.

Two Important Parts

Base Case

Stops recursion
Prevents infinite loop

Recursive Case

Function calls itself
Reduces problem size

Example: Factorial

public static int factorial(int n) {
// base case
if (n <= 1) return 1;

// recursive case
return n * factorial(n - 1);

}

How It Works

factorial(3)
= 3 * factorial(2)
= 3 * 2 * factorial(1)
= 3 * 2 * 1
= 6

Where Recursion is Used

Trees
Graphs
Divide & Conquer
Fibonacci
Backtracking problems

For More: https://www.quipoin.com/tutorial/data-structure-with-java/recursion-introduction

Same Algorithm, Different Performance? | Best, Average, Worst Case Explained

Quipoin — Mon, 06 Apr 2026 06:29:10 +0000

You wrote an algorithm… and it works perfectly

But sometimes it runs fast…
and sometimes it becomes slow

Why does this happen?

Because algorithm performance depends on the input case

Three Types of Cases
Best Case

Fastest possible scenario
Example: target found at first index
Time: O(1)

Average Case

Typical scenario across all inputs
Expected performance
Time: O(n)

Worst Case

Slowest possible scenario
Example: element not found or at last index
Time: O(n)

Example: Linear Search

int linearSearch(int[] arr, int target) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == target) return i;
}
return -1;
}

Case Analysis

Best Case → element at index 0 → O(1)
Worst Case → element not found → O(n)
Average Case → ~n/2 comparisons → O(n)

Why Do We Focus on Worst Case?

Because it gives a guarantee:

“Algorithm will NEVER take more than this time”

This is critical for:

Large-scale systems
Real-time applications
Performance-sensitive code

For More: https://www.quipoin.com/tutorial/data-structure-with-java/best-average-worst-case