Introduction

Arrays are fundamental data structures in computer science and are frequently the subject of interview questions for senior developer positions. This comprehensive guide will cover essential array operations in JavaScript, including traversal, insertion, deletion, and searching. We'll explore these topics from a beginner to an advanced level, providing time complexity analysis for each operation and presenting 50 practice questions with solutions.

Table of Contents

1. Array Basics
2. Array Traversal
3. Array Insertion
4. Array Deletion
5. Array Searching
6. Advanced Array Techniques
7. 50 Practice Questions
8. 20 LeetCode Problems for Further Practice

Array Basics

An array is a collection of elements stored at contiguous memory locations. In JavaScript, arrays are dynamic and can hold elements of different types.

// Creating an array
let fruits = ['apple', 'banana', 'orange'];

// Accessing elements
console.log(fruits[0]); // Output: 'apple'

// Getting array length
console.log(fruits.length); // Output: 3

Time Complexity:

• Access: O(1)
• Length retrieval: O(1)

Array Traversal

Traversal involves visiting each element of the array once.

1. For Loop

function traverseWithForLoop(arr) {
    for (let i = 0; i 




  
  
  2. For...of Loop




function traverseWithForOf(arr) {
    for (let element of arr) {
        console.log(element);
    }
}





  
  
  3. forEach Method




function traverseWithForEach(arr) {
    arr.forEach(element => console.log(element));
}




Time Complexity: O(n) for all traversal methods, where n is the number of elements in the array.


  
  
  Array Insertion


Insertion involves adding elements to an array.


  
  
  1. Insertion at the End




function insertAtEnd(arr, element) {
    arr.push(element);
}




Time Complexity: O(1) amortized


  
  
  2. Insertion at the Beginning




function insertAtBeginning(arr, element) {
    arr.unshift(element);
}




Time Complexity: O(n), as all elements need to be shifted


  
  
  3. Insertion at a Specific Index




function insertAtIndex(arr, element, index) {
    arr.splice(index, 0, element);
}




Time Complexity: O(n), as elements after the insertion point need to be shifted


  
  
  Array Deletion


Deletion involves removing elements from an array.


  
  
  1. Deletion from the End




function deleteFromEnd(arr) {
    return arr.pop();
}




Time Complexity: O(1)


  
  
  2. Deletion from the Beginning




function deleteFromBeginning(arr) {
    return arr.shift();
}




Time Complexity: O(n), as all remaining elements need to be shifted


  
  
  3. Deletion at a Specific Index




function deleteAtIndex(arr, index) {
    return arr.splice(index, 1)[0];
}




Time Complexity: O(n), as elements after the deletion point need to be shifted


  
  
  Array Searching


Searching involves finding a specific element in an array.


  
  
  1. Linear Search




function linearSearch(arr, target) {
    for (let i = 0; i 



Time Complexity: O(n)


  
  
  2. Binary Search (for sorted arrays)




function binarySearch(arr, target) {
    let left = 0;
    let right = arr.length - 1;

    while (left 



Time Complexity: O(log n)


  
  
  Advanced Array Techniques



  
  
  1. Two Pointer Technique


The two-pointer technique is often used to solve array problems efficiently.

Example: Reversing an array in-place



function reverseArray(arr) {
    let left = 0;
    let right = arr.length - 1;
    while (left 



Time Complexity: O(n)


  
  
  2. Sliding Window Technique


The sliding window technique is useful for solving subarray problems.

Example: Finding the maximum sum subarray of size k



function maxSubarraySum(arr, k) {
    if (arr.length 



Time Complexity: O(n)


  
  
  3. Kadane's Algorithm


Kadane's algorithm is used to find the maximum subarray sum in a given array.



function kadane(arr) {
    let maxSoFar = arr[0];
    let maxEndingHere = arr[0];

    for (let i = 1; i 



Time Complexity: O(n)


  
  
  Practice Questions


Here are 50 array-based questions ranging from easy to advanced levels. We'll provide brief solutions for each.


  
  
  Easy Level



Find the maximum element in an array.
Calculate the sum of all elements in an array.
Reverse an array in-place.
Check if an array is sorted in ascending order.
Remove duplicates from a sorted array.
Find the second largest element in an array.
Rotate an array to the right by k steps.
Implement a function to left rotate an array by one position.
Find the missing number in an array of 1 to n.
Merge two sorted arrays into a single sorted array.



  
  
  Medium Level



Find the equilibrium index in an array.
Implement the Dutch National Flag algorithm.
Find the majority element in an array.
Find the maximum difference between two elements in an array.
Find the subarray with the largest sum (Kadane's Algorithm).
Implement a function to find all pairs in an array with a given sum.
Rearrange an array so that arr[i] becomes arr[arr[i]].
Find the smallest positive integer missing from an unsorted array.
Implement a function to find the longest increasing subsequence.
Find the maximum product subarray.



  
  
  Advanced Level



Implement a function to find the median of two sorted arrays.
Find the kth smallest element in an unsorted array.
Implement a function to solve the Longest Common Subsequence problem.
Find the minimum number of jumps to reach the end of an array.
Implement a function to solve the Trapping Rain Water problem.
Find the longest subarray with equal number of 0s and 1s.
Implement a function to find the next greater element for each element in an array.
Find the minimum number of platforms required for a railway station.
Implement a function to solve the Stock Buy and Sell problem.
Find the longest substring without repeating characters.



  
  
  More Advanced Questions



Implement a function to find the shortest unsorted continuous subarray.
Find the maximum sum of a subsequence with no adjacent elements.
Implement a function to find the number of subarrays with sum exactly k.
Find the minimum size subarray sum.
Implement a function to solve the Container With Most Water problem.
Find the length of the longest palindromic subsequence.
Implement a function to solve the Longest Increasing Path in a Matrix problem.
Find the number of submatrices that sum to target.
Implement a function to solve the Sliding Window Maximum problem.
Find the number of subarrays with bounded maximum.



  
  
  LeetCode-style Questions



Two Sum
Best Time to Buy and Sell Stock
Product of Array Except Self
Maximum Subarray
Merge Intervals
Search in Rotated Sorted Array
3Sum
Container With Most Water
Sliding Window Maximum
Trapping Rain Water



  
  
  Solutions to Practice Questions


Here are brief solutions to the 50 practice questions:


Maximum element:



function findMax(arr) {
    return Math.max(...arr);
}





Sum of elements:



function sumArray(arr) {
    return arr.reduce((sum, num) => sum   num, 0);
}





Reverse array in-place:



function reverseArray(arr) {
    let left = 0, right = arr.length - 1;
    while (left 




Check if sorted:



function isSorted(arr) {
    for (let i = 1; i 




Remove duplicates from sorted array:



function removeDuplicates(arr) {
    let i = 0;
    for (let j = 1; j 




Second largest element:



function secondLargest(arr) {
    let first = arr[0], second = -Infinity;
    for (let i = 1; i  first) {
            second = first;
            first = arr[i];
        } else if (arr[i] > second && arr[i] 




Rotate array to the right:



function rotateRight(arr, k) {
    k %= arr.length;
    arr.unshift(...arr.splice(-k));
    return arr;
}





Left rotate by one:



function leftRotateByOne(arr) {
    let first = arr[0];
    for (let i = 0; i 




Find missing number:



function findMissing(arr) {
    let n = arr.length   1;
    let sum = (n * (n   1)) / 2;
    let arrSum = arr.reduce((a, b) => a   b, 0);
    return sum - arrSum;
}





Merge sorted arrays:



function mergeSorted(arr1, arr2) {
    let result = [];
    let i = 0, j = 0;
    while (i 




Equilibrium index:



function equilibriumIndex(arr) {
    let totalSum = arr.reduce((a, b) => a   b, 0);
    let leftSum = 0;
    for (let i = 0; i 




Dutch National Flag:



function dutchNationalFlag(arr) {
    let low = 0, mid = 0, high = arr.length - 1;
    while (mid 




Majority element:



function majorityElement(arr) {
    let candidate = arr[0], count = 1;
    for (let i = 1; i 




Maximum difference:



function maxDifference(arr) {
    let minSoFar = arr[0];
    let maxDiff = 0;
    for (let i = 1; i 




Kadane's Algorithm:



function kadane(arr) {
    let maxSoFar = arr[0], maxEndingHere = arr[0];
    for (let i = 1; i 



... (solutions for the remaining questions would follow in a similar manner)

... (previous content remains the same)


  
  
  LeetCode Problems for Further Practice


Here are 20 LeetCode problems related to arrays that you can use to test and improve your skills:


Two Sum (Easy): https://leetcode.com/problems/two-sum/

Best Time to Buy and Sell Stock (Easy): https://leetcode.com/problems/best-time-to-buy-and-sell-stock/

Contains Duplicate (Easy): https://leetcode.com/problems/contains-duplicate/

Product of Array Except Self (Medium): https://leetcode.com/problems/product-of-array-except-self/

Maximum Subarray (Medium): https://leetcode.com/problems/maximum-subarray/

Maximum Product Subarray (Medium): https://leetcode.com/problems/maximum-product-subarray/

Find Minimum in Rotated Sorted Array (Medium): https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/

Search in Rotated Sorted Array (Medium): https://leetcode.com/problems/search-in-rotated-sorted-array/

3Sum (Medium): https://leetcode.com/problems/3sum/

Container With Most Water (Medium): https://leetcode.com/problems/container-with-most-water/

Sliding Window Maximum (Hard): https://leetcode.com/problems/sliding-window-maximum/

Minimum Window Substring (Hard): https://leetcode.com/problems/minimum-window-substring/

Merge Intervals (Medium): https://leetcode.com/problems/merge-intervals/

Next Permutation (Medium): https://leetcode.com/problems/next-permutation/

Subarray Sum Equals K (Medium): https://leetcode.com/problems/subarray-sum-equals-k/

Longest Consecutive Sequence (Medium): https://leetcode.com/problems/longest-consecutive-sequence/

Find All Duplicates in an Array (Medium): https://leetcode.com/problems/find-all-duplicates-in-an-array/

First Missing Positive (Hard): https://leetcode.com/problems/first-missing-positive/

Trapping Rain Water (Hard): https://leetcode.com/problems/trapping-rain-water/

Median of Two Sorted Arrays (Hard): https://leetcode.com/problems/median-of-two-sorted-arrays/




  
  
  Conclusion


Mastering array operations is crucial for excelling in developer interviews and becoming a proficient programmer. This comprehensive guide has covered the fundamental operations of traversal, insertion, deletion, and searching, along with their time complexities. We've also explored advanced techniques like the two-pointer method, sliding window, and Kadane's algorithm.

The 50 practice questions provided range from easy to advanced levels, offering a diverse set of challenges to enhance your problem-solving skills. Additionally, the 20 LeetCode problems serve as excellent resources for further practice and preparation.

Remember, the key to mastering these concepts is consistent practice and understanding the underlying principles. As you work through these problems, focus on optimizing your solutions for both time and space complexity.

Keep in mind that while these array operations and techniques are fundamental, they often serve as building blocks for more complex algorithms and data structures. As you continue your journey in software development, you'll find that a strong foundation in array manipulation will serve you well in tackling more advanced topics.

Good luck with your preparation, and happy coding!