GeeksforGeeks App
Open App
Browser
Continue

# How do Dynamic arrays work?

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 ``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```

My Personal Notes arrow_drop_up