What is the time complexity of accessing an element in an array?

Accessing by index in an array is O(1) — constant time.

Why is insertion at the beginning of an array O(n)?

Because all elements after the insertion point must be shifted to the right.

Time Complexity of Basic Array Operations | FullStackPrep.Dev

💡 Concept Name

Time Complexity of Array Operations — Analyzing the speed and efficiency of everyday tasks on arrays, such as accessing, searching, inserting, or deleting elements.

📘 Quick Intro

Arrays are all about fast, direct access to elements using an index. However, not all operations are created equal—while reading an element is instant, adding or removing from the middle can be slow. Understanding why can help you write faster, cleaner code.

🧠 Analogy / Short Story

Picture a long row of books on a library shelf. Grabbing the third book is quick and easy (like array access). But if you want to insert a new book between the 3rd and 4th, you'll have to slide every book after the 3rd one spot to the right first!

🔧 Technical Explanation

⚡ Access by index: O(1) — Instantly fetch any element by its position. No searching needed.
🔍 Search: O(n) — You may have to check every element if the value isn't present.
➕ Insertion at end (static array): O(1) if space exists, else O(n) if resizing is needed.
➕ Insertion at beginning/middle: O(n) — Each element after the insertion point must be shifted right.
➖ Deletion from end: O(1) — Just reduce the count; data doesn't need to be shifted.
➖ Deletion from middle/start: O(n) — Elements to the right of the deleted item need to slide left.
📦 Space Complexity: O(n) — Linear with the number of elements stored.

🎯 Purpose & Use Case

✅ Use arrays when you need lightning-fast, index-based access and know the total number of items ahead of time.
✅ Arrays are perfect for static datasets, or where changes (insert/delete) are rare.
✅ For apps with frequent add/remove operations (except at the end), consider dynamic collections like List<T> or LinkedList<T> instead.

💻 Real Code Example

// Access: O(1)
int[] nums = { 1, 2, 3, 4 };
int second = nums[1]; // super fast!

// Search: O(n)
bool found = nums.Contains(3);

// Insert at end (if space): O(1), else O(n)
int[] newNums = new int[5];
Array.Copy(nums, 0, newNums, 0, nums.Length);
newNums[4] = 5; // adding to the end (simulate append)

// Delete from middle: O(n)
for (int i = 2; i < newNums.Length - 1; i++)
    newNums[i] = newNums[i + 1]; // shift elements left

❓ Interview Q&A

Q1: What is the time complexity of accessing an array element by index?
A: O(1)

Q2: What is the worst-case time for searching in an unsorted array?
A: O(n)

Q3: What is the time to insert an element at the beginning?
A: O(n)

Q4: What is the time to delete an element at the end?
A: O(1)

Q5: Why is inserting in the middle O(n)?
A: Because it requires shifting elements.

Q6: What’s the space complexity of an array with n elements?
A: O(n)

Q7: Can you resize a static array in .NET?
A: No, you must allocate a new one.

Q8: How to append in a fixed-size array?
A: Create a larger array and copy elements.

Q9: Which operation benefits most from an array?
A: Index-based access.

Q10: Is deletion from array expensive?
A: Yes, unless deleting the last item.

📝 MCQs

Q1. What is the time complexity of accessing an array by index?

O(1)
O(n)
O(log n)
O(n^2)

Q2. What is the time complexity for searching in an unsorted array?

O(n)
O(1)
O(log n)
O(n log n)

Q3. What is insertion time at the beginning of an array?

O(1)
O(n)
O(log n)
O(n^2)

Q4. What is deletion time at the end of an array?

O(n)
O(1)
O(log n)
O(n log n)

Q5. Why is insertion in the middle O(n)?

Due to sorting
Due to memory limits
Due to shifting elements
It is O(1)

Q6. What is the space complexity of an array with n items?

O(1)
O(n)
O(n^2)
O(log n)

Q7. How do you simulate array append in .NET?

Use ref
Array.Resize()
Create a new array and copy
Add to original

Q8. Which operation is fastest in arrays?

Search
Insert
Delete
Access by index

Q9. When is deletion from an array O(n)?

When deleting last
Always
When not deleting last element
Never

Q10. Can static arrays in .NET grow in size?

Yes
No
Only in List<T>
Only with pointers

💡 Bonus Insight

Arrays deliver blazing-fast access if you know exactly where to look. But for flexibility—like growing, shrinking, or lots of insertions—reach for List<T> or LinkedList<T> instead. Each data structure has its sweet spot!

📄 PDF Download

Need a handy summary for your notes? Download this topic as a PDF!

📄 PDF Download Coming Soon

Time Complexity of Basic Array Operations