DSA with JS: Understanding Custom Array Data Structure in JavaScript - A Step-by-Step Guide

Introduction

Arrays are fundamental data structures in programming, essential for organizing and storing data efficiently. They allow developers to manage collections of elements, such as numbers, strings, or objects, by grouping them into a single, ordered structure. Arrays provide easy access to elements through indexing, making them useful for various tasks like sorting, searching, and manipulating data.

JavaScript's native arrays are powerful and flexible, built-in data structures that can dynamically grow or shrink as needed. Unlike arrays in lower-level languages, which are typically of fixed size, JavaScript arrays can handle different data types and adjust their size automatically. JavaScript provides numerous built-in methods, which abstract the complexities of managing memory, resizing, and element access. These methods simplify array manipulation, allowing developers to focus on solving problems without worrying about the underlying implementation. JavaScript arrays are optimized by modern engines like V8, making them highly performant for most use cases.

While JavaScript provides a convenient and highly optimized array implementation, building a custom array helps you understand the mechanics of memory management, dynamic resizing, and efficient data access. By building custom arrays, developers not only improve their problem-solving skills but also develop a deeper understanding of the core principles that drive programming efficiency, preparing them for more advanced data structures and algorithmic challenges.

Building a Custom Array

Let me show you an example of how someone might write arrays using classes in JavaScript. This approach is more low-level, simulating an array's behavior manually. To build a custom array in JavaScript, you can create a class that mimics the behavior of JavaScript's native arrays. The class will need a constructor to initialize the array and methods to perform basic operations like adding, removing, and resizing elements. Here's a simple structure:

class CustomArray {
  constructor() {
    this.data = {};  // Object to hold array data
    this.length = 0; // Length of the array
  }

  // Method to add an element at the end
  push(element) {
    this.data[this.length] = element;
    this.length++;
    return this.length;
  }

  // Method to remove the last element
  pop() {
    if (this.length === 0) return undefined;
    const lastElement = this.data[this.length - 1];
    delete this.data[this.length - 1];
    this.length--;
    return lastElement;
  }

  // Method to get the element at a specific index
  get(index) {
    return this.data[index];
  }

  // Method to delete an element at a specific index
  delete(index) {
    const item = this.data[index];
    this.shiftItems(index);  // Shift items after deletion
    return item;
  }

  // Internal method to shift items after deletion
  shiftItems(index) {
    for (let i = index; i < this.length - 1; i++) {
      this.data[i] = this.data[i + 1];
    }
    delete this.data[this.length - 1];
    this.length--;
  }
}

// Example usage
const myArray = new CustomArray();
myArray.push(10);   // [10]
myArray.push(20);   // [10, 20]
myArray.push(30);   // [10, 20, 30]

console.log(myArray.get(1));  // Output: 20

myArray.delete(1);   // [10, 30]
console.log(myArray); // { data: { '0': 10, '1': 30 }, length: 2 }

myArray.pop();  // Remove last element [10]
console.log(myArray); // { data: { '0': 10 }, length: 1 }

Explanation:

1. Constructor (constructor): Initializes an empty object data and sets the initial length to 0. This object (data) will act like the internal storage of the array.

2. Push (push()): Adds a new element to the array by assigning it to the next available index (tracked by this.length), then increments the length.

3. Pop (pop()): Removes the last element from the array by deleting the last index and reducing the length. This mimics the behavior of the Array.prototype.pop() method.

4. Get (get()): Fetches the value at a specific index. It mimics accessing elements in an array by index (e.g., arr[1]).

5. Delete (delete()): Deletes an element at a given index and shifts the rest of the elements to the left to fill in the gap, similar to what Array.prototype.splice() would do in native JavaScript arrays.

6. Shift Items (shiftItems()): After deleting an element, this method moves all the elements after the deleted index one position to the left, which is necessary to maintain array-like behavior.

Time Complexity & Performance

The topic of performance measurement comes under Big O notation. So, if you think you need to study on Time Complexity and Performance, you can read this article to grasp the concepts.

push() Operation

Time Complexity: O(1) (Constant time) The push() method appends an element at the end of the array. Since it simply places the value at the current length index, it performs in constant time, meaning the operation does not depend on the size of the array.

Space Complexity: O(1) (Constant space) The space complexity is constant because it only adds one new element, regardless of the array size.

push(value) {
  this.data[this.length] = value; // O(1)
  this.length++;
}

pop() Operation

Time Complexity: O(1) (Constant time) The pop() method removes the last element, which involves accessing the last index and adjusting the length. This is also done in constant time.

Space Complexity: O(1) (Constant space) No additional memory is used, and only the last element is removed.

pop() {
  const lastItem = this.data[this.length - 1]; // O(1)
  delete this.data[this.length - 1];
  this.length--;
  return lastItem;
}

Resizing (In the case of dynamic resizing)

Time Complexity: O(n) (Linear time) If you were to implement dynamic resizing (doubling the capacity once the array is full), copying elements to a new larger array would take O(n) time because every element has to be moved to a new location. However, this doesn't happen on every push() call, so amortized over many operations, it approaches O(1) per operation.

Space Complexity: O(n) (Linear space) When resizing, a new array with larger capacity is allocated, leading to a linear space complexity based on the number of elements.

class ResizableArray {
  constructor() {
    this.data = {};
    this.length = 0;
    this.capacity = 2; // Initial capacity
  }

  push(value) {
    if (this.length === this.capacity) {
      this._resize(); // Resize array when it's full
    }
    this.data[this.length] = value;
    this.length++;
  }

  _resize() {
    const newData = {};
    this.capacity *= 2;
    for (let i = 0; i < this.length; i++) {
      newData[i] = this.data[i]; // O(n) operation
    }
    this.data = newData;
  }
}

these are examples of how time and space complexity can be measured for different operations in a custom array implementation. They illustrate the computational cost in terms of time (how long the operation takes) and space (how much memory it uses) based on factors like the size of the array and the type of operation (e.g., push, pop, resizing). These measurements help analyze the efficiency of data structures and algorithms.

Usefulness in coding a javascript script

Custom arrays in JavaScript can be useful in several specific scenarios where you need more control over performance, memory management, or specific behaviors that JavaScript's native array doesn't provide out of the box. Here are a few use cases for custom arrays, along with examples showing how they can provide advantages.

Fixed-Length Array (Optimized Memory Use)

In some cases, you might want an array that has a fixed size, which helps control memory usage more precisely. JavaScript's native array dynamically resizes, but with a custom array, you can allocate a fixed amount of space for efficiency.

Use Case: You are developing a real-time application (e.g., a game or embedded system) where you need strict memory constraints and know exactly how many elements are required.

class FixedArray {
  constructor(size) {
    this.data = new Array(size); // Pre-allocating memory
    this.length = size;
  }

  set(index, value) {
    if (index >= this.length) throw new Error('Index out of bounds');
    this.data[index] = value;
  }

  get(index) {
    if (index >= this.length) throw new Error('Index out of bounds');
    return this.data[index];
  }
}

const fixedArr = new FixedArray(5);
fixedArr.set(0, 'A');
console.log(fixedArr.get(0));  // Output: A

Advantage: Memory is pre-allocated and fixed, which can be beneficial when memory optimization is crucial.

Sparse Array (Efficient for Large, Mostly Empty Arrays)

A sparse array stores only non-null or non-zero elements, which can save memory in cases where an array is large but contains mostly empty or default values.

Use Case: You need to handle a large dataset where only a small percentage of the entries hold values (e.g., managing sparse matrices in scientific computing).

class SparseArray {
  constructor() {
    this.data = {};
  }

  set(index, value) {
    if (value !== null && value !== undefined) {
      this.data[index] = value;
    }
  }

  get(index) {
    return this.data[index] || null; // Return null if the value isn't set
  }
}

const sparseArr = new SparseArray();
sparseArr.set(1000, 'A');  // Only this value takes up memory
console.log(sparseArr.get(1000));  // Output: A
console.log(sparseArr.get(999));   // Output: null

Implementing custom arrays in JavaScript gives you the flexibility to optimize for specific use cases like memory efficiency (fixed or sparse arrays), operational efficiency (circular buffers), or even better programming practices (immutable arrays). These optimizations can significantly improve performance and code reliability in applications with specific requirements, helping you go beyond the limitations of native JavaScript arrays.

Comparing Custom Arrays with Native Arrays

When comparing custom arrays with native arrays in JavaScript, it's essential to understand the strengths and weaknesses of each in different contexts. Native arrays are a built-in feature of JavaScript, providing developers with a highly optimized, dynamic data structure that’s easy to use and integrated deeply into the language. Native arrays come with numerous methods such as push(), pop(), map(), and filter(), which make array manipulation straightforward and efficient for most use cases. Their dynamic nature means they automatically resize when new elements are added, which is convenient when you don’t need strict control over memory management or performance optimizations.

On the other hand, custom arrays allow developers to control the internal behavior of the array-like data structures. Custom arrays can be implemented to fit specific performance, memory, or structural requirements that native arrays might not handle well. For instance, if you need a fixed-size array where resizing is not required, or you need a custom resizing mechanism, a custom array implementation would allow you to pre-allocate memory, control the resizing strategy, or even optimize access patterns to achieve constant-time operations.

One key benefit of custom arrays is that they give you direct control over how memory is allocated and how operations are performed. For example, if performance is crucial in a particular algorithm and native array methods introduce overhead, custom implementations can provide fine-tuned efficiency. Custom arrays can also be designed for more specialized use cases, such as circular buffers or sparse arrays, which are not supported natively in JavaScript.

Native arrays are generally faster in most common scenarios because they are implemented directly within the JavaScript engine, leveraging low-level optimizations. So, the decision to use one over the other depends largely on the specific needs of your application, especially in terms of performance and memory management.

---

Ultimately, custom array implementations deepen your understanding of both JavaScript and computer science principles, enhancing your ability to write more efficient, thoughtful code and empowering you with the knowledge to optimize solutions when native abstractions fall short.