01 - Linear - Basic - Array

Question 1

What is an array?

Answer 1

The array is a linear, sequential data structure that stores elements accessible by indices; in Java it has fixed size and a defined type at creation.

Question 2

What is the “killer feature” of arrays?

Answer 2

Direct random access by index in constant time O(1).

Question 3

What does O(1) mean in array access?

Answer 3

It means access time does not grow with the array size; it is constant.

Question 4

What is an array API?

Answer 4

An abstraction built on top of the raw array that provides extra functionality, safety, and optimizations.

Question 5

Array vs ArrayList in Java (size)

Answer 5

Array: fixed size. ArrayList: automatically resizable.

Question 6

Array vs ArrayList in Java (types)

Answer 6

Array: stores primitives and objects. ArrayList: stores only objects (primitives via wrappers).

Question 7

Array vs ArrayList in Java (methods)

Answer 7

Array: manual operations. ArrayList: built-in methods such as add, remove, get, set, size.

Question 8

4 Array characteristics

Answer 8

1)Fixed size and contiguous elements in memory -
2) Index access in O(1). - Random Access
3) Insertion/removal in the middle requires shifting elements: O(n).
4) Can hold anything (primitives and objects)

Question 9

Why is index access O(1)?

Answer 9

Because the address of the element is computed as base + index × element_size.

Question 10

Average cost of inserting at the end of a full array

Answer 10

Amortized O(1) in a dynamic array; O(n) worst case due to reallocation and copying.

Question 11

How does insertion work in a simple array?

Answer 11

Choose a position, shift elements to the right, and write the new value.

Question 12

How does removal work in a simple array?

Answer 12

Remove the element, shift subsequent elements to the left to close the gap.

Question 13

Disadvantage of inserting at the beginning of an array

Answer 13

Requires shifting all elements: cost O(n).

Question 14

When to use a fixed array?

Answer 14

When the size is known and immutable and you want maximum efficiency and simplicity.

Question 15

When to use an ArrayList?

Answer 15

When you need dynamic growth/shrink and want a rich API of methods.

Question 16

What is a dynamic array?

Answer 16

An array that automatically resizes (usually doubling capacity) when full.

Question 17

Growth (resize) strategy

Answer 17

When size == capacity, allocate a larger array (e.g., ×2) and copy elements.

Question 18

Time complexity of push in a dynamic array

Answer 18

Amortized O(1); occasionally O(n) when resizing occurs.

Question 19

Time complexity of access and set in a dynamic array

Answer 19

O(1) for index-based get and set.

Question 20

Time complexity of insert/delete in the middle of a dynamic array

Answer 20

O(n) due to shifting.

Question 21

Interview best practices (arrays)

Answer 21

Understand O(1) access, shifting costs, amortized resizing, and array vs linked list use cases.

Question 22

Basic operations on arrays (Java)

Answer 22

get/set by index, insert by shifting, remove by shifting, and bounds checking.

Question 23

Difference between capacity and size in a dynamic array

Answer 23

Capacity: allocated space. Size: number of stored elements.

Question 24

Pseudocode: insert at end (no resize)

Answer 24

if size < cap: a[size] = x; size++.

int[] array = new int[5]; // fixed size array
int size = 3; // current number of elements
int element = 10; // element to insert

if (size < array.length) {
array[size] = element; // insert at end
size++; // update size
} else {
System.out.println(“Array is full, cannot insert!”);
}

Question 25

Pseudocode: insert at end (with resize)

Answer 25

allocate b[2*cap]; copy; a = b; cap *= 2; a[size] = x; size++. public void insertAtEnd(int value) { // if array is full, resize if (size == array.length) { int[] newArray = new int[array.length * 2]; // copy old elements for (int i = 0; i < size; i++) { newArray[i] = array[i]; } array = newArray; } // insert at the end array[size] = value; size++; }

Question 26

Pseudocode: insert at i (0 ≤ i ≤ size)

Answer 26

shift j = size−1…i to j+1; a[i] = x; size++. public void insertAt(int i, int value) { if (i < 0 || i > size) { throw new IndexOutOfBoundsException("Index: " + i); } // assuming capacity > size // shift elements to the right for (int j = size; j > i; j--) { array[j] = array[j - 1]; } array[i] = value; size++; }

Question 27

Pseudocode: remove at i (0 ≤ i < size)

Answer 27

shift j = i+1…size−1 to j−1; size--. public int removeAt(int i) { if (i < 0 || i >= size) { throw new IndexOutOfBoundsException("Index: " + i); } int removedValue = array[i]; // Shift elements left for (int j = i; j < size - 1; j++) { array[j] = array[j + 1]; } size--; // reduce logical size return removedValue; }

Question 28

Trade-off of shrinking capacity automatically

Answer 28

Reduces memory but frequent resizes may degrade performance; use thresholds.

Question 29

How to avoid autoboxing with ArrayList of primitives

Answer 29

Use primitive arrays or specialized libraries; ArrayList requires wrapper types.

Question 30

Why is ArrayList.get(i) O(1)?

Answer 30

Because it uses an internal array and accesses by index directly.

Question 31

Array bounds checking

Answer 31

Always ensure 0 ≤ i < size to avoid exceptions or data corruption.

Question 32

How do you create and initialize an array in Java?

Answer 32

// Create an array with a fixed size int[] numbers = new int[5]; // Initialize values numbers[0] = 10; numbers[1] = 20; numbers[2] = 30; numbers[3] = 40; numbers[4] = 50; // Or create and initialize in one line int[] numbers2 = { 10, 20, 30, 40, 50 };

Question 33

Give examples of the use of arrays of Objects

Answer 33

´´´java Object[] objects = new Object[10]; String[] strings = new String[]; Person[] persons = new Person[10]; ´´´