# What Are the Operations Performed on Data Structure?

//

Angela Bailey

Data structures are fundamental components in computer science that allow us to efficiently store and manipulate data. There are several operations that can be performed on data structures to modify, access, and analyze the stored data. In this article, we will explore some of the most common operations performed on data structures and understand their significance.

## Accessing Elements

One of the basic operations performed on a data structure is accessing its elements. This operation allows us to retrieve specific values from the data structure for further processing or analysis. The way elements are accessed depends on the type of data structure being used.

### Array

In an array, elements are accessed using their index. The index represents the position of an element within the array starting from 0. For example:

```int[] numbers = {1, 2, 3, 4};
int secondNumber = numbers; // Accessing the second element (index 1)
```

In a linked list, elements are accessed by traversing through the list starting from the head or tail node until reaching the desired position. Each node contains a reference to the next node in the list.

```Node current = head;
int count = 0;
while(count < index) {
current = current.next;
count++;
}
Data desiredData = current.data; // Accessing data at specified index
```

## Insertion and Deletion of Elements

Data structures also support operations for inserting new elements into their collection or deleting existing ones.

### List-Based Data Structures (Array, Linked List)

In list-based data structures like arrays and linked lists, insertion and deletion operations involve manipulating the links between elements. For example, to insert an element at a specific position in a linked list:

```Node newNode = new Node(data);
int count = 0;
while(count < index - 1) {
current = current.next;
count++;
}
newNode.next = current.next;
current.next = newNode; // Inserting the new node
```

### Tree-Based Data Structures (Binary Tree)

In tree-based data structures like binary trees, insertion and deletion operations involve rearranging the structure of the tree to maintain its properties. For example, to insert a new element into a binary tree:

```TreeNode newNode = new TreeNode(data);
TreeNode current = root;
while(true) {
// Comparing values to determine which child to traverse next
If (data < current.data) {
// Go left

if (current.left == null) {
current.left = newNode;
break;
} else {
current = current.left;
}
} else {
// Go right
if (current.right == null) {
current.right = newNode;
break;
} else {
current = current.right;
}
}
}
```

## List Operations: Searching and Sorting

Searching and sorting are essential operations performed on list-based data structures to find specific elements or arrange them in a particular order.

### Linear Search

Linear search is a simple searching algorithm that checks each element in the list sequentially until a match is found. It can be used with arrays or linked lists.

```for(int i = 0; i < numbers.length; i++) {
if(numbers[i] == Target) {
// Element found

break;
}
}
```

### Sorting: Bubble Sort

Bubble sort is a popular sorting algorithm that repeatedly compares adjacent elements and swaps them if they are in the wrong order. This process is repeated until the entire list is sorted.length – 1; i++) {

for(int j = 0; j < numbers.length – i – 1; j++) {

If (numbers[j] > numbers[j+1]) {
// Swap elements

int temp = numbers[j];
numbers[j] = numbers[j+1];
numbers[j+1] = temp;
}
}
}

The operations mentioned above are just a glimpse into the vast world of data structures. Understanding these operations and their implementation is crucial for building efficient algorithms and solving real-world problems effectively.