Heap fragmentation happens when free memory in heap becomes divided into small scattered blocks.

This makes memory allocation inefficient.

Why It Happens?

Repeated:

• malloc()
• free()

operations of different sizes create gaps in memory.

Example

Allocated:
[A][B][C][D]

After freeing B and D:
[A][ ][C][ ]

Now free memory exists, but in fragmented form.

Types of Fragmentation

1. External Fragmentation

Free memory exists but not in contiguous block.

2. Internal Fragmentation

Allocated block contains unused space.

Problems

• Memory wastage
• Allocation failure
• Reduced performance

Prevention

• Memory pooling
• Proper allocation strategy
• Compact memory usage

Interview Insight

Very important concept in:

• Operating systems
• Embedded systems
• Memory management interviews

*** 22. Explain pointer increment behavior.

When a pointer is incremented, it moves by:

size of its data type

not by 1 byte.

Example

int arr[] = {10, 20, 30};

int *p = arr;

p++;

Behavior

If integer size is 4 bytes:

Before increment -> 1000
After increment  -> 1004

Character Pointer Example

char *c;
c++;

Moves by:

1 byte

Important Rule

Interview Insight

Very frequently asked pointer question.

*** 23. Remove duplicates in array

This program removes duplicate elements from array.

Program

#include <stdio.h>

int main() {

    int arr[] = {1, 2, 2, 3, 4, 4, 5};

    int size = 7;

    for(int i = 0; i < size; i++) {

        for(int j = i + 1; j < size; ) {

            if(arr[i] == arr[j]) {

                for(int k = j; k < size - 1; k++) {
                    arr[k] = arr[k + 1];
                }

                size--;

            } else {
                j++;
            }
        }
    }

    for(int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }

    return 0;
}

Output

1 2 3 4 5

Time Complexity

O(n²)

Interview Insight

Optimization:
Use hashing for:

O(n)

solution.

** 24. Detect unique characters in string

This program checks whether all characters are unique.

Program

#include <stdio.h>
#include <string.h>

int main() {

    char str[] = "hello";

    int unique = 1;

    for(int i = 0; str[i] != '\0'; i++) {

        for(int j = i + 1; str[j] != '\0'; j++) {

            if(str[i] == str[j]) {
                unique = 0;
                break;
            }
        }
    }

    if(unique)
        printf("Unique Characters");
    else
        printf("Duplicates Found");

    return 0;
}

Output

Duplicates Found

Better Approach

Use frequency array or hash set.

Interview Insight

Common interview follow-up:

“How to solve in O(n)?”

Using hashing.

*** 25. Reverse each word in sentence

This program reverses every word individually.

Example

Input:

Hello World

Output:

olleH dlroW

Program

#include <stdio.h>
#include <string.h>

void reverse(char str[], int start, int end) {

    while(start < end) {

        char temp = str[start];
        str[start] = str[end];
        str[end] = temp;

        start++;
        end--;
    }
}

int main() {

    char str[] = "Hello World";

    int start = 0;

    for(int i = 0; ; i++) {

        if(str[i] == ' ' || str[i] == '\0') {

            reverse(str, start, i - 1);

            start = i + 1;
        }

        if(str[i] == '\0')
            break;
    }

    printf("%s", str);

    return 0;
}

Interview Insight

Frequently asked string manipulation problem.

** 26. Count subarrays with even sum

A subarray has even sum when:

sum % 2 == 0

Optimized Logic

• Even + Even = Even
• Odd + Odd = Even

Program

#include <stdio.h>

int main() {

    int arr[] = {1, 2, 3, 4};

    int n = 4;

    int evenCount = 1;
    int oddCount = 0;

    int sum = 0;
    int result = 0;

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

        sum += arr[i];

        if(sum % 2 == 0) {

            result += evenCount;
            evenCount++;

        } else {

            result += oddCount;
            oddCount++;
        }
    }

    printf("%d", result);

    return 0;
}

Time Complexity

O(n)

Interview Insight

Important prefix-sum interview problem.

*** 27. Find intersection point of linked lists

Two linked lists intersect if they share same node address.

Efficient Approach

Use:

• Two pointers
• Length difference adjustment

Logic

1. Find lengths
2. Move longer list ahead
3. Traverse together

Program

struct Node* getIntersection(struct Node* head1,
                             struct Node* head2) {

    while(head1 != head2) {

        head1 = (head1 == NULL) ? head2 : head1->next;

        head2 = (head2 == NULL) ? head1 : head2->next;
    }

    return head1;
}

Time Complexity

O(n)

Interview Insight

Very popular linked-list interview problem.

*** 28. Merge two sorted linked lists

This program merges two sorted linked lists into one sorted list.

Program

struct Node* merge(struct Node* a, struct Node* b) {

    if(a == NULL)
        return b;

    if(b == NULL)
        return a;

    struct Node* result = NULL;

    if(a->data <= b->data) {

        result = a;

        result->next = merge(a->next, b);

    } else {

        result = b;

        result->next = merge(a, b->next);
    }

    return result;
}

Example

List1: 1 -> 3 -> 5
List2: 2 -> 4 -> 6

Output:

1 -> 2 -> 3 -> 4 -> 5 -> 6

Interview Insight

Frequently asked recursion + linked list question.

*** 29. Detect circular linked list

A circular linked list contains a loop.

Best Approach

Use:

Floyd’s Cycle Detection Algorithm

Also called:

Tortoise and Hare Algorithm

Program

int hasCycle(struct Node *head) {

    struct Node *slow = head;
    struct Node *fast = head;

    while(fast && fast->next) {

        slow = slow->next;
        fast = fast->next->next;

        if(slow == fast)
            return 1;
    }

    return 0;
}

Time Complexity

O(n)

Space Complexity

O(1)

Interview Insight

Very common DSA interview question.

*** 30. Balanced parentheses using stack

This problem checks whether brackets are balanced.

Example

Valid

{[()]}

Invalid

{[(])}

Logic

• Push opening brackets into stack
• Pop when closing bracket appears
• Check matching pair

Program

#include <stdio.h>
#include <string.h>

char stack[100];
int top = -1;

void push(char c) {
    stack[++top] = c;
}

char pop() {
    return stack[top--];
}

int main() {

    char str[] = "{[()]}";

    int balanced = 1;

    for(int i = 0; str[i] != '\0'; i++) {

        char ch = str[i];

        if(ch == '(' || ch == '{' || ch == '[') {

            push(ch);

        } else {

            if(top == -1) {
                balanced = 0;
                break;
            }

            char p = pop();

            if((ch == ')' && p != '(') ||
               (ch == '}' && p != '{') ||
               (ch == ']' && p != '[')) {

                balanced = 0;
                break;
            }
        }
    }

    if(top != -1)
        balanced = 0;

    if(balanced)
        printf("Balanced");
    else
        printf("Not Balanced");

    return 0;
}

Time Complexity

O(n)

Interview Insight

Very frequently asked stack interview problem.

*** 31. Add numbers without +

Addition can be performed using bitwise operators.

Logic

• XOR (^) gives sum without carry
• AND (&) gives carry
• Left shift carry by 1

Repeat until carry becomes 0.

Program

#include <stdio.h>

int add(int a, int b) {

    while(b != 0) {

        int carry = a & b;

        a = a ^ b;

        b = carry << 1;
    }

    return a;
}

int main() {

    printf("%d", add(5, 3));

    return 0;
}

Output

8

Interview Insight

Very common bit manipulation interview problem.

** 32. Subtract without -

Subtraction can be done using:

• Two’s complement
• Bitwise addition logic

Logic

a - b = a + (~b + 1)

Program

#include <stdio.h>

int subtract(int a, int b) {

    return a + (~b + 1);
}

int main() {

    printf("%d", subtract(10, 3));

    return 0;
}

Output

7

Interview Insight

Important concept:

~b + 1

represents two’s complement.

** 33. Multiply by 2 without *

Multiplication by 2 can be done using left shift operator.

Logic

x << 1

means:

x * 2

Program

#include <stdio.h>

int main() {

    int x = 7;

    printf("%d", x << 1);

    return 0;
}

Output

14

Why?

Left shift moves bits left by one position.

Interview Insight

Common extension:

x << n = x * 2ⁿ

*** 34. Check EVEN/ODD without arithmetic operators

Use bitwise AND operator.

Logic

Last bit:
0 -> Even
1 -> Odd

Program

#include <stdio.h>

int main() {

    int n = 7;

    if(n & 1)
        printf("Odd");
    else
        printf("Even");

    return 0;
}

Output

Odd

Why Works?

Binary of odd numbers ends with:

1

Interview Insight

Very frequently asked bitwise interview question.

*** 35. Set, clear, toggle, and check bits

Bit manipulation is widely used in:

• Embedded systems
• Competitive programming
• System programming

1. Set Bit

Logic

num | (1 << pos)

Example

num = num | (1 << 2);

2. Clear Bit

Logic

num & ~(1 << pos)

Example

num = num & ~(1 << 2);

3. Toggle Bit

Logic

num ^ (1 << pos)

Example

num = num ^ (1 << 2);

4. Check Bit

Logic

num & (1 << pos)

Example

if(num & (1 << 2))

Quick Summary

Interview Insight

Extremely common embedded systems interview topic.

*** 36. What is bit masking?

Bit masking means using bitwise operations to manipulate specific bits.

Why Used?

• Enable/disable flags
• Extract bits
• Permission systems
• Embedded programming

Example

int mask = 1 << 3;

Check Specific Bit

if(num & mask)

Real-World Example

Permission systems:

Read  = 001
Write = 010
Exec  = 100

Interview Insight

Bit masking is heavily used in:

• Device drivers
• Networking
• Operating systems

** 37. Difference between signed and unsigned shift

Signed Shift

Works on signed integers.

Right shift may preserve sign bit.

Example

int x = -8;

x >> 1;

Unsigned Shift

Works on unsigned integers.

Vacated bits filled with:

0

Example

unsigned int x = 8;

x >> 1;

Key Difference

Interview Insight

Right shift behavior for signed integers can be implementation-defined.

*** 38. Swap numbers without temp variable

Method 1: Using XOR

Program

#include <stdio.h>

int main() {

    int a = 5, b = 10;

    a = a ^ b;
    b = a ^ b;
    a = a ^ b;

    printf("%d %d", a, b);

    return 0;
}

Output

10 5

Method 2: Using Addition/Subtraction

a = a + b;
b = a - b;
a = a - b;

Interview Insight

XOR swap is famous interview question, but temporary variable method is usually more readable.

*** 39. Detect system endianness

Endianness defines byte order in memory.

Types

Program

#include <stdio.h>

int main() {

    unsigned int x = 1;

    char *c = (char*)&x;

    if(*c)
        printf("Little Endian");
    else
        printf("Big Endian");

    return 0;
}

Logic

If first byte contains:

1

system is little-endian.

Interview Insight

Very common system programming interview question.

** 40. What is dynamic data structure?

A dynamic data structure can grow or shrink during runtime.

Memory is allocated dynamically using heap memory.

Examples

• Linked List
• Stack using linked list
• Queue
• Tree
• Graph

Advantages

• Flexible size
• Efficient memory usage
• Runtime scalability

Example

struct Node {
    int data;
    struct Node *next;
};

Difference from Static Data Structure

Interview Insight

Common interview question:

“Why are linked lists dynamic?”

Because nodes are allocated at runtime using dynamic memory allocation

Push: 1 2 3

Pop Order:
3 2 1

Insert: 1 2 3

Remove Order:
1 2 3

Stack

10 -> 20 -> 30
^           |
|___________|

struct Node {
    int data;
    struct Node *next;
};

Array insertion -> shifting required
Linked list insertion -> pointer adjustment only

struct Test {
    char c;
    int x;
};

1 + 4 = 5 bytes

8 bytes

char c   -> 1 byte
padding  -> 3 bytes
int x    -> 4 bytes

#pragma pack(1)

#pragma pack(1)

struct Test {
    char c;
    int x;
};

struct Test {
    int x;
    char c;
};

struct Data {
    unsigned int x : 3;
};

3 bits

struct Flags {
    unsigned int isActive : 1;
    unsigned int isAdmin  : 1;
};

Hello 123

fprintf()
fscanf()

fwrite()
fread()

fwrite(ptr, size, count, fp);

fwrite(&x, sizeof(int), 1, fp);

fread(ptr, size, count, fp);

fread(&x, sizeof(int), 1, fp);

#include <stdio.h>

int main() {

    FILE *fp;

    int x = 100;

    fp = fopen("data.bin", "wb");

    fwrite(&x, sizeof(int), 1, fp);

    fclose(fp);

    return 0;
}

#include <stdio.h>

int main() {

    FILE *fp;

    char line[100];

    fp = fopen("data.txt", "r");

    while(fgets(line, sizeof(line), fp)) {

        printf("%s", line);
    }

    fclose(fp);

    return 0;
}

gets()

End Of File

-1

int ch;

while((ch = fgetc(fp)) != EOF) {
    printf("%c", ch);
}