Theoretical Questions for Interviews on Array

1. What is an array?

An array is a data structure consisting of a collection of elements, each identified by at least one array index or key.

2. How do you declare an Array?

Each language has its own way of declaring arrays, but the general idea is similar: defining the type of elements and the number of elements or initializing it directly.

✅ C/C++: int arr[5]; (Declares an array of 5 integers).
✅ Java: int[] arr = new int[5]; (Declares and initializes an array of 5 integers).
✅ Python: arr = [1, 2, 3, 4, 5] (Uses a list, which functions like an array and doesn’t require a fixed size).
✅ JavaScript: let arr = [1, 2, 3, 4, 5]; (Uses arrays without needing a size specification).
✅ C#: int[] arr = new int[5]; (Declares an array of 5 integers).

3. Can an array be resized at runtime?

An array is fixed in size once created. However, in C, you can resize an array at runtime using Dynamic Memory Allocation (DMA) with malloc() or realloc(). Most modern languages have dynamic-sized arrays like vector in C++, list in Python, and ArrayList in Java, which automatically resize.

4. Is it possible to declare an array without specifying its size?

In C/C++, declaring an array without specifying its size is not allowed and causes a compile-time error. However, in C, we can create a pointer and allocate memory dynamically using malloc(). In C++, we can use vectors where we can declare first and then dynamically add elements. In modern languages like Java, Python, and JavaScript, we can declare without specifying the size.

5. What is the time complexity for accessing an element in an array?

The time complexity for accessing an element in an array is O(1), as it can be accessed directly using its index.

6. What is the difference between an array and a linked list?

An array is a static data structure, while a linked list is a dynamic data structure. Raw arrays have a fixed size, and elements are stored consecutively in memory, while linked lists can grow dynamically and do not require contiguous memory allocation. Dynamic-sized arrays allow flexible size, but the worst-case time complexity for insertion/deletion at the end becomes more than O(1). With a linked list, we get O(1) worst-case time complexity for insertion and deletion.

7. How would you find out the smallest and largest element in an array?

The best approach is iterative (linear search), while other approaches include recursive and sorting.

Iterative method

Algorithm:

1. Initialize two variables:

small = arr[0] (first element as the smallest).

large = arr[0] (first element as the largest).



2. Traverse through the array from index 1 to n-1.


3. If arr[i] > large, update large = arr[i].


4. If arr[i] < small, update small = arr[i].


5. Print the values of small and large.



C++ Code Implementation

#include <iostream>
using namespace std;

void findMinMax(int arr[], int n) {
    int small = arr[0], large = arr[0];

    for (int i = 1; i < n; i++) {
        if (arr[i] > large) 
            large = arr[i];
        if (arr[i] < small) 
            small = arr[i];
    }

    cout << "Smallest element: " << small << endl;
    cout << "Largest element: " << large << endl;
}

int main() {
    int arr[] = {7, 2, 9, 4, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    findMinMax(arr, n);

    return 0;
}

8. What is the time complexity to search in an unsorted and sorted array?

✅ Unsorted Array: The time complexity for searching an element in an unsorted array is O(n), as we may need to check every element.
✅ Sorted Array: The time complexity for searching an element in a sorted array is O(log n) using binary search.

🔹 O(log n) takes less time than O(n), whereas O(n log n) takes more time than O(n).