C Programming Interview Questions: Master the Core Concepts

C is the backbone of modern computing—powering operating systems, embedded devices, and high-performance applications. In interviews, C questions test your understanding of low-level concepts like memory management, pointers, and data structures. This article covers the most frequently asked C interview questions, from basic syntax to advanced topics like dynamic memory allocation and bit manipulation. Each question includes a solution with time and space complexity analysis, plus tips on how to present your answer in an interview. Whether you're preparing for a systems programming role or a general software engineering position, mastering these concepts will set you apart. Let's dive into the essential C interview questions that every developer should know.

1. Pointers and Memory Management

Pointers are a fundamental concept in C. Interviewers often ask about pointer arithmetic, null pointers, and dynamic memory allocation. A common question is: 'Write a function to reverse a string in place using pointers.' The solution involves using two pointers—one at the start and one at the end—and swapping characters until they meet. This demonstrates understanding of pointer arithmetic and memory manipulation. Another frequent topic is the difference between malloc, calloc, and realloc. malloc allocates uninitialized memory, calloc allocates zero-initialized memory, and realloc resizes previously allocated memory. Always check the return value of malloc for NULL to handle allocation failure.

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

void reverse_string(char *str) {
    char *start = str;
    char *end = str + strlen(str) - 1;
    while (start < end) {
        char temp = *start;
        *start = *end;
        *end = temp;
        start++;
        end--;
    }
}

int main() {
    char s[] = "hello";
    reverse_string(s);
    printf("%s\n", s);
    return 0;
}

2. Strings and Character Arrays

C strings are null-terminated character arrays. Common interview questions include finding the length of a string without using strlen, checking for palindromes, and implementing strcpy or strcat. A classic problem is: 'Implement atoi to convert a string to an integer.' This requires handling leading whitespace, optional sign, and overflow. Another is 'Find the first non-repeating character in a string.' Use a hash table (or array of size 256) to count frequencies, then traverse again to find the first character with count 1. Be careful with null terminators and buffer overflows—always ensure destination buffers are large enough.

#include <stdio.h>
#include <limits.h>

int my_atoi(const char *str) {
    int sign = 1, result = 0, i = 0;
    while (str[i] == ' ') i++;
    if (str[i] == '-' || str[i] == '+') {
        sign = (str[i++] == '-') ? -1 : 1;
    }
    while (str[i] >= '0' && str[i] <= '9') {
        if (result > INT_MAX / 10 || (result == INT_MAX / 10 && str[i] - '0' > INT_MAX % 10)) {
            return (sign == 1) ? INT_MAX : INT_MIN;
        }
        result = result * 10 + (str[i++] - '0');
    }
    return result * sign;
}

int main() {
    printf("%d\n", my_atoi("   -123"));
    return 0;
}

3. Data Structures: Linked Lists

Linked lists are a staple in C interviews. You may be asked to reverse a linked list, detect a cycle, or find the middle element. Reversing a linked list iteratively uses three pointers: prev, current, and next. For cycle detection, Floyd's cycle-finding algorithm (tortoise and hare) is efficient. Another common question is merging two sorted linked lists. The solution uses a dummy node to simplify the merging process. Always handle edge cases like empty lists and single-node lists.

#include <stdio.h>
#include <stdlib.h>

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

struct Node* reverse(struct Node* head) {
    struct Node *prev = NULL, *current = head, *next = NULL;
    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    return prev;
}

void printList(struct Node* head) {
    while (head) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}

int main() {
    struct Node* head = malloc(sizeof(struct Node));
    head->data = 1; head->next = malloc(sizeof(struct Node));
    head->next->data = 2; head->next->next = malloc(sizeof(struct Node));
    head->next->next->data = 3; head->next->next->next = NULL;
    head = reverse(head);
    printList(head);
    return 0;
}

4. Bit Manipulation

Bit manipulation questions test your understanding of binary operations. Common tasks: check if a number is power of two, count set bits, or find the only non-repeating element in an array where every other element repeats twice. For power of two, use n > 0 && (n & (n-1)) == 0. For counting set bits, Brian Kernighan's algorithm repeatedly clears the lowest set bit. For the non-repeating element, XOR all numbers; the result is the unique element. These questions are popular because they demonstrate low-level thinking.

#include <stdio.h>

int countSetBits(int n) {
    int count = 0;
    while (n) {
        n &= (n - 1);
        count++;
    }
    return count;
}

int main() {
    printf("%d\n", countSetBits(7));
    return 0;
}

5. Dynamic Memory Allocation and Structures

Questions about dynamic memory allocation often involve creating and manipulating structures. For example, implement a function to create a 2D array dynamically. This requires allocating an array of pointers, then each row. Another common question is implementing a stack using dynamic arrays or linked lists. Always free memory to avoid leaks. Interviewers may ask about the difference between struct and union, or padding and alignment. Use #pragma pack or __attribute__((packed)) to control padding.

#include <stdio.h>
#include <stdlib.h>

int** create2DArray(int rows, int cols) {
    int **arr = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        arr[i] = (int*)malloc(cols * sizeof(int));
    }
    return arr;
}

void free2DArray(int **arr, int rows) {
    for (int i = 0; i < rows; i++) free(arr[i]);
    free(arr);
}

int main() {
    int **arr = create2DArray(3, 4);
    arr[0][0] = 5;
    printf("%d\n", arr[0][0]);
    free2DArray(arr, 3);
    return 0;
}

6. Recursion and Function Pointers

Recursion questions often involve tree traversals, factorial, or Fibonacci. However, C interviewers may ask about function pointers—pointers that store the address of a function. For example, implement a sorting function that takes a comparison function pointer. This is the basis of qsort. Another question: write a recursive function to compute the nth Fibonacci number, but discuss its exponential time complexity and suggest memoization. Understanding recursion depth and stack overflow is crucial.

#include <stdio.h>

int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

int operate(int (*op)(int, int), int x, int y) {
    return op(x, y);
}

int main() {
    printf("%d\n", operate(add, 5, 3));
    printf("%d\n", operate(multiply, 5, 3));
    return 0;
}