Array Interview Questions and Answers for 2025

A Sparse Array is the type of array in which most of the elements have either zero or null values. These types of arrays do not have contiguous indexes and are used over basic arrays. There are less non zero elements in comparison to the elements with zero value. 

This is because this way, we only need to store non zero elements which are less in number saving a lot of memory and time which again in the world of DSA are very essential parameters. 

They are normally seen and used in the Sparse Matrix in which most of the elements are equal to zero and no null values are there. Let us see some examples to understand.

Example

This is a frequently asked question in Programming questions on Arrays.

Before answering this question, let's first understand the concept of both arrays and pointers in C.

A. Arrays in C

Array will not be changed, no matter in which language they are defined in. They are collections of elements of the same data type stored in contiguous memory locations.

B. Pointers in C

In C, pointers are used to hold the address of variables or memory locations. These variables can be of any data type, such as int, char, function, array, or any other pointer. The pointer of type void is known as a Void pointer or a Generic pointer. A void pointer can hold the location of any type of variable.

Difference between Arrays and Pointers

No, it is not possible to initialize an array of negative size. This is because ‘as per the convention of array declaration, it is mandatory that each time an array is evaluated it shall have a size greater than 0. Declaring array size negative breaks this “shall” condition.’ That is why this action gives an error of NegativeArraySizeException at run-time in Java while other programming languages handle the declaration of Array size with a negative value. Let's see some of them.

Python

C++

Java

Expect to come across this popular question in Array interview questions.  

We have two sorted arrays, A and B, the task is to merge both arrays in such a way that the third array is also sorted. 

Examples 

Input: arr1[] = { 1, 3, 4, 5}, arr2[] = {2, 4, 6, 8}  

Output: arr3[] = {1, 2, 3, 4, 4, 5, 6, 8} 

There are many ways of doing it, but here we will be discussing the most efficient way by using merge sort. 

Using Merge Sort Algorithm 

1. Create an array C of n+m size to store the merged array 
2. Initialize three pointers i, j, and k for the three arrays respectively. 
3. Traverse both the input arrays simultaneously using the pointers. 
4. Compare the elements of both arrays at each index using the pointers and place the smaller one into the C[]. 
5. Increase the pointer of that array through which we have copied the element for C[] and the pointer of the C[]. 
6. If we have reached the end of an array, simply copy the remaining elements of the other array and paste them into C[].

class Main{ 
        public static int[] mergeArrays(int[] A, int[] B, int m,int n){ 
                int i = 0, j = 0, k = 0; 
        int[] C = new int[m+n]; 
 
                // Traverse both array 
                while (i<m && j <n){ 
                        // Check if current element of first 
                        // array is smaller than current element 
                        // of second array. If yes, store first 
                        // array element and increment first array 
                        // index. Otherwise do same with second array 
                        if (A[i] < B[j]) 
                                C[k++] = A[i++]; 
                        else 
                                C[k++] = B[j++]; 
                } 
 
                // Store remaining elements of first array 
                while (i < m) 
                        C[k++] = A[i++]; 
 
                // Store remaining elements of second array 
                while (j < n) 
                        C[k++] = B[j++]; 
            
        return C; 
        } 
 
        public static void main (String[] args){ 
                int[] A = {1, 3, 5, 7}; 
                int m = A.length; 
 
                int[] B = {2, 4, 6, 8}; 
                int n = B.length; 
 
                int[] nums = mergeArrays(A, B, m, n); 
 
                System.out.println("Array after merging"); 
                for (int i=0; i < m+n; i++) 
                        System.out.print(nums[i] + " "); 
        } 
} 

Output 

Array after merging - 1, 2, 3, 4, 5, 6, 7, 8 
Time Complexity - O(n+m) 
Space Complexity - O(n+m) 

In data structures there is something known as Hashed Array Tree which is also a type of dynamic array but it stores data in a separate memory fragment called leaves unlike dynamic arrays which stores data in the heap part of the JVM that too in contiguous order.

Its basic objective is to eliminate element duplication caused by automatic array resizing operations and to enhance memory usage patterns. In contrast to dynamic arrays, which are based on geometric expansion, HAT wastes rootlinear - O(√n) space.

We know that an array is a collection of elements of the same data type stored in contiguous memory locations and are of fixed size and cannot be resized until declared otherwise.

Now the error ArrayStoreException is thrown by the compiler when we try to add an element of an incompatible data type. While the other error ArrayOutOfBounds is thrown by the compiler when we are either accessing an element with -ve index value or illegal index.  Let's understand these errors with the help of an example.

A must-know for anyone heading into an Array interview, this question is frequently asked in Array questions in Java.  

We have been given an array and told to write a program to cyclic rotate this array by one - here, cyclic means in the clockwise direction. 

Examples:   

Input:  arr[] = {1, 2, 3, 4, 5} 

Output: arr[] = {5, 1, 2, 3, 4} 

Approach: Using the k variable 

In this approach, we will define a new variable, say k. Store the last element into k and shift the rest towards the end of the array. When all the elements have been shifted to the end, paste the k elements, which was also the last element of the array, and here is our chad and tare for us.

import java.util.Arrays; 
public class Main { 
   public static void main(String args[]) { 
     int[] a = {1, 2, 3, 4, 5}; 
     int k = a[a.length-1]; 
    for (int i = a.length-1; i > 0; i--) 
          a[i] = a[i-1]; 
      a[0] = k; 
       System.out.print(Arrays.toString(a)); 
   } 
} 

Output - 

{5, 1, 2, 3, 4} 
Time Complexity: O(n) 
Space Complexity: O(1)

HashSet class implements Set Interface and is backed up by a Hash Table to arrange and store elements in it. The working of a Hash table is little different than other methods of storing elements, in its elements are not stored in the same way they are given to a hashset.

It uses a unique concept of hash code to sort and store data making it easier to perform operations like add, remove, contains, and size assuming the hash function disperses the elements properly among the buckets, and the time complexity taken by the Hash et to perform all of these is O(1).

There are two ways in which we can convert a HashSet into an array: 

1. Traversing HashSet and adding every element to the array 
2. Convert the complete HashSet into an array using the toArray() method 

Method 1: Traversing Hashset and adding every element to the array 

We can traverse the HashSet using the forEach loop and add each element into the array one at a time.

import java.io.*; 
import java.util.*; 
  
class Main { 
    public static void main(String[] args) 
    { 
        HashSet<String> set = new HashSet<String>(); 
        set.add("1"); 
        set.add("13"); 
        set.add("27"); 
        set.add("87"); 
        set.add("19"); 
  
        System.out.println("Hash Set Contains :" + set); 
        String arr[] = new String[set.size()]; 
          
        int i=0; 
        
        // iterating over the hashset 
        for(String ele:set){ 
          arr[i++] = ele; 
        } 
  
       System.out.println("Array. contains : "+ Arrays.toString(arr)); 
    } 
} 

Output 

Hash Set Contains :[1, 13, 27, 19, 87] 

Array. contains : [1, 13, 27, 19, 87] 

Method 2 : Convert the complete HashSet into an array using the toArray() method. 

The toArray() method of ArrayList is used to return an array containing all the elements in ArrayList in the correct order. 

Syntax: 

public Object[] toArray() 
           or 
public <T> T[] toArray(T[] a) 

import java.io.*; 
import java.util.*;  
class Main { 
    public static void main(String[] args) 
    { 
        HashSet<String> set = new HashSet<String>(); 
        set.add("1"); 
        set.add("13"); 
        set.add("27"); 
        set.add("87"); 
        set.add("19"); 
  
        System.out.println("Hash Set Contains :" + set); 
        String arr[] = new String[set.size()]; 
        
        // toArray() method converts the set to array 
        set.toArray(arr); 
System.out.println("Array Contains : "+ Arrays.toString(arr));
 } 
} 

Output 

Hash Set Contains :[1, 13, 27, 19, 87] 
Array Contains : [1, 13, 27, 19, 87] 

We were given an array containing both positive and negative numbers. Our task is to rearrange the array elements so that positive and negative numbers are alternately placed. The sum of positive and negative numbers does not have to be equal.

If there are more positive numbers, they are displayed at the bottom of the array. If there are any more negative numbers, they are also added to the end of the array.

Example 

Input : arr[] =  [-1, 2, -3, 4, 5, 6, -7, 8, 9]; 

Output : arr[] = [9, -7, 8, -3, 5, -1, 2, 4, 6];

import java.io.*; 
class Main { 
    // The main function that rearranges elements of given 
    // array.  It puts positive elements at even indexes (0, 
    // 2, ..) and negative numbers at odd indexes (1, 3, ..). 
    static void rearrange(int arr[], int n) 
    { 
        // The following few lines are similar to partition 
        // process of QuickSort.  The idea is to consider 0 
        // as pivot and divide the array around it. 
        int i = -1, temp = 0; 
        for (int j = 0; j < n; j++) 
        { 
            if (arr[j] < 0) 
            { 
                i++; 
                temp = arr[i]; 
                arr[i] = arr[j]; 
                arr[j] = temp; 
            } 
        } 
        // Now all positive numbers are at end and negative numbers at 
        // the beginning of array. Initialize indexes for starting point 
        // of positive and negative numbers to be swapped 
        int pos = i+1, neg = 0; 
        // Increment the negative index by 2 and positive index by 1, i.e., 
        // swap every alternate negative number with next positive number 
        while (pos < n && neg < pos && arr[neg] < 0) 
        { 
            temp = arr[neg]; 
            arr[neg] = arr[pos]; 
            arr[pos] = temp; 
            pos++; 
            neg += 2; 
        } 
    } 
    // A utility function to print an array 
    static void printArray(int arr[], int n) 
    { 
        for (int i = 0; i < n; i++) 
            System.out.print(arr[i] + "   "); 
    } 
    /*Driver function to check for above functions*/ 
    public static void main (String[] args) 
    { 
        int arr[] = {-1, 2, -3, 4, 5, 6, -7, 8, 9}; 
        int n = arr.length; 
        rearrange(arr,n); 
        System.out.println("Array after rearranging: "); 
        printArray(arr,n); 
    } 
} 

Output 

Array after rearranging:  
4   -3   5   -1   6   -7   2   8   9    
Time Complexity:  O(n) 
Space Complexity: O(1) 

Consecutive numbers are those numbers that follow each other in order and have a difference of 1 between them. Like 1,2,3,4,5 is a set of consecutive numbers.

According to the problem, we have to find whether the elements of the given array are consecutive or not. And to do that we will be using two methods - sorting and XOR.

Method 1 - Sorting

Approach 

Just sort the given array and fins whether the elements of the given array are consecutive or not.

import java.util.*; 
class Main { 
    public static void main(String[] args) { 
        int arr[] = {5, 4, 3, 1, 6, 2}; 
        int n = arr.length; 
        Arrays.sort(arr); 
    // checking the adjacent elements 
    for(int i=1;i<n;i++) 
    { 
        if(arr[i]!=arr[i-1]+1) 
        { 
            System.out.println("Elements are not Consecutive"); 
        } 
    } 
    System.out.println("Elements are Consecutive"); 
  } 
} 

Output 

Elements are Consecutive 
Time Complexity - O(n log n) 
Space Complexity - O(1) 

Method 2 - Using XOR Property 

Approach 

1. Find either the min or max element of the array. 
2. Take xor of this unsorted array, and if the result comes to zero then the array is consecutive. 

import java.util.*; 
class Main { 
    public static void main(String[] args) { 
        int arr[] = {5, 4, 3, 1, 6, 2}; 
        int n = arr.length; 
       int min_ele = Arrays.stream(arr).min().getAsInt(); 
    int num = 0; 
    for(int i=0; i<n; i++){ 
        num = num ^ min_ele ^ arr[i]; 
        min_ele += 1; 
    } 
    if(num == 0) { 
        System.out.println("Array is consecutive"); 
    }else { 
        System.out.println("Array is not Consecutive"); 
    } 
  } 
} 

Output 

Array is Consecutive 
Time Complexity - O(n) 
Space Complexity - O(1) 

According to Geeks for Geeks, the reduce() method reduces the array to a single value. and executes a provided function for each value of the array (from left-to-right) and the return value of the function is stored in an accumulator.

Syntax 

array.reduce( function(total, currentValue, currentIndex, arr),  initialValue ) 

Where - 

Total and current value are required parameters while the other three are optional parameters.

Coming back to the question, we have to double the value of the elements of the array like  

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

Output arr[] = {2, 4, 6, 8, 10} 

var arr = [1, 2, 3, 4, 5]; 
var doubled = arr.reduce(function (memo, val) { 
  memo.push(val * 2); 
  return memo; 
}, []); 
console.log(doubled);

Output 

[ 2, 4, 6, 8, 10 ]

In the above code, we have defined and used two variables - memo and val which are representing the total and currentValue parameter of the reduce() method.

The initial value of the memo variable will be 0 and that of val will be 1 which when multiplied by 2 will become 2 which will become the current value of memo which then gets returned to the function. Same process continues until we have reached the end of the array,  

This question is a regular feature in Array interview questions, be ready to tackle it.  

According to MDN docs, the map() method creates a new array populated with the results of calling a provided function on every element in the calling array. Simply said, this method allows us to iterate over an array and modify its elements using a callback function. The callback function will then be executed on each of the array's elements.

It is basically a replacement for loop and was introduced with other ES6 variables and methods. Instead of manually iterating over the array using a for loop, you can simply use the built-in Array.map() method.

Let us understand the map method with the help of an example program. We are given an array of size 5 and we are told to print the same array but this time by multiplying each element by 3.

Suppose your input array is {1, 2, 3, 4, 5}, then the output should be {3, 6, 9, 12, 15}.

var arr = [1, 2, 3, 4, 5]; 
for (let i = 0; i < arr.length; i++){ 
  arr[i] = arr[i] * 3; 
} 
console.log("Using for loop " + arr); 
var arr1 = [1, 2, 3, 4, 5]; 
arr1.map((val) => { 
    return arr1 * 3; 
}) 
console.log("Using map function " + arr1);

Output 

Using for loop3,6,9,12,15 

Using map function1,2,3,4,5 

We can clearly see that map() function works the same way as the for loop. 

This is a frequently asked question in Java Array interview questions.

According to MDN docs, the destructuring assignment syntax is a JavaScript expression that makes it possible to unpack values from arrays, or properties from objects, into distinct variables.

Consider me choosing a shirt from my favorite assortment of stunning yet casual shirts. I will first search through the collection of shirts and unpack everything to get a better idea of what’s in store, which will aid me in making better decisions.

Destructuring is the same as unpacking the elements of an object or array. Destructuring gives us the ability to manipulate and switch out elements after they have been unpacked, depending on the operation we want to carry out.

Destructuring array elements in JavaScript is quite easy, we just have to use the bracket([]) notation to define destructuring.

const colorArr = ["red", "yellow", "blue", "green", "white", "black"]; 
const [first, second] = colorArr; 
console.log(first, second); // red, yellow 

We can also use destructuring to store variable names which will be assigned to the name of the array storing the element.

const [var1, var2, ...] = arrayName;

There are endless possibilities when it comes to destructuring array elements. Like the one shown below:

var thing = ["Table", "Chair", "Fan"]; 
var [a, b, c] = thing; 
console.log(a); // Output: Table 
console.log(b); //Output: Chair 
console.log(c); //Output: Fan 

Here we have mapped each variable on the array literal on the left-hand side to the same element at the same index in the array.

Thus we can say that destructuring has made extracting data from an array very simple and readable.

There are four ways in which we can empty an array:

1. Equate the array to an empty array
2. Make its length 0
3. Using splice() method
4. Using pop() method

Suppose we have the following array, and my task is to remove all its elements;

Let us see the different methods of emptying the array in action;

• Equate the array to an empty array

Yes, this is one of the methods of turning an array of any numeric length to empty. This is by far the most easiest way to empty a array.

This array a previously had elements in it and was of length 5. But now its length has become zero as we can see in the above image. It works perfectly if we do not have any references to the original array.

In the above code, the variable b has stored the values of a in it or we can say has taken a reference of a, and then the variable a is assigned to an empty array. But its reference still persists.

• Make its length 0

Another way to make an array empty is to set its length to zero.

• Using the splice() method

This method of java script is used to modify the existing array by either removing or adding new elements in the array.

Syntax

array.splice(index, howmany, item1, ....., itemX) 

Where -

• Index - required parameter which denotes the position of either adding or removing elements.
• Howmany - optional parameter which tells us the number of items that need to be removed.
• Items - optional parameter which tells us the number of elements that needs to be added

• Using pop() method

This method will remove every element one by one from the end of the array until the array is empty.

There are three ways of retrieving a class name of the array from the object:  

1. Using get*Name() Methods 
2. Using Class.getEnclosingClass() method 
3. Using Stack Trace

Using the get*Name() Methods. 

The simplest way to retrieve the class name of an array is to use the getClass() and getName() methods. The getClass() returns the runtime class of the array while the getName() method returns the name of the class/array class. There are many ways of calling them like getSimpleName() or getCanonicalName() which as the name suggests will return the simple and conical name of the underlying class.

Using the Class.getEnclosingClass() Method 

This method is only used when we want to return an anonymous inner class that is an immediate enclosing class of an underlying class.

Using the Stack Trace Method 

The first element which has been returned by the stack trace which acts just like a call stack contains the stack frame of the current method used for debugging and contains the information of the class

This method is not safe as some machines may omit some vital information from the stack frames while giving us a stack frame with incomplete information.

One of the most frequently posed Array interview questions, be ready for it.  

An object is a thing that has characteristics (called properties), whereas an array is a list of data that is stored in a single variable. We can access, alter, and delete items from objects using brackets and dots, while we can access and modify items in arrays using a variety of built-in methods and zero-based indexing. Using various loops (e.g., for, for...in, for...of, forEach()), we can iterate over object properties and array items.

On the heap memory, all Java objects are dynamically allocated. Unlike in C++, where objects can be allocated on the Heap or the Stack. When we use the new() method in C++, the object is allocated on the heap unless it is global or static, in which case it is allocated on Stack.

Dimension of an array is the number of indices or subscripts that you need to specify an individual element of an array while subscripts are a means of displaying or defining the value of a particular element in an array.  

A subscript is a number while a dimension is a description of the range of the number of keys. And you only need one subscript for the dimension of the array.

This is a frequently asked question in Array coding questions.  

We know that arrays are the simplest form of data structures that can store multiple values at the same time, but they should be of the same data type and stored at contiguous memory locations. These values can be accessed and modified using their index or keys, which again is in the form of a number starting from 0.

These contiguous memory locations are the spaces created by the new() keyword on either the heap or stack memory, and the address of the element is calculated mathematically during run-time using the formula given below:

element address = (base address) + (element index * size of a single element) 

Where?  

• Base Address: As the name suggests, this is the address of the starting element or the element stored at index 0. The compiler knows this address as the memory location of the array. 
• Element Index: It is the number that is given to the element at the time of array creation aka its index number which again starts from 0 and ends at 1, less than the length of the array.  
• Size of the Single Element: As we know, the elements of the array need to be of the same data type. The size of the single element is the number of bytes required in memory to store a single element of that kind. Like for int it is 4 bytes in java. 

The below table shows memory taken by different data types for Java and C++ programming languages: 

Array remains the same no matter the programming language. The difference comes in the methods we use to perform certain operations like removing a certain element from the array.

In JavaScript we have four different methods which can very easily do this task for us without us traversing through each element of the array. Those four methods are:

1. pop() Method
2. shift() Method
3. splice() Method
4. filter() Method

pop() Method - This method is used to remove elements from the end of the array and returns the removed array.

function func() { 
        var arr = ["shift", "splice", "filter", "pop"]; 
      
        // Popping the last element from the array 
        var remove = arr.pop(); 
        console.log("Removed element: " + remove ); 
        console.log("Remaining elements: " + arr); 
    } 
    func();

Output

Removed element: pop

Remaining elements: shift,splice,filter

shift() Method - This method is used to removes the first element of the array.

function func() { 
        var arr = ["shift", "splice", "filter", "pop"]; 
      
        // Popping the last element from the array 
        var remove = arr.shift(); 
        console.log("Removed element: " + remove ); 
        console.log("Remaining elements: " + arr); 
    } 
    func(); 

Output

Removed element: shift

Remaining elements: splice,filter,pop

splice() Method - This method is little different from the other two. With this method we can even add an element at any position of the array either using its index or the value which we want to add. For this question our main focus will be on how to remove an element from an array. See the following to understand this method clearly.

//Use the indexing of the splice method to remove elements from a JavaScript array. 
function func() { 
        var arr = ["shift", "splice", "filter", "pop"]; 
      
        var spliced = arr.splice(1, 1); 
        console.log("Use the indexing of the splice method to remove elements from a JavaScript array. ") 
        console.log("Removed element: " + spliced); 
        console.log("Remaining elements: " + arr); 
        console.log("\n"); 
    } 
    func(); 
//Using the value of the splice method to remove elements from a JavaScript array. 
 function func1() { 
        var arr1 = ["shift", "splice", "filter", "pop"]; 
      
        for (var i = 0; i < arr1.length; i++) { 
            if (arr1[i] === "splice") { 
                var spliced = arr1.splice(i, 1); 
                console.log("Using the value of the splice method to remove elements from a JavaScript array. ") 
                console.log("Removed element: " + spliced); 
                console.log("Remaining elements: " + arr1); 
            } 
        } 
    } 
    func1();