Data Modelling & AI Data Structure & Algorithm

How do Dynamic arrays work?

20 June 2025

0

A Dynamic array (vector in C++, ArrayList in Java) automatically grows when we try to make an insertion and there is no more space left for the new item. Usually the area doubles in size. A simple dynamic array can be constructed by allocating an array of fixed-size, typically larger than the number of elements immediately required. The elements of the dynamic array are stored contiguously at the start of the underlying array, and the remaining positions towards the end of the underlying array are reserved, or unused. Elements can be added at the end of a dynamic array in constant time by using the reserved space until this space is completely consumed. When all space is consumed, and an additional element is to be added, the underlying fixed-sized array needs to be increased in size. Typically resizing is expensive because you have to allocate a bigger array and copy over all of the elements from the array you have overgrow before we can finally append our item.

Approach: When we enter an element in array but array is full then you create a function, this function creates a new array double size or as you wish and copy all element from the previous array to a new array and return this new array. Also, we can reduce the size of the array. and add an element at a given position, remove the element at the end default and at the position also.

Key Features of Dynamic Array

Add Element: Add element at the end if the array size is not enough then extend the size of the array and add an element at the end of the original array as well as given index. Doing all that copying takes O(n) time, where n is the number of elements in our array. That’s an expensive cost for an append. In a fixed-length array, appends only take O(1) time. But appends take O(n) time only when we insert into a full array. And that is pretty rare, especially if we double the size of the array every time we run out of space. So in most cases appending is still O(1) time, and sometimes it’s O(n) time. In dynamic array you can create fixed-size array when required added some more element in array then use this approach:

Delete Element: Delete an element from array, default remove() method delete an element from end, simply store zero at last index and you also delete element at specific index by calling removeAt(i) method where i is index. removeAt(i) method shift all right element in the left side from the given index.

Resize of Array Size: When the array has null/zero data (aside from an element added by you) at the right side of the array, meaning it has unused memory, the method shrinkSize() can free up the extra memory. When all space is consumed, and an additional element is to be added, then the underlying fixed-size array needs to increase in size. Typically resizing is expensive because you have to allocate a bigger array and copy over all of the elements from the array you have outgrown before we can finally append our item.

Simple code for dynamic array. In below code then the array will become full of size we copy all element to new double size array(variable size array).sample code is below

C++

#include <iostream>
using namespace std;
 
class DynamicArray {
private:
    // Pointer to store array created
    // using new keyword
    int* array = NULL;
    // Size of array
    int size;
 
    // Container size
    int capacity;
 
public:
    // Default constructor with size 1
    DynamicArray()
    {
        capacity = 1;
        size = 0;
        array = new int[capacity];
    }
 
    // Taking size from the user
    DynamicArray(int capacity)
    {
        this->capacity = capacity;
        array = new int[capacity];
        size = 0;
    }
 
    // Returns the size of Array
    // i.e Total elements stored currently
    int getSize() { return size; }
 
    // Returns the size of container
    int getCapacity() { return capacity; }
 
    // Inserting element after last stored index
    void push_back(int value)
    {
        // check is array having size to store element or
        // not
        if (size == capacity) {
 
            // if not then grow the array by double
            growArray();
        }
 
        // insert element
        array[size] = value;
        // increment the size or last_index+1
        size++;
    }
 
    // Deleting element at last stored index
    void pop_back()
    {
        // Replace the last index by 0
        array[size - 1] = 0;
 
        // Decrement the array size
        size--;
 
        // Reduce if the container half element of its
        // capacity
        if (size == (capacity / 2)) {
            shrinkArray();
        }
    }
 
    // Increase the array size by double of current capacity
    void growArray()
    {
 
        // Creating new array of double size
        int* temp = new int[capacity * 2];
 
        capacity = capacity * 2;
        // copy element of old array in newly created array
        for (int i = 0; i < size; i++) {
            temp[i] = array[i];
        }
 
        // Delete old array
        delete[] array;
 
        // Assign newly created temp array to original array
        array = temp;
    }
 
    // Reduce the size of array by half
    void shrinkArray()
    {
 
        // Creating new array of half size
        capacity = size;
        int* temp = new int[capacity];
 
        // copy element of old array in newly created array
        for (int i = 0; i < size; i++) {
            temp[i] = array[i];
        }
 
        // Delete old array
        delete[] array;
 
        // Assign newly created temp array to original array
        array = temp;
    }
 
    // Searching element in the given array
    int search(int key)
    {
        for (int i = 0; i < size; i++) {
            if (array[i] == key) {
                // If element found return its index
                return i;
            }
        }
 
        // Return -1 if element not found;
        return -1;
    }
 
    // Insert element at given index
    void insertAt(int index, int value)
    {
        // check is array having size to store element or
        // not
        if (size == capacity) {
 
            // if not then grow the array by double
            growArray();
        }
 
        for (int i = size - 1; i >= index; i--) {
            array[i + 1] = array[i];
        }
 
        array[index] = value;
        size++;
    }
 
    // Delete element at given index
    void deleteAt(int index)
    {
        for (int i = index; i < size; i++) {
            array[i] = array[i + 1];
        }
 
        // Replace the last index by 0
        array[size - 1] = 0;
 
        // Decrement the array size
        size--;
 
        // Reduce if the container half element of its
        // capacity
        if (size == (capacity / 2)) {
            shrinkArray();
        }
    }
 
    // To Print Array
    void printArrayDetails()
    {
        cout << "Elements of array : ";
        for (int i = 0; i < size; i++) {
            cout << array[i] << " ";
        }
        cout << endl;
        cout << "No of elements in array : " << size
             << ", Capacity of array :" << capacity << endl;
    }
 
    bool isEmpty()
    {
        if (size == 0) {
            return true;
        }
        else {
            return false;
        }
    }
};
 
int main()
{
    DynamicArray da;
 
    da.push_back(1);
    da.push_back(2);
    da.push_back(3);
    da.push_back(4);
    da.push_back(5);
    da.push_back(6);
    da.push_back(7);
    da.push_back(8);
    da.push_back(9);
    da.push_back(10);
    da.push_back(11);
 
    da.printArrayDetails();
 
    da.shrinkArray();
    cout << "\nCapacity of array  after shrinking : "
         << da.getCapacity() << endl;
 
    cout << "\nAfter inserting at index 3 " << endl;
    da.insertAt(3, 50);
    da.printArrayDetails();
 
    cout << "\nAfter delete last element ";
    da.pop_back();
    da.printArrayDetails();
 
    cout << "\nAfter deleting at index 3 ";
    da.deleteAt(3);
    da.printArrayDetails();
 
    cout << "\nSearching 5 in array ";
    int index = da.search(5);
    if (index != -1) {
        cout << "Element found at index : " << index << endl;
    }
    else {
        cout << "Element not found " << endl;
    }
    return 0;
}
 
// This code is contributed by Aniket Tiwari

Java

// Java program deals with all operation of a dynamic array
// add, remove, resize memory of array is the main feature
public class DynamicArray {
 
    // create three variable array[] is a array,
    // count will deal with no of element add by you and
    // size will with size of array[]
    private int array[];
    private int count;
    private int size;
    // constructor initialize value to variable
 
    public DynamicArray()
    {
        array = new int[1];
        count = 0;
        size = 1;
    }
    // function add an element at the end of array
 
    public void add(int data)
    {
 
        // check no of element is equal to size of array
        if (count == size) {
            growSize(); // make array size double
        } // insert element at end of array
        array[count] = data;
        count++;
    }
 
    // function makes size double of array
    public void growSize()
    {
 
        int temp[] = null;
        if (count == size) {
 
            // temp is a double size array of array
            // and store array elements
            temp = new int[size * 2];
            {
                for (int i = 0; i < size; i++) {
                    // copy all array value into temp
                    temp[i] = array[i];
                }
            }
        }
 
        // double size array temp initialize
        // into variable array again
        array = temp;
 
        // and make size is double also of array
        size = size * 2;
    }
 
    // function shrink size of array
    // which block unnecessary remove them
    public void shrinkSize()
    {
        int temp[] = null;
        if (count > 0) {
 
            // temp is a count size array
            // and store array elements
            temp = new int[count];
            for (int i = 0; i < count; i++) {
 
                // copy all array value into temp
                temp[i] = array[i];
            }
 
            size = count;
 
            // count size array temp initialize
            // into variable array again
            array = temp;
        }
    }
    // function add an element at given index
 
    public void addAt(int index, int data)
    {
        // if size is not enough make size double
        if (count == size) {
            growSize();
        }
 
        for (int i = count - 1; i >= index; i--) {
 
            // shift all element right
            // from given index
            array[i + 1] = array[i];
        }
 
        // insert data at given index
        array[index] = data;
        count++;
    }
 
    // function remove last element or put
    // zero at last index
    public void remove()
    {
        if (count > 0) {
            array[count - 1] = 0;
            count--;
        }
    }
 
    // function shift all element of right
    // side from given index in left
    public void removeAt(int index)
    {
        if (count > 0) {
            for (int i = index; i < count - 1; i++) {
 
                // shift all element of right
                // side from given index in left
                array[i] = array[i + 1];
            }
            array[count - 1] = 0;
            count--;
        }
    }
 
    public static void main(String[] args)
    {
        DynamicArray da = new DynamicArray();
 
        // add 9 elements in array
        da.add(1);
        da.add(2);
        da.add(3);
        da.add(4);
        da.add(5);
        da.add(6);
        da.add(7);
        da.add(8);
        da.add(9);
 
        // print all array elements after add 9 elements
        System.out.println("Elements of array:");
        for (int i = 0; i < da.size; i++) {
            System.out.print(da.array[i] + " ");
        }
 
        System.out.println();
 
        // print size of array and no of element
        System.out.println("Size of array: " + da.size);
        System.out.println("No of elements in array: "
                           + da.count);
 
        // shrinkSize of array
        da.shrinkSize();
 
        // print all array elements
        System.out.println("Elements of array "
                           + "after shrinkSize of array:");
        for (int i = 0; i < da.size; i++) {
            System.out.print(da.array[i] + " ");
        }
        System.out.println();
 
        // print size of array and no of element
        System.out.println("Size of array: " + da.size);
        System.out.println("No of elements in array: "
                           + da.count);
 
        // add an element at index 1
        da.addAt(1, 22);
 
        // print Elements of array after adding an
        // element at index 1
        System.out.println("Elements of array after"
                           + " add an element at index 1:");
        for (int i = 0; i < da.size; i++) {
            System.out.print(da.array[i] + " ");
        }
 
        System.out.println();
 
        // print size of array and no of element
        System.out.println("Size of array: " + da.size);
        System.out.println("No of elements in array: "
                           + da.count);
 
        // delete last element
        da.remove();
 
        // print Elements of array after delete last
        // element
        System.out.println("Elements of array after"
                           + " delete last element:");
        for (int i = 0; i < da.size; i++) {
            System.out.print(da.array[i] + " ");
        }
 
        System.out.println();
 
        // print size of array and no of element
        System.out.println("Size of array: " + da.size);
        System.out.println("No of elements in array: "
                           + da.count);
 
        // delete element at index 1
        da.removeAt(1);
 
        // print Elements of array after delete
        // an element index 1
        System.out.println("Elements of array after"
                           + " delete element at index 1:");
        for (int i = 0; i < da.size; i++) {
            System.out.print(da.array[i] + " ");
        }
        System.out.println();
 
        // print size of array and no of element
        System.out.println("Size of array: " + da.size);
        System.out.println("No of elements in array: "
                           + da.count);
    }
}

Python3

# Python 3 program deals with all operation of a dynamic array
# add, remove, resize memory of array is the main feature
 
 
class DynamicArray:
 
    # create three variable array[] is a array,
    # count will deal with no of element add by you and
    # size will with size of array[]
    array = None
    count = 0
    size = 0
 
    # constructor initialize value to variable
    def __init__(self):
        self.array = [0] * (1)
        self.count = 0
        self.size = 1
 
    # function add an element at the end of array
    def add(self, data):
 
        # check no of element is equal to size of array
        if (self.count == self.size):
            self.growSize()
 
        # insert element at end of array
        self.array[self.count] = data
        self.count += 1
 
    # function makes size double of array
    def growSize(self):
        temp = None
        if (self.count == self.size):
 
            # temp is a double size array of array
            # and store array elements
            temp = [0] * (self.size * 2)
            i = 0
            while (i < self.size):
 
                # copy all array value into temp
                temp[i] = self.array[i]
                i += 1
 
        # double size array temp initialize
        # into variable array again
        self.array = temp
 
        # and make size is double also of array
        self.size = self.size * 2
 
    # function shrink size of array
    # which block unnecessary remove them
    def shrinkSize(self):
        temp = None
        if (self.count > 0):
 
            # temp is a count size array
            # and store array elements
            temp = [0] * (self.count)
            i = 0
            while (i < self.count):
 
                # copy all array value into temp
                temp[i] = self.array[i]
                i += 1
            self.size = self.count
 
            # count size array temp initialize
            # into variable array again
            self.array = temp
 
    # function add an element at given index
    def addAt(self, index,  data):
 
        # if size is not enough make size double
        if (self.count == self.size):
            self.growSize()
        i = self.count - 1
        while (i >= index):
 
            # shift all element right
            # from given index
            self.array[i + 1] = self.array[i]
            i -= 1
 
        # insert data at given index
        self.array[index] = data
        self.count += 1
 
    # function remove last element or put
    # zero at last index
    def remove(self):
        if (self.count > 0):
            self.array[self.count - 1] = 0
            self.count -= 1
    # function shift all element of right
    # side from given index in left
 
    def removeAt(self, index):
        if (self.count > 0):
            i = index
            while (i < self.count - 1):
 
                # shift all element of right
                # side from given index in left
                self.array[i] = self.array[i + 1]
                i += 1
            self.array[self.count - 1] = 0
            self.count -= 1
 
    @staticmethod
    def main(args):
        da = DynamicArray()
 
        # add 9 elements in array
        da.add(1)
        da.add(2)
        da.add(3)
        da.add(4)
        da.add(5)
        da.add(6)
        da.add(7)
        da.add(8)
        da.add(9)
 
        # print all array elements after add 9 elements
        print("Elements of array:")
        i = 0
        while (i < da.size):
            print(str(da.array[i]) + " ", end="")
            i += 1
        print()
 
        # print size of array and no of element
        print("Size of array: " + str(da.size))
        print("No of elements in array: " + str(da.count))
 
        # shrinkSize of array
        da.shrinkSize()
 
        # print all array elements
        print("Elements of array after shrinkSize of array:")
        i = 0
        while (i < da.size):
            print(str(da.array[i]) + " ", end="")
            i += 1
        print()
 
        # print size of array and no of element
        print("Size of array: " + str(da.size))
        print("No of elements in array: " + str(da.count))
 
        # add an element at index 1
        da.addAt(1, 22)
 
        # print Elements of array after adding an
        # element at index 1
        print("Elements of array after add an element at index 1:")
        i = 0
        while (i < da.size):
            print(str(da.array[i]) + " ", end="")
            i += 1
        print()
 
        # print size of array and no of element
        print("Size of array: " + str(da.size))
        print("No of elements in array: " + str(da.count))
 
        # delete last element
        da.remove()
 
        # print Elements of array after delete last
        # element
        print("Elements of array after delete last element:")
        i = 0
        while (i < da.size):
            print(str(da.array[i]) + " ", end="")
            i += 1
        print()
 
        # print size of array and no of element
        print("Size of array: " + str(da.size))
        print("No of elements in array: " + str(da.count))
 
        # delete element at index 1
        da.removeAt(1)
 
        # print Elements of array after delete
        # an element index 1
        print("Elements of array after delete element at index 1:")
        i = 0
        while (i < da.size):
            print(str(da.array[i]) + " ", end="")
            i += 1
        print()
 
        # print size of array and no of element
        print("Size of array: " + str(da.size))
        print("No of elements in array: " + str(da.count))
 
 
# Driver code
if __name__ == "__main__":
    DynamicArray.main([])
 
    # This code is contributed by aadityaburujwale.

C#

// C# program deals with all operation
// of dynamic array add, remove, resize
// memory of array is the main feature
using System;
 
public class DynamicArray {
 
    // create three variable array[] is
    // a array, count will deal with no
    // of element add by you and
    // size will with size of array[]
    private int[] array;
    private int count;
    private int size;
 
    // constructor initialize value to variable
    public DynamicArray()
    {
        array = new int[1];
        count = 0;
        size = 1;
    }
 
    // function add an element at the end of array
    public void add(int data)
    {
 
        // check no of element is equal to size of array
        if (count == size) {
            growSize(); // make array size double
        }
 
        // insert element at end of array
        array[count] = data;
        count++;
    }
 
    // function makes size double of array
    public void growSize()
    {
 
        int[] temp = null;
        if (count == size) {
 
            // temp is a double size array of array
            // and store array elements
            temp = new int[size * 2];
            {
                for (int i = 0; i < size; i++) {
                    // copy all array value into temp
                    temp[i] = array[i];
                }
            }
        }
 
        // double size array temp initialize
        // into variable array again
        array = temp;
 
        // and make size is double also of array
        size = size * 2;
    }
 
    // function shrink size of array
    // which block unnecessary remove them
    public void shrinkSize()
    {
        int[] temp = null;
        if (count > 0) {
 
            // temp is a count size array
            // and store array elements
            temp = new int[count];
            for (int i = 0; i < count; i++) {
 
                // copy all array value into temp
                temp[i] = array[i];
            }
 
            size = count;
 
            // count size array temp initialize
            // into variable array again
            array = temp;
        }
    }
 
    // function add an element at given index
    public void addAt(int index, int data)
    {
        // if size is not enough make size double
        if (count == size) {
            growSize();
        }
 
        for (int i = count - 1; i >= index; i--) {
 
            // shift all element right
            // from given index
            array[i + 1] = array[i];
        }
 
        // insert data at given index
        array[index] = data;
        count++;
    }
 
    // function remove last element or put
    // zero at last index
    public void remove()
    {
        if (count > 0) {
            array[count - 1] = 0;
            count--;
        }
    }
 
    // function shift all element of right
    // side from given index in left
    public void removeAt(int index)
    {
        if (count > 0) {
            for (int i = index; i < count - 1; i++) {
 
                // shift all element of right
                // side from given index in left
                array[i] = array[i + 1];
            }
            array[count - 1] = 0;
            count--;
        }
    }
 
    // Driver code
    public static void Main()
    {
        DynamicArray da = new DynamicArray();
 
        // add 9 elements in array
        da.add(1);
        da.add(2);
        da.add(3);
        da.add(4);
        da.add(5);
        da.add(6);
        da.add(7);
        da.add(8);
        da.add(9);
 
        // print all array elements after add 9 elements
        Console.WriteLine("Elements of array:");
        for (int i = 0; i < da.size; i++) {
            Console.Write(da.array[i] + " ");
        }
 
        Console.WriteLine();
 
        // print size of array and no of element
        Console.WriteLine("Size of array: " + da.size);
        Console.WriteLine("No of elements in array: "
                          + da.count);
 
        // shrinkSize of array
        da.shrinkSize();
 
        // print all array elements
        Console.WriteLine("Elements of array "
                          + "after shrinkSize of array:");
        for (int i = 0; i < da.size; i++) {
            Console.Write(da.array[i] + " ");
        }
        Console.WriteLine();
 
        // print size of array and no of element
        Console.WriteLine("Size of array: " + da.size);
        Console.WriteLine("No of elements in array: "
                          + da.count);
 
        // add an element at index 1
        da.addAt(1, 22);
 
        // print Elements of array after adding an
        // element at index 1
        Console.WriteLine("Elements of array after"
                          + " add an element at index 1:");
        for (int i = 0; i < da.size; i++) {
            Console.Write(da.array[i] + " ");
        }
 
        Console.WriteLine();
 
        // print size of array and no of element
        Console.WriteLine("Size of array: " + da.size);
        Console.WriteLine("No of elements in array: "
                          + da.count);
 
        // delete last element
        da.remove();
 
        // print Elements of array after delete last
        // element
        Console.WriteLine("Elements of array after"
                          + " delete last element:");
        for (int i = 0; i < da.size; i++) {
            Console.Write(da.array[i] + " ");
        }
 
        Console.WriteLine();
 
        // print size of array and no of element
        Console.WriteLine("Size of array: " + da.size);
        Console.WriteLine("No of elements in array: "
                          + da.count);
 
        // delete element at index 1
        da.removeAt(1);
 
        // print Elements of array after delete
        // an element index 1
        Console.WriteLine("Elements of array after"
                          + " delete element at index 1:");
        for (int i = 0; i < da.size; i++) {
            Console.Write(da.array[i] + " ");
        }
        Console.WriteLine();
 
        // print size of array and no of element
        Console.WriteLine("Size of array: " + da.size);
        Console.WriteLine("No of elements in array: "
                          + da.count);
    }
}
 
/* This code contributed by PrinciRaj1992 */

Javascript

class DynamicArray {
    // Pointer to store array created using new keyword
    #array;
    // Size of array
    #size;
    // Container size
    #capacity;
 
    // Default constructor with size 1
    constructor() {
        this.#capacity = 1;
        this.#size = 0;
        this.#array = new Array(this.#capacity);
    }
 
    // Taking size from the user
    // constructor(capacity) {
    // this.#capacity = capacity;
    // this.#array = new Array(this.#capacity);
    // this.#size = 0;
    // }
 
    // Returns the size of Array i.e Total elements stored currently
    getSize() {
        return this.#size;
    }
 
    // Returns the size of container
    getCapacity() {
        return this.#capacity;
    }
 
    // Inserting element after last stored index
    push_back(value) {
        // check is array having size to store element or not
        if (this.#size == this.#capacity) {
            // if not then grow the array by double
            this.growArray();
        }
        // insert element
        this.#array[this.#size] = value;
        // increment the size or last_index+1
        this.#size++;
    }
 
    // Deleting element at last stored index
    pop_back() {
        // Replace the last index by 0
        this.#array[this.#size - 1] = 0;
        // Decrement the array size
        this.#size--;
        // Reduce if the container half element of its capacity
        if (this.#size == Math.floor(this.#capacity / 2)) {
            this.shrinkArray();
        }
    }
 
    // Increase the array size by double of current capacity
    growArray() {
        // Creating new array of double size
        let temp = new Array(this.#capacity * 2);
        this.#capacity = this.#capacity * 2;
        // copy element of old array in newly created array
        for (let i = 0; i < this.#size; i++) {
            temp[i] = this.#array[i];
        }
        // Delete old array
        this.#array = null;
        // Assign newly created temp array to original array
        this.#array = temp;
    }
 
    // Reduce the size of array by half
    shrinkArray() {
        // Creating new array of half size
        this.#capacity = this.#size;
        let temp = new Array(this.#capacity);
        // copy element of old array in newly created array
        for (let i = 0; i < this.#size; i++) {
            temp[i] = this.#array[i];
        }
        // Delete old array
        this.#array = null;
        // Assign newly created temp array to original array
        this.#array = temp;
    }
 
    // Searching element in the given array
    search(key) {
        for (let i = 0; i < this.#size; i++) {
            if (this.#array[i] == key) {
                // If element found return its index
                return i;
            }
        }
        // Return -1 if element not found;
        return -1;
    }
 
    // Insert element at given index
    insertAt(index, value) {
        // check is array having size to store element or not
        if (this.#size == this.#capacity) {
            // if not then grow the array by double
            this.growArray();
        }
        for (let i = this.#size - 1; i >= index; i--) {
            this.#array[i + 1] = this.#array[i];
        }
        this.#array[index] = value;
        this.#size++;
    }
 
    // Delete element at given index
    // Delete element at given index
    deleteAt(index) {
        for (let i = index; i < this.#size; i++) {
            this.#array[i] = this.#array[i + 1];
        }
 
        // Replace the last index by 0
        this.#array[this.#size - 1] = 0;
 
        // Decrement the array size
        this.#size--;
 
        // Reduce if the container half element of its
        // capacity
        if (this.#size == (this.#capacity / 2)) {
            shrinkArray();
        }
    }
 
    // To Print Array
    printArrayDetails() {
        console.log("Elements of array : ");
        console.log(this.#array);
        console.log("No of elements in array : ", this.#size
            , ", Capacity of array :", this.#capacity);
    }
 
    isEmpty() {
        if (size == 0) {
            return true;
        }
        else {
            return false;
        }
    }
};
 
const da = new DynamicArray();
 
da.push_back(1);
da.push_back(2);
da.push_back(3);
da.push_back(4);
da.push_back(5);
da.push_back(6);
da.push_back(7);
da.push_back(8);
da.push_back(9);
da.push_back(10);
da.push_back(11);
 
da.printArrayDetails();
 
da.shrinkArray();
console.log("\nCapacity of array  after shrinking : "
    , da.getCapacity());
 
console.log("\nAfter inserting at index 3 ");
da.insertAt(3, 50);
da.printArrayDetails();
 
console.log("\nAfter delete last element ");
da.pop_back();
da.printArrayDetails();
 
console.log("\nAfter deleting at index 3 ");
da.deleteAt(3);
da.printArrayDetails();
 
console.log("\nSearching 5 in array ");
let index = da.search(5);
if (index >= 0) {
    console.log("Element found at index : ", index);
}
else {
    console.log("Element not found ");
}
 
// This code is contributed by akashish__

Output

Elements of array : 1 2 3 4 5 6 7 8 9 10 11 
No of elements in array : 11, Capacity of array :16

Capacity of array  after shrinking : 11

After inserting at index 3 
Elements of array : 1 2 3 50 4 5 6 7 8 9 10 11 
No of elements in array : 12, Capacity of array :22

After delete last element Elements of array : 1 2 3 50 4 5 6 7 8 9 10 
No of elements in array : 11, Capacity of array :11

After deleting at index 3 Elements of array : 1 2 3 4 5 6 7 8 9 10 
No of elements in array : 10, Capacity of array :11

Searching 5 in array Element found at index : 4

Recommended

Solve DSA problems on GfG Practice.

Solve Problems

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

1 COMMENT

Introduction to Arrays – Data Structure and Algorithm Tutorials – Neveropen Tech 26 July 2025 At 11:03 pm

[…] Is it possible to create dynamic array? […]

Log in to leave a comment

How do Dynamic arrays work?

Key Features of Dynamic Array

C++

Java

Python3

C#

Javascript

LangExtract + Milvus: A Practical Guide to Building a Hybrid Document Processing and Search System

Stop Your AI Assistant from Writing Outdated Code with Milvus SDK Code Helper

A Practical Guide for Choosing the Right Vector Database for Your AI Applications

1 COMMENT

LEAVE A REPLY Cancel reply

Most Popular

It’s your last chance to score a $50 Samsung credit before tomorrow’s big product announcement

The Samsung Health app now puts a licensed doctor right in your pocket

Google’s NotebookLM is giving Audio Overviews new personalities

MediaTek’s next flagship chip may give future Android phones faster cores and a beefed-up NPU

EDITOR PICKS

It’s your last chance to score a $50 Samsung credit before tomorrow’s big product announcement

The Samsung Health app now puts a licensed doctor right in your pocket

Google’s NotebookLM is giving Audio Overviews new personalities

POPULAR POSTS

It’s your last chance to score a $50 Samsung credit before tomorrow’s big product announcement

The Samsung Health app now puts a licensed doctor right in your pocket

Google’s NotebookLM is giving Audio Overviews new personalities

POPULAR CATEGORY

ABOUT US

FOLLOW US