What is Static Data Structure?
Static data structures are characterized by their fixed size and predefined memory allocation. This means that the amount of memory allocated to the structure is determined at compile time and remains constant throughout the program’s execution. Examples of static data structures include arrays .
Features of Static Data Structures:
There are many features of static data structures. Let’s discuss the most popular of them:
- Memory Allocation: For static data structures, static memory is allocated at the compile time by the compiler, which is stored in the stack memory of the program.
- Memory Deallocation: Memory allocated to the static data structures deallocates when they go out of scope or the program ends.
- Continuous Memory Allocation: As we have discussed above, continuous memory is allocated to the static data structures, which means there is no need to store the structural information of the data structure or explicit data variable to store the information of the memory location.
Advantages of Static Data Structures:
- Static data structures have a fixed size and structure, making them simpler to implement and understand.
- Since the size is known in advance, the memory can be allocated efficiently.
- The behavior of static data structures is more predictable, making them suitable for real-time systems.
- Accessing elements in static data structures is generally faster than in dynamic data structures.
Disadvantages of Static Data Structures:
- The size and structure of static data structures are fixed, which can lead to inefficient memory usage if the data requirements change.
- Static data structures have a predefined size, limiting their ability to handle large and varying amounts of data.
- If the data size is smaller than the allocated memory, the unused memory is wasted.
- Expanding the size of a static data structure requires complex procedures, such as creating a new, larger structure and copying the data.
Examples of Static Data Structures:
Array : An array is a collection of elements identified by index or key values. The size of the array is specified at the time of creation and remains constant. For example, an array of integers can be declared as int arr[8]; in C++, which creates an array of size 8.
Note: Problem with above Array implementation: Once we create the Array we cannot alter the size of the array. So the size of the array is unalterable
Implementation:
#include <iostream>
using namespace std;
int main()
{
// Declaration of an array of size 6
int array[6];
// initialize and printing values of array elements
for (int i = 0; i < 6; i++) {
array[i] = i;
cout << array[i] << " ";
}
cout << endl;
return 0;
}
public class Main {
public static void main(String[] args)
{
// Declaration of an array of size 6
int[] array = new int[6];
// initialize and printing values of array elements
for (int i = 0; i < 6; i++) {
array[i] = i;
System.out.print(array[i] + " ");
}
System.out.println();
}
}
def main():
# Declaration of a list of size 6
array = [0] * 6
# initialize and printing values of array elements
for i in range(6):
array[i] = i
print(array[i], end=" ")
print()
if __name__ == "__main__":
main()
function main() {
// Declaration of an array of size 6
let array = new Array(6);
// Initialize and print values of array elements
for (let i = 0; i < 6; i++) {
array[i] = i;
process.stdout.write(array[i] + " ");
}
console.log();
}
// Call the main function to execute the code
main();
Output
0 1 2 3 4 5
In the above code: we declared an array of the fixed size. After that, we initialize some value using a loop and printed them.
Static and Dynamic Data Structures
Data structures are the fundamental building blocks of computer programming. They determine how data is organized, stored, and manipulated within a software application. There are two main categories of data structures: static and dynamic. Static data structures have a fixed size and are allocated in memory during compile-time, while dynamic data structures can grow and shrink in size during runtime. This article will provide an overview of the key differences between static and dynamic data structures, their use cases, and the trade-offs to consider when choosing between them.
Table of Content
- What is Static Data structure?
- Features of Static Data Structures
- Advantages of Static Data Structures
- Disadvantages of Static Data Structures
- Examples of Static Data Structures
- What is Dynamic Data Structure?
- Features of Dynamic Data Structures
- Advantages of Dynamic Data Structures
- Disadvantages of Dynamic Data Structures
- Examples of Dynamic Data Structures
- Difference between Static and Dynamic Data Structure