Static vs Dynamic Allocation in DSA

Introduction

Memory allocation is one of the most important concepts in programming and Data Structures & Algorithms (DSA).

Whenever we create:

• Variables
• Arrays
• Objects
• Linked Lists
• Trees

memory is allocated inside RAM.

There are mainly two types of memory allocation:

1. Static Memory Allocation
2. Dynamic Memory Allocation

Although PHP automatically manages memory internally, understanding these concepts is very important for:

• DSA
• Backend Development
• Performance Optimization
• Interview Preparation
• Understanding Arrays & Objects

What is Memory Allocation?

Memory allocation means:

Reserving space in RAM to store data.

Example:

<?php

$name = "Himanshu";

?>

<?php

$name = "Himanshu";

?>

PHP allocates memory for variable $name.

Program Memory Structure

Types of Memory Allocation

1. Static Memory Allocation

Definition

Static allocation means:

Memory size is fixed before execution.

The memory requirement is already known.

Static Allocation Example in PHP

PHP internally handles memory dynamically, but fixed-size variables behave conceptually like static allocation.

<?php

$number = 10;

$name = "PHP";

?>

<?php

$number = 10;

$name = "PHP";

?>

Memory is allocated with fixed values.

Static Array Example

<?php

$marks = [10, 20, 30, 40, 50];

echo $marks[0];

?>

<?php

$marks = [10, 20, 30, 40, 50];

echo $marks[0];

?>

Here:

• Array size is predefined
• Data is fixed initially

Static Allocation Diagram

Characteristics of Static Allocation

Advantages of Static Allocation

1. Faster Access

Because memory structure is fixed.

<?php

$x = 100;

?>

<?php

$x = 100;

?>

2. Easy to Understand

No pointer management needed.

3. Better Performance

Less runtime overhead.

Disadvantages of Static Allocation

1. Fixed Size Problem

<?php

$data = [1,2,3];

?>

<?php

$data = [1,2,3];

?>

Initially fixed structure.

2. Memory Waste

Extra reserved memory may remain unused.

3. Less Flexible

Cannot efficiently handle unknown data size.

Real-Life Example

Imagine:

• A classroom with fixed 30 seats.
• Even if only 10 students come, all seats remain reserved.

This is static allocation.

2. Dynamic Memory Allocation

Definition

Dynamic allocation means:

Memory is allocated during runtime according to requirement.

PHP mostly works dynamically internally.

Dynamic Allocation Example

<?php

$students = [];

$students[] = "Rahul";
$students[] = "Aman";
$students[] = "Himanshu";

print_r($students);

?>

<?php

$students = [];

$students[] = "Rahul";
$students[] = "Aman";
$students[] = "Himanshu";

print_r($students);

?>

Here:

• Array size increases dynamically
• Memory grows automatically

Dynamic Allocation Diagram

Characteristics of Dynamic Allocation

Advantages of Dynamic Allocation

1. Flexible Memory Usage

<?php

$data = [];

for($i=1; $i<=100; $i++){
    $data[] = $i;
}

?>

<?php

$data = [];

for($i=1; $i<=100; $i++){
    $data[] = $i;
}

?>

Memory grows automatically.

2. Better Memory Utilization

Only required memory is allocated.

3. Essential for Advanced DSA

Used in:

• Linked Lists
• Trees
• Graphs
• Queues
• Stacks

Disadvantages of Dynamic Allocation

1. Slightly Slower

Because memory management happens during runtime.

2. More Memory Consumption

Dynamic structures may use extra metadata memory.

3. Complex Internally

PHP handles complexity automatically.

Real-Life Example

Imagine:

• Restaurant table arrangement changes according to customer count.

This is dynamic allocation.

Static vs Dynamic Allocation

Visual Comparison

Static Array vs Dynamic Array in PHP

Static Style Array

<?php

$numbers = [1,2,3,4,5];

?>

<?php

$numbers = [1,2,3,4,5];

?>

Fixed initial data.

Dynamic Style Array

<?php

$numbers = [];

for($i=1; $i<=10; $i++){
    $numbers[] = $i;
}

print_r($numbers);

?>

<?php

$numbers = [];

for($i=1; $i<=10; $i++){
    $numbers[] = $i;
}

print_r($numbers);

?>

Array grows dynamically.

Dynamic Allocation in DSA

PHP arrays are internally dynamic.

But advanced DSA structures are manually created using objects.

Linked List Example in PHP

<?php

class Node {

    public $data;
    public $next;

    function __construct($data){
        $this->data = $data;
        $this->next = null;
    }
}

$node1 = new Node(10);
$node2 = new Node(20);

$node1->next = $node2;

echo $node1->next->data;

?>

<?php

class Node {

    public $data;
    public $next;

    function __construct($data){
        $this->data = $data;
        $this->next = null;
    }
}

$node1 = new Node(10);
$node2 = new Node(20);

$node1->next = $node2;

echo $node1->next->data;

?>

Linked List Diagram

Stack Memory vs Heap Memory

Stack Memory

Stores:

• Function calls
• Local variables

Example:

<?php

function test(){

    $x = 10;

}

?>

<?php

function test(){

    $x = 10;

}

?>

Heap Memory

Stores:

• Objects
• Dynamic arrays

Example:

<?php

$obj = new stdClass();

?>

<?php

$obj = new stdClass();

?>

Stack vs Heap Diagram

Memory Management in PHP

PHP automatically handles:

• Memory allocation
• Memory deallocation
• Garbage collection

This means:

• No malloc()
• No free()
• No new/delete like C++

Garbage Collection in PHP

PHP removes unused memory automatically.

Example:

<?php

$data = [1,2,3];

unset($data);

?>

<?php

$data = [1,2,3];

unset($data);

?>

unset() releases variable reference.

Real DSA Structures Using Dynamic Allocation

Interview Questions

Q1. Does PHP support dynamic memory allocation?

Yes, PHP internally uses dynamic memory allocation.

Q2. Why are PHP arrays dynamic?

Because memory size automatically increases during runtime.

Q3. What is heap memory?

Memory used for dynamic objects and structures.

Q4. What is garbage collection?

Automatic cleanup of unused memory.

Performance Tip

Large dynamic arrays consume more memory.

Example:

<?php

$data = range(1,1000000);

?>

<?php

$data = range(1,1000000);

?>

This may use huge RAM.

Best Practices

Use Static Style When:

• Data size is fixed
• Small arrays
• Better performance needed

Use Dynamic Style When:

• Data size unknown
• User-generated data
• Complex DSA structures

Complete Example

Static Allocation Style

<?php

$marks = [10,20,30];

foreach($marks as $mark){
    echo $mark."<br>";
}

?>

<?php

$marks = [10,20,30];

foreach($marks as $mark){
    echo $mark."<br>";
}

?>

Dynamic Allocation Style

<?php
$marks = [];
for($i=1; $i<=5; $i++){
 $marks[] = $i * 10;
}
foreach($marks as $mark){
    echo $mark."<br>";
}
?>

<?php
$marks = [];
for($i=1; $i<=5; $i++){
 $marks[] = $i * 10;
}
foreach($marks as $mark){
    echo $mark."<br>";
}
?>

Output

10
20
30
40
50

10
20
30
40
50

Final Conclusion

In PHP:

• Most memory handling is dynamic internally.
• Arrays and objects use dynamic memory.
• DSA structures depend heavily on dynamic allocation.

Understanding these concepts helps in:

• Writing optimized PHP code
• Building scalable systems
• Learning advanced DSA
• Improving interview preparation

Quick Revision

Static Style

$data = [1,2,3];

$data = [1,2,3];

Dynamic Style

$data[] = 10;

$data[] = 10;

Practice Questions

1. What is memory allocation?
2. Difference between static and dynamic allocation?
3. Why are PHP arrays dynamic?
4. What is heap memory?
5. What is garbage collection?
6. Why linked lists use dynamic allocation?

Mini Exercise

Task 1

Create a fixed array:

$numbers = [1,2,3,4,5];

$numbers = [1,2,3,4,5];

Task 2

Create a dynamic array using loop:

$numbers = [];
for($i=1; $i<=10; $i++){
    $numbers[] = $i;
}

$numbers = [];
for($i=1; $i<=10; $i++){
    $numbers[] = $i;
}