Dynamic Arrays: Implementation and Applications

Dynamic Arrays
1. Definition
A dynamic array is an array whose size can be adjusted during runtime, allowing it
to grow or shrink as needed. Unlike static arrays, dynamic arrays manage memory
efficiently and allow elements to be added or removed without needing to know
the size in advance.

Key Characteristics:

 Resizable: Dynamic arrays can expand when more space is needed.
 Contiguous Memory: They maintain the property of contiguous memory
allocation, just like static arrays.
 Automatic Resizing: When the array is full, it resizes itself (usually doubling
the size) to accommodate more elements.
 Flexible: You don't need to specify the size upfront, and it adjusts
dynamically as elements are added or removed.



2. Dynamic Arrays in Different Languages
 C/C++: In C and C++, the concept of dynamic arrays is achieved using
pointers and memory allocation functions like malloc, calloc, or realloc. For
dynamic arrays, the C++ vector class is commonly used.

Example (C using malloc):

int *arr = malloc(5 * sizeof(int)); // Dynamically allocating space for 5
integers.
arr[0] = 10; // Access and modify elements.
free(arr); // Freeing the dynamically allocated memory.

Example (C++ using vector):

#include <vector>
std::vector<int> arr;

, arr.push_back(10); // Adds 10 to the end of the array.
arr.push_back(20);

 Java: In Java, arrays are fixed in size, but you can use the ArrayList class to
create a dynamic array. The ArrayList class resizes automatically as
elements are added or removed.

Example (Java using ArrayList):

import java.util.ArrayList;
ArrayList<Integer> arr = new ArrayList<>();
arr.add(10); // Adds 10 to the dynamic array.
arr.add(20);

 Python: Python uses lists, which are dynamic arrays under the hood. They
can grow or shrink as needed, and they store elements of any type.

Example (Python using list):

arr = []
arr.append(10) # Adds 10 to the list.
arr.append(20)

 JavaScript: JavaScript arrays are dynamic and can grow or shrink as needed.
They are often implemented as objects internally.

Example (JavaScript):

let arr = [];
arr.push(10); // Adds 10 to the array.
arr.push(20);



3. How Dynamic Arrays Work
Dynamic arrays work by using a resizable block of memory to hold the array
elements. Initially, when the array is created, it may have a fixed size (e.g., 4 or 8