DEV Community: Quipoin

Why Linked Lists Are Different from Arrays

Quipoin — Sun, 24 May 2026 04:08:00 +0000

Arrays are great for fast access…

But inserting or deleting elements can be expensive.

That’s where Linked Lists become powerful.

A Singly Linked List connects nodes like a chain:

each node points only to the next node.

1. Structure of a Singly Linked List

Visual representation:

[10] → [20] → [30] → null

Each node contains:

data
reference to next node

2. Insert at Head
Idea

New node becomes the first node.

public void insertAtHead(int data) {

Node newNode = new Node(data);

newNode.next = head;

head = newNode;

}

Complexity

O(1) insertion at head

Because:

no traversal needed

3. Insert at End
Idea

Traverse until last node.

public void insertAtEnd(int data) {

Node newNode = new Node(data);

if (head == null) {
    head = newNode;
    return;
}

Node temp = head;

while (temp.next != null) {
    temp = temp.next;
}

temp.next = newNode;

}

Complexity

O(n) insertion at end

Because:

traversal is required.

4. Delete a Node
Idea

Find previous node,
then bypass target node.

public void delete(int key) {

if (head == null)
    return;

if (head.data == key) {
    head = head.next;
    return;
}

Node temp = head;

while (temp.next != null &&
       temp.next.data != key) {

    temp = temp.next;
}

if (temp.next != null) {
    temp.next = temp.next.next;
}

}
5. Traversal
Idea

Move node by node until null.

public void printList() {

Node temp = head;

while (temp != null) {

    System.out.print(temp.data + " -> ");

    temp = temp.next;
}

System.out.println("null");

}

Linked Lists trade:

random access

for:

flexible insertions/deletions

That’s their main strength.

Nodes form a one-way chain
Head stores first node
Insert at head → O(1)
Traversal → O(n)

Singly Linked Lists are one of the most important DSA foundations.

Understanding them deeply makes advanced structures much easier

Explore More: https://www.quipoin.com/tutorial/data-structure-with-java/singly-linked-list

The Data Structure That Powers Stacks & Queues

Quipoin — Sat, 23 May 2026 04:21:51 +0000

Imagine a treasure hunt…

Each clue tells you where the next clue is.

That’s exactly how a Linked List works.

Instead of storing elements side-by-side like arrays,
each node stores:

data
a reference to the next node

1. What is a Linked List?

A Linked List is a linear data structure made of nodes.

Each node contains:

actual data
link to next node

Node Structure in Java

public class Node {

int data;
Node next;

public Node(int data) {

    this.data = data;
    this.next = null;
}

}

How It Works

Visual representation:

[10] → [20] → [30] → null

Each node knows:

where the next node exists.

*2. Why Use Linked Lists?
*
Unlike arrays:

linked lists do NOT require contiguous memory.

This gives:

dynamic size
flexible insertion/deletion

Advantages

Dynamic Size

Linked list can grow/shrink easily.

Fast Insert/Delete

If reference is available:

O(1) insertion/deletion

Better Memory Usage

No fixed-size allocation.

3. Drawbacks of Linked Lists
Slow Access

To reach an element:

traverse node by node.

Complexity:

O(n) access

Extra Memory

Every node stores an additional pointer.

Not Cache Friendly

Nodes are scattered in memory.

Linked Lists trade:

fast access

for:

flexible insertion & deletion.

That’s why they are useful in:

stacks
queues
graph structures
hash tables
Linked list = chain of nodes
Nodes store data + next reference
Dynamic structure
Slower random access

Linked Lists may seem simple…

But they form the foundation of many advanced data structures

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

Sliding Window on Strings Explained Simply in Java

Quipoin — Wed, 20 May 2026 12:19:04 +0000

Many string problems look complicated because they involve:

substrings
repeated characters
dynamic conditions

Beginners often use nested loops…

But sliding window reduces many of these problems from:

O(n²) to:
O(n)

1. Longest Substring Without Repeating Characters
Problem

Find the length of the longest substring with unique characters.

Efficient Sliding Window Solution

public static int lengthOfLongestSubstring(String s) {

Set<Character> set = new HashSet<>();

int left = 0, maxLen = 0;

for (int right = 0; right < s.length(); right++) {

    while (set.contains(s.charAt(right))) {

        set.remove(s.charAt(left));

        left++;
    }

    set.add(s.charAt(right));

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

return maxLen;

}

Core Idea

Maintain a window:

expand right pointer
shrink left when duplicate appears

This keeps the substring valid.

*2. Minimum Window Substring
*Problem

Find the smallest substring containing all characters of a pattern.

Example:

Text = "ADOBECODEBANC"
Pattern = "ABC"

Answer:

"BANC"

Key Idea

Use:

character frequency counts
dynamic window resizing

Expand until valid,
then shrink to minimize window.

3. Longest Repeating Character Replacement
Problem

Given:

a string
k replacements

Find the longest substring that can become all same characters.

Smart Observation

Track:

most frequent character inside window.

If:

windowSize - maxFreq > k

then shrink window.

Sliding window works because:

we reuse previous computations instead of recalculating substrings.

That’s the optimization.

Sliding window avoids nested loops
Expand → valid state
Use two pointers
Track characters using set/map
Expand right pointer
Shrink left when condition breaks
Complexity → O(n)

Sliding window is one of the most important interview patterns.

Once you master it,

many “hard” string problems become manageable

Explore More: https://www.quipoin.com/tutorial/data-structure-with-java/sliding-window-on-strings

Anagram & Palindrome Problems Explained Simply in Java

Quipoin — Tue, 19 May 2026 05:27:21 +0000

String interview questions often look tricky…

But many of them are built on:

character counting
frequency matching
two-pointer logic

Anagram and palindrome problems are perfect examples.

1. Check if Two Strings are Anagrams

Two strings are anagrams if:

both contain the same characters
with the same frequency.

Example:

listen
silent

Efficient Approach

Use a frequency array.

public static boolean areAnagrams(String s1, String s2) {

if (s1.length() != s2.length())
    return false;

int[] freq = new int[26];

for (int i = 0; i < s1.length(); i++) {

    freq[s1.charAt(i) - 'a']++;
    freq[s2.charAt(i) - 'a']--;
}

for (int count : freq) {

    if (count != 0)
        return false;
}

return true;

}

Why This Works

If both strings contain the same letters:

all frequencies cancel out to zero.

2. Group Anagrams

Given:

["eat", "tea", "tan", "ate"]

Output:

[["eat","tea","ate"], ["tan"]]

Smart Trick

Sort characters of each string.

Example:

eat → aet
tea → aet

Same sorted form:

same group.

public static List> groupAnagrams(String[] strs) {

Map<String, List<String>> map = new HashMap<>();

for (String s : strs) {

    char[] arr = s.toCharArray();

    Arrays.sort(arr);

    String key = new String(arr);

    map.computeIfAbsent(key,
        k -> new ArrayList<>()).add(s);
}

return new ArrayList<>(map.values());

}

3. Palindrome Check

Palindrome:

reads same forwards & backwards.

Example:

madam
racecar

Two Pointer Technique

Compare:

left character
right character

Move inward until middle.

Most string interview problems are about:

counting characters
comparing efficiently
reducing repeated work
Anagrams → frequency matching
Grouping → hashing + sorting
Palindrome → two pointers

These problems may look basic…

But the same logic appears in advanced interview questions too

Explore More: https://www.quipoin.com/tutorial/data-structure-with-java/anagram-palindrome-problems

Pattern Matching in Java: Naive Search vs KMP Explained

Quipoin — Mon, 18 May 2026 06:34:29 +0000

Ever wondered how:

browsers search text
editors find words
search engines process patterns

It all starts with:

Pattern Matching.

The goal is simple:
Find a smaller string (pattern)
inside a larger string (text).

1. Naive Pattern Matching

The simplest approach:

Check every possible starting position.

public static int naiveSearch(String text, String pattern) {

int n = text.length();
int m = pattern.length();

for (int i = 0; i <= n - m; i++) {

    int j;

    for (j = 0; j < m; j++) {

        if (text.charAt(i + j) != pattern.charAt(j))
            break;
    }

    if (j == m)
        return i;
}

return -1;

}

How It Works

Example:

Text:

ABABDABACDABABCABAB

Pattern:

ABABC

Start checking from every position.

If mismatch occurs:

shift pattern by one step.

Problem with Naive Approach

Worst-case complexity:

O(n×m)

Because:

characters get rechecked multiple times.

2. KMP Algorithm (Basic Idea)

KMP improves performance using:

LPS array (Longest Prefix Suffix)

Instead of restarting from zero:

it uses previous match information.

KMP Complexity

O(n+m)

This is much faster for large strings.

KMP is powerful because it:

remembers previous matches
avoids unnecessary comparisons

That’s the optimization.

Pattern matching = substring search
Naive approach is simple but slower
KMP uses preprocessing for speed

Vist Full Tutorials Here: https://www.quipoin.com/tutorial/data-structure-with-java/pattern-matching-basics

StringBuilder vs StringBuffer in Java

Quipoin — Sun, 17 May 2026 06:54:17 +0000

Many beginners write code like this:

String s = "";

for (int i = 0; i < 10000; i++) {
s += i;
}

Looks harmless…

But internally:

thousands of new String objects are created

That’s why Java provides:

StringBuilder
StringBuffer

Why Regular String Is Slow

Strings in Java are immutable.

That means:

s += "Java";

does NOT modify the existing string.

Instead:

a completely new object is created.

1. StringBuilder

StringBuilder is:

Mutable
Fast
Not thread-safe

StringBuilder sb = new StringBuilder();

sb.append("Hello");
sb.append(" World");

String result = sb.toString();

Common Methods

sb.insert(5, " Java");
sb.delete(5, 10);
sb.reverse();

2. StringBuffer

StringBuffer is similar to StringBuilder.

Difference:

It is synchronized (thread-safe).

StringBuffer sbuf = new StringBuffer();

sbuf.append("Thread-safe");

Performance Difference

Inefficient

String s = "";

for (int i = 0; i < 10000; i++) {
s += i;
}

Efficient

StringBuilder sb = new StringBuilder();

for (int i = 0; i < 10000; i++) {
sb.append(i);
}

String result = sb.toString();

The Real Insight

When strings change frequently:

mutable objects are much more efficient.

That’s why:

StringBuilder is preferred in most cases
StringBuffer is used when thread safety matters
String = immutable
StringBuilder = mutable + fast
StringBuffer = mutable + thread-safe

For More Learning: https://www.quipoin.com/tutorial/data-structure-with-java/stringbuilder-vs-stringbuffer

Java String Manipulation Made Simple

Quipoin — Sat, 16 May 2026 05:49:25 +0000

String questions are everywhere in coding interviews.

And most of them are built on a few simple patterns:

Two pointers
Character arrays
StringBuilder

Master these, and many problems become easy.

1. Reverse a String

The easiest way:

public static String reverse(String str) {
return new StringBuilder(str).reverse().toString();
}

Manual Reverse

public static String reverseManual(String str) {

char[] arr = str.toCharArray();

int left = 0, right = arr.length - 1;

while (left < right) {

    char temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;

    left++;
    right--;
}

return new String(arr);

}

Core Idea

Use two pointers:

one from start
one from end

Swap characters until middle.

2. Check Palindrome

A palindrome reads the same forwards and backwards.

Example:

madam
level
public static boolean isPalindrome(String str) {

int left = 0, right = str.length() - 1;

while (left < right) {
```
if (str.charAt(left) != str.charAt(right))
    return false;

left++;
right--;
```
}

return true;
}

Why Two Pointers Work

Compare:

first ↔ last
second ↔ second-last

If all match:

palindrome confirmed.

3. Remove Duplicate Characters

public static String removeDuplicates(String str) {

Set<Character> seen = new LinkedHashSet<>();

for (char c : str.toCharArray()) {
    seen.add(c);
}

StringBuilder sb = new StringBuilder();

for (char c : seen)
    sb.append(c);

return sb.toString();

}

Why LinkedHashSet?

Because it:

removes duplicates
preserves insertion order

Most string problems involve:

traversing characters
comparing from both ends
building new strings efficiently
Strings are immutable
StringBuilder improves efficiency
Two-pointer technique is powerful for strings

For More Learning: https://www.quipoin.com/tutorial/data-structure-with-java/string-manipulation

Why Java Strings Are Immutable — And Why It Matters

Quipoin — Fri, 15 May 2026 04:48:09 +0000

Strings look simple…

But Java Strings hide some very important concepts:

Immutability
String Pool
Memory optimization

And interviewers LOVE asking about them.

What is a String?

A String is a sequence of characters.

In Java:

Strings are objects of the String class.

String name = "Java";

Why Strings Are Immutable

Once a String is created:

Its value cannot be changed.

Example:

String s = "Hello";
s = s + " World";

This creates:

Old object → "Hello"
New object → "Hello World"

The original string remains unchanged.

String Pool Explained

Java stores string literals inside a special memory area called the String Pool.

String s1 = "Hello";
String s2 = "Hello";

Both variables point to the same pooled string.

This saves memory and improves performance.

Important String Methods

String str = " Java DSA ";

str.length();
str.trim();
str.toUpperCase();
str.charAt(2);
str.indexOf("DSA");
str.substring(2, 9);

equals() vs ==

This is one of the most common beginner mistakes.

String a = new String("Java");
String b = new String("Java");

System.out.println(a == b); // false
System.out.println(a.equals(b)); // true

Why?

== compares references
equals() compares content

Java Strings are designed this way for:

Security
Memory optimization
Thread safety
Strings are immutable
String literals use pooling
Use equals() for comparison

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

Matrix Problems Explained Simply (Java + Intuition)

Quipoin — Wed, 13 May 2026 05:28:35 +0000

Matrix problems often look intimidating.

Too many rows, columns, indices…

But most interview questions are built on just a few core patterns.

Master these patterns once,
and matrix questions become much easier.

1. Spiral Traversal

Problem

Print matrix elements in spiral order.

public static List spiralOrder(int[][] matrix) {

List<Integer> result = new ArrayList<>();

int top = 0, bottom = matrix.length - 1;
int left = 0, right = matrix[0].length - 1;

while (top <= bottom && left <= right) {

    for (int i = left; i <= right; i++)
        result.add(matrix[top][i]);

    top++;

    for (int i = top; i <= bottom; i++)
        result.add(matrix[i][right]);

    right--;

    if (top <= bottom) {
        for (int i = right; i >= left; i--)
            result.add(matrix[bottom][i]);

        bottom--;
    }

    if (left <= right) {
        for (int i = bottom; i >= top; i--)
            result.add(matrix[i][left]);

        left++;
    }
}

return result;

}

Core Idea

Maintain 4 boundaries:

top
bottom
left
right
Move inward layer by layer.

2. Rotate Matrix by 90°

Trick

Instead of rotating directly:

Transpose matrix
Reverse each row

public static void rotate(int[][] matrix) {

// Transpose
for (int i = 0; i < matrix.length; i++) {
    for (int j = i; j < matrix[0].length; j++) {

        int temp = matrix[i][j];
        matrix[i][j] = matrix[j][i];
        matrix[j][i] = temp;
    }
}

// Reverse rows
for (int i = 0; i < matrix.length; i++) {

    int left = 0, right = matrix[0].length - 1;

    while (left < right) {

        int temp = matrix[i][left];
        matrix[i][left] = matrix[i][right];
        matrix[i][right] = temp;

        left++;
        right--;
    }
}

}

Why It Works

Transpose:

Rows ↔ Columns

Reverse:

Adjust orientation

Together:

90° clockwise rotation.

3. Set Matrix Zeroes

Problem

If one element is zero:

Entire row & column become zero.

Smart Optimization

Use:

First row
First column

as markers instead of extra space.

The Real Insight

Matrix problems are mostly about:

Direction handling
Boundary management
Smart index manipulation

Key Insights

Spiral → boundaries
Rotate → transpose + reverse
Zeroes → marker optimization

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

The Smart O(n) Trick for Subarray Sum Questions

Quipoin — Tue, 12 May 2026 04:53:08 +0000

Subarray problems are everywhere in coding interviews.

And most beginners solve them using:

Nested loops
O(n²) brute force

But interviewers expect something smarter.

That’s where:

Prefix Sum
HashMap

become powerful together.

Core Idea

Instead of recalculating sums repeatedly:

Store running sums (prefix sums)
Use hashing for quick lookup

This reduces many problems to O(n).

1. Subarray Sum Equals K

Problem

Find number of subarrays whose sum equals k.

public static int subarraySum(int[] nums, int k) {
Map map = new HashMap<>();

map.put(0, 1);

int sum = 0, count = 0;

for (int num : nums) {
    sum += num;

    int diff = sum - k;

    count += map.getOrDefault(diff, 0);

    map.put(sum, map.getOrDefault(sum, 0) + 1);
}

return count;

}

Key Insight

If:

prefixSum−previousPrefix=k

Then:

A valid subarray exists.

2. Zero Sum Subarray

Problem

Check if any subarray has sum = 0.

public static boolean hasZeroSumSubarray(int[] nums) {
Set set = new HashSet<>();

int sum = 0;

for (int num : nums) {
    sum += num;

    if (sum == 0 || set.contains(sum))
        return true;

    set.add(sum);
}

return false;

}

Why It Works

If the same prefix sum appears twice:

Middle subarray sum = 0

3. Longest Subarray with Sum K

Idea

Store the first occurrence of each prefix sum.

Helps maximize length.

The Real Insight

Most subarray problems become easier when you think in terms of:

Running sums
Differences between prefix sums

Key Insights

Prefix sum + HashMap = powerful pattern
Avoids nested loops
Many interview problems use this idea

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

3 Pointers, One Pass: The Smart Sorting Trick

Quipoin — Tue, 05 May 2026 08:29:15 +0000

Sorting usually means:

O(n log n)
Extra space

But what if the array contains only 3 distinct values?

You can sort it in:

O(n) time
O(1) space
Single pass

That’s the Dutch National Flag Algorithm.

Core Idea

Use three pointers:

low → boundary for 0s
mid → current element
high → boundary for 2s

Implementation

public static void sortColors(int[] nums) {
int low = 0, mid = 0, high = nums.length - 1;

while (mid <= high) {
    switch (nums[mid]) {
        case 0:
            swap(nums, low, mid);
            low++; mid++;
            break;

        case 1:
            mid++;
            break;

        case 2:
            swap(nums, mid, high);
            high--;
            break;
    }
}

}
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}

How It Works

At each step:

If 0 → move to left
If 1 → keep in middle
If 2 → move to right

All done in one traversal

The Real Insight

Instead of sorting, we partition the array

This is similar to Quick Sort partitioning.

Key Insights

Three-pointer technique
In-place sorting
Single pass solution

For More: https://www.quipoin.com/tutorial/data-structure-with-java/dutch-national-flag

Stop Using Extra Space: Master Moore’s Voting Algorithm

Quipoin — Sun, 03 May 2026 05:23:11 +0000

Finding the majority element seems easy…

Just count frequencies, right?

But that takes extra space.

What if you could solve it in:

O(n) time
O(1) space

That’s where Moore’s Voting Algorithm shines.

Core Idea

The algorithm works like cancelling votes.

Different elements cancel each other
Majority element survives

Phase 1: Candidate Selection

int candidate = 0, count = 0;

for (int num : nums) {
if (count == 0) {
candidate = num;
count = 1;
} else if (num == candidate) {
count++;
} else {
count--;
}
}

Think of it as:

Same element → increase count
Different element → cancel

Phase 2: Verification

count = 0;
for (int num : nums) {
if (num == candidate) count++;
}

if (count > nums.length / 2) return candidate;
return -1;

Ensures candidate is actually majority

Example

Array:

[3, 3, 4, 2, 3, 3, 3]

Majority element = 3

The Real Insight

Majority element can’t be fully cancelled

Because it appears more than half the time.

Key Insights

Uses vote cancellation logic
Requires two passes
No extra space needed

for more: https://www.quipoin.com/tutorial/data-structure-with-java/moore-voting-algorithm