13
DecOne dimensional Array in Data Structures with Example
One dimensional Array: An Overview
Data Structures and Algorithms (DSA) form the backbone of computer science, enabling efficient problem-solving and algorithmic design. In this DSA tutorial, we'll explore the concept of one-dimensional arrays, their characteristics, and their applications in DSA. You might have already come across arrays while learning arrays in C and arrays in C++.
To further enhance your understanding and application of array concepts, consider enrolling in the Best Data Structures and Algorithms Course, where you can gain comprehensive insights into effective data structure utilization for improved problem-solving and time management.
What is One dimensional Array in Data Structure?
A one-dimensional array is a linear data structure that stores elements of the same data type in contiguous memory locations. It provides a systematic way of organizing and accessing a collection of elements, where each element is identified by its index or position within the array. The index starts from 0 and goes up to the size of the array minus one.
One-dimensional arrays are useful and robust data formats that can be used for a variety of data storage and manipulation purposes. They are used in a variety of applications and are a necessary component of many C programs.
Syntax
The syntax for declaring and initializing a one-dimensional array in C is as follows:
data_type array_name[array_size] = value1, value2, value3,...;
- The arguments used in the preceding syntax are listed below.
- The data_type variable represents the data type of the array's items.
- array_name is the name of the array.
- array_size specifies how many elements the array can hold.
- The values of each array element are value1, value2, value3,...
Read More - DSA Interview Questions and Answers
Declaration and Initialization
In most programming languages, one-dimensional arrays can be declared and initialized as follows:
int myArray[5];
// Initialization
myArray[0] = 10;
myArray[1] = 20;
myArray[2] = 30;
myArray[3] = 40;
myArray[4] = 50;
Common Operations on One-Dimensional Arrays
1. Accessing Elements
Elements in a one-dimensional array are accessed using their respective indices. For example, myArray[2] would return the value 30.
Syntax
element = arrayName[index];
Example
For example, if we have an array named myArray and we want to access the element at index 2:
int value = myArray[2];
This line of code retrieves the value stored at index 2 in the array myArray. In this case, if myArray is {10, 20, 30, 40, 50}, the variable value would be assigned the value 30.
2. Insertion and Deletion
Inserting or deleting an element in a one-dimensional array may require shifting the subsequent elements accordingly to maintain the sequential order. The syntax for inserting and deleting elements is as follows:
Syntax
arrayName[index] = newElement;
Example
For example, if we have an array named myArray and we want to access the element at index 2:
myArray[2] = 25;
Deletion
Deletion involves shifting elements after the deleted element to fill the gap. In this example, let's delete the element at index 3:
// Deleting the element at position index
// Shift elements after the deleted index to fill the gap
for (int i = index; i < arraySize - 1; i++) {
arrayName[i] = arrayName[i + 1];
}
arraySize--; // Decrease the size of the array
3. Updating Elements
Elements in an array can be updated by assigning a new value to the desired index.
Syntax
arrayName[index] = newValue;
Example
For example, if we have an array named myArray and we want to access the element at index 2:
myArray[2] = 35;
4. Traversing
Traversing involves visiting each element of the array sequentially, allowing for various operations on each element. The syntax for traversing through an array using a loop is as follows:
Syntax
for (int i = 0; i < arraySize; i++) {
// Perform operations on array elements, e.g., print, modify, etc.
// Access array elements using arrayName[i]
}
Example
For example, to print all elements of the array myArray:
printf("Elements of the array:\n");
for (int i = 0; i < 5; i++) {
printf("%d ", myArray[i]);
}
printf("\n");
Example of One-Dimensional Array
Let's take a simple example in C to demonstrate the use of a one-dimensional array in DSA. In this example, we'll create an array of integers, initialize it, and perform basic operations like accessing elements and traversing the array.
# Declaration and Initialization of a One-Dimensional Array
myArray = [10, 20, 30, 40, 50]
# Accessing and Printing Elements
print("Elements of the array:")
for i in range(5):
print(myArray[i], end=" ")
print()
# Updating an Element
myArray[2] = 35
print("Updated array after changing the third element:")
for i in range(5):
print(myArray[i], end=" ")
print()
# Summing the Elements
sum_value = sum(myArray)
print("Sum of the elements:", sum_value)
public class OneDimensionalArrayExample {
public static void main(String[] args) {
// Declaration and Initialization of a One-Dimensional Array
int[] myArray = {10, 20, 30, 40, 50};
// Accessing and Printing Elements
System.out.println("Elements of the array:");
for (int i = 0; i < 5; i++) {
System.out.print(myArray[i] + " ");
}
System.out.println();
// Updating an Element
myArray[2] = 35;
System.out.println("Updated array after changing the third element:");
for (int i = 0; i < 5; i++) {
System.out.print(myArray[i] + " ");
}
System.out.println();
// Summing the Elements
int sum = 0;
for (int i = 0; i < 5; i++) {
sum += myArray[i];
}
System.out.println("Sum of the elements: " + sum);
}
}
#include
int main() {
// Declaration and Initialization of a One-Dimensional Array
int myArray[5] = {10, 20, 30, 40, 50};
// Accessing and Printing Elements
std::cout << "Elements of the array:" << std::endl;
for (int i = 0; i < 5; i++) {
std::cout << myArray[i] << " ";
}
std::cout << std::endl;
// Updating an Element
myArray[2] = 35;
std::cout << "Updated array after changing the third element:" << std::endl;
for (int i = 0; i < 5; i++) {
std::cout << myArray[i] << " ";
}
std::cout << std::endl;
// Summing the Elements
int sum = 0;
for (int i = 0; i < 5; i++) {
sum += myArray[i];
}
std::cout << "Sum of the elements: " << sum << std::endl;
return 0;
}
In this example, we declare and initialize an array myArray of size 5 with integer elements. We use a loop to print the elements of the array. Update the third element of the array and print the array after the update. Then calculate and print the sum of all elements in the array.
Output
Elements of the array:
10 20 30 40 50
Updated array after changing the third element:
10 20 35 40 50
Sum of the elements: 155
Applications in DSA
1. Linear Search
One-dimensional arrays are commonly used in linear search algorithms to find the position of a specific element in the array.
2. Sorting Algorithms
Sorting algorithms like bubble sort, insertion sort, and selection sort often rely on manipulating one-dimensional arrays to rearrange elements in ascending or descending order.
3. Dynamic Memory Allocation
One-dimensional arrays are crucial in dynamically allocating memory for structures like linked lists, stacks, and queues.
4. Mathematical and Scientific Applications
Arrays are extensively used to store and process data in mathematical and scientific computations, making them invaluable in fields like engineering and physics.
5. String Manipulation
>>> Read More:- Differences Between Array and Linked List |