Open In App

Common operations on various Data Structures

Last Updated : 27 Mar, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

Data Structure is the way of storing data in computer’s memory so that it can be used easily and efficiently. There are different data-structures used for the storage of data. It can also be defined as a mathematical or logical model of a particular organization of data items. The representation of particular data structure in the main memory of a computer is called as storage structure. 

For Examples: Array, Stack, Queue, Tree, Graph, etc.

Operations on different Data Structure: 
There are different types of operations that can be performed for the manipulation of data in every data structure. Some operations are explained and illustrated below: 

  • Traversing: Traversing a Data Structure means to visit the element stored in it. It visits data in a systematic manner. This can be done with any type of DS. 
    Below is the program to illustrate traversal in an array, stack, queue and linkedlist:

Array




// C++ program to traversal in an array
#include <iostream>
using namespace std;
 
// Driver Code
int main()
{
    // Initialise array
    int arr[] = { 1, 2, 3, 4 };
 
    // size of array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Traverse the element of arr[]
    for (int i = 0; i < N; i++) {
 
        // Print the element
        cout << arr[i] << ' ';
    }
 
    return 0;
}


Stack




// C++ program to traversal in an stack
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the element in stack
void printStack(stack<int>& St)
{
 
    // Traverse the stack
    while (!St.empty()) {
 
        // Print top element
        cout << St.top() << ' ';
 
        // Pop top element
        St.pop();
    }
}
 
// Driver Code
int main()
{
    // Initialise stack
    stack<int> St;
 
    // Insert Element in stack
    St.push(4);
    St.push(3);
    St.push(2);
    St.push(1);
 
    // Print elements in stack
    printStack(St);
    return 0;
}


Queue




// C++ program to traversal
// in an queue
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the
// element in queue
void printQueue(queue<int>& Q)
{
    // Traverse the stack
    while (!Q.empty()) {
 
        // Print top element
        cout << Q.front() << ' ';
 
        // Pop top element
        Q.pop();
    }
}
 
// Driver Code
int main()
{
    // Initialise queue
    queue<int> Q;
 
    // Insert element
    Q.push(1);
    Q.push(2);
    Q.push(3);
    Q.push(4);
 
    // Print elements
    printQueue(Q);
    return 0;
}


LinkedList




// C++ program to traverse the
// given linked list
#include <bits/stdc++.h>
using namespace std;
struct Node {
    int data;
    Node* next;
};
 
// Function that allocates a new
// node with given data
Node* newNode(int data)
{
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}
 
// Function to insert a new node
// at the end of linked list
Node* insertEnd(Node* head, int data)
{
    // If linked list is empty,
    // Create a new node
    if (head == NULL)
        return newNode(data);
 
    // If we have not reached the end
    // Keep traversing recursively
    else
        head->next = insertEnd(head->next, data);
    return head;
}
 
/// Function to traverse given LL
void traverse(Node* head)
{
    if (head == NULL)
        return;
 
    // If head is not NULL,
    // print current node and
    // recur for remaining list
    cout << head->data << " ";
 
    traverse(head->next);
}
 
// Driver Code
int main()
{
    // Given Linked List
    Node* head = NULL;
    head = insertEnd(head, 1);
    head = insertEnd(head, 2);
    head = insertEnd(head, 3);
    head = insertEnd(head, 4);
 
    // Function Call to traverse LL
    traverse(head);
}


Output

1 2 3 4 

Time Complexity: O(N)
Auxiliary Space: O(1)

Below is the program to illustrate traversal in an array:

C++




// C++ program to traversal in an array
#include <bits/stdc++.h>
using namespace std;
 
// Driver Code
int main()
{
    // Initialise array
    int arr[] = { 1, 2, 3, 4 };
 
    // size of array
    int N = sizeof(arr)/sizeof(arr[0]);
 
    // Traverse the element of arr[]
    for (int i = 0; i < N; i++) {
 
        // Print the element
        cout << arr[i] << " ";
    }
    return 0;
}
 
// This code is contributed by jana_sayantan.


Java




// Java program to traversal in an array
 
import java.util.*;
 
class GFG{
 
// Driver Code
public static void main(String[] args)
{
    // Initialise array
    int arr[] = { 1, 2, 3, 4 };
 
    // size of array
    int N = arr.length;
 
    // Traverse the element of arr[]
    for (int i = 0; i < N; i++) {
 
        // Print the element
        System.out.print(arr[i] + " ");
    }
 
}
}
 
// This code contributed by Rajput-Ji


Python3




# Python program to traversal in an array
 
# Driver Code
if __name__ == '__main__':
   
    # Initialise array
    arr = [ 1, 2, 3, 4 ];
 
    # size of array
    N = len(arr);
 
    # Traverse the element of arr
    for i in range(N):
 
        # Print element
        print(arr[i], end=" ");
     
# This code is contributed by Rajput-Ji


C#




// C# program to traversal in an array
 
using System;
 
public class GFG {
 
    // Driver Code
    public static void Main(String[] args) {
        // Initialise array
        int []arr = { 1, 2, 3, 4 };
 
        // size of array
        int N = arr.Length;
 
        // Traverse the element of []arr
        for (int i = 0; i < N; i++) {
 
            // Print the element
            Console.Write(arr[i] + " ");
        }
 
    }
}
 
 
 
// This code contributed by Rajput-Ji


Javascript




<script>
// javascript program to traversal in an array    // Driver Code
     
        // Initialise array
        var arr = [ 1, 2, 3, 4 ];
 
        // size of array
        var N = arr.length;
 
        // Traverse the element of arr
        for (i = 0; i < N; i++) {
 
            // Print the element
            document.write(arr[i] + " ");
        }
 
// This code is contributed by Rajput-Ji
</script>


Output

1 2 3 4 

Time Complexity: O(N)
Auxiliary Space: O(1)

Below is the program to illustrate traversal in a Stack:

C++




#include <iostream>
#include <stack>
using namespace std;
 
// Function to print the element in stack
void printStack(stack<int> St){
   
      // Traverse the stack
    while (!St.empty()) {
       
          // Print top element
        cout << St.top() <<" ";
       
          // Pop top element
        St.pop();
    }
}
 
int main() {
 
      // Initialise stack
    stack<int> St;
   
      // Insert Element in stack
    St.push(4);
    St.push(3);
    St.push(2);
    St.push(1);
   
      // Print elements in stack
    printStack(St);
       
    return 0;
}
 
// This code is contributed by lokesh.


Java




// Java program to traversal in an stack
 
import java.util.*;
 
class GFG{
 
// Function to print the element in stack
static void printStack(Stack<Integer> St)
{
 
    // Traverse the stack
    while (!St.isEmpty()) {
 
        // Print top element
        System.out.print(St.peek() +" ");
 
        // Pop top element
        St.pop();
    }
}
 
// Driver Code
public static void main(String[] args)
{
    // Initialise stack
    Stack<Integer> St = new Stack<>() ;
 
    // Insert Element in stack
    St.add(4);
    St.add(3);
    St.add(2);
    St.add(1);
 
    // Print elements in stack
    printStack(St);
}
}
 
// This code contributed by Rajput-Ji


Python3




# Function to print the element in stack
def print_stack(St):
    # Traverse the stack
    while St:
        # Print top element
        print(St.pop(), end=' ')
 
 
# Test function with sample input
St = []
St.append(4)
St.append(3)
St.append(2)
St.append(1)
print_stack(St)
# This code is contributed by Potta Lokesh


C#




// C# program to traversal in an stack
using System;
using System.Collections.Generic;
 
public class GFG {
 
  // Function to print the element in stack
  static void printStack(Stack<int> St) {
 
    // Traverse the stack
    while (St.Count != 0) {
 
      // Print top element
      Console.Write(St.Peek() + " ");
 
      // Pop top element
      St.Pop();
    }
  }
 
  // Driver Code
  public static void Main(String[] args)
  {
 
    // Initialise stack
    Stack<int> St = new Stack<int>();
 
    // Insert Element in stack
    St.Push(4);
    St.Push(3);
    St.Push(2);
    St.Push(1);
 
    // Print elements in stack
    printStack(St);
  }
}
 
// This code is contributed by Rajput-Ji


Javascript




<script>
// javascript program to traversal in an stack   
// Function to print the element in stack
    function printStack(St)
    {
 
        // Traverse the stack
        while (St.length != 0)
        {
 
            // Print top element
            document.write(St.pop() + " ");
 
        }
    }
 
    // Driver Code
     
        // Initialise stack
        var St = [];
 
        // Insert Element in stack
        St.push(4);
        St.push(3);
        St.push(2);
        St.push(1);
 
        // Print elements in stack
        printStack(St);
         
// This code is contributed by Rajput-Ji
</script>


Output

1 2 3 4 

Time Complexity: O(N)
Auxiliary Space: O(1)

  • Searching: Searching means to find a particular element in the given data-structure. It is considered as successful when the required element is found. Searching is the operation which we can performed on data-structures like array, linked-list, tree, graph, etc.
    Below is the program to illustrate searching an element in an array, stack, queue and linkedlist:
 

Array




// C++ program to searching in an array
#include <iostream>
using namespace std;
 
// Function that finds element K in the
// array
void findElement(int arr[], int N, int K)
{
 
    // Traverse the element of arr[]
    // to find element K
    for (int i = 0; i < N; i++) {
 
        // If Element is present then
        // print the index and return
        if (arr[i] == K) {
            cout << "Element found!";
            return;
        }
    }
 
    cout << "Element Not found!";
}
 
// Driver Code
int main()
{
    // Initialise array
    int arr[] = { 1, 2, 3, 4 };
 
    // Element to be found
    int K = 3;
 
    // size of array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    findElement(arr, N, K);
    return 0;
}


Stack




// C++ program to find element in stack
#include <bits/stdc++.h>
using namespace std;
 
// Function to find element in stack
void findElement(stack<int>& St, int K)
{
 
    // Traverse the stack
    while (!St.empty()) {
 
        // Check if top is K
        if (St.top() == K) {
            cout << "Element found!";
            return;
        }
 
        // Pop top element
        St.pop();
    }
 
    cout << "Element Not found!";
}
 
// Driver Code
int main()
{
    // Initialise stack
    stack<int> St;
 
    // Insert Element in stack
    St.push(4);
    St.push(3);
    St.push(2);
    St.push(1);
 
    // Element to be found
    int K = 3;
 
    // Function Call
    findElement(St, K);
    return 0;
}


Queue




// C++ program to find given element
// in an queue
#include <bits/stdc++.h>
using namespace std;
 
// Function to find element in queue
void findElement(queue<int>& Q, int K)
{
 
    // Traverse the stack
    while (!Q.empty()) {
 
        // Check if top is K
        if (Q.front() == K) {
            cout << "Element found!";
            return;
        }
 
        // Pop top element
        Q.pop();
    }
 
    cout << "Element Not found!";
}
 
// Driver Code
int main()
{
    // Initialise queue
    queue<int> Q;
 
    // Insert element
    Q.push(1);
    Q.push(2);
    Q.push(3);
    Q.push(4);
 
    // Element to be found
    int K = 3;
 
    // Print elements
    findElement(Q, K);
    return 0;
}


LinkedList




// C++ program to traverse the
// given linked list
#include <bits/stdc++.h>
using namespace std;
struct Node {
    int data;
    Node* next;
};
 
// Function that allocates a new
// node with given data
Node* newNode(int data)
{
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}
 
// Function to insert a new node
// at the end of linked list
Node* insertEnd(Node* head, int data)
{
    // If linked list is empty,
    // Create a new node
    if (head == NULL)
        return newNode(data);
 
    // If we have not reached the end
    // Keep traversing recursively
    else
        head->next = insertEnd(head->next, data);
    return head;
}
 
/// Function to traverse given LL
bool traverse(Node* head, int K)
{
    if (head == NULL)
        return false;
 
    // If node with value K is found
    // return true
    if (head->data == K)
        return true;
 
    return traverse(head->next, K);
}
 
// Driver Code
int main()
{
    // Given Linked List
    Node* head = NULL;
    head = insertEnd(head, 1);
    head = insertEnd(head, 2);
    head = insertEnd(head, 3);
    head = insertEnd(head, 4);
 
    // Element to be found
    int K = 3;
 
    // Function Call to traverse LL
    if (traverse(head, K)) {
        cout << "Element found!";
    }
    else {
        cout << "Element Not found!";
    }
}


Output

Element found!

Time Complexity: O(N)
Auxiliary Space: O(1)

  • Insertion: It is the operation which we apply on all the data-structures. Insertion means to add an element in the given data structure. The operation of insertion is successful when the required element is added to the required data-structure. It is unsuccessful in some cases when the size of the data structure is full and when there is no space in the data-structure to add any additional element. The insertion has the same name as an insertion in the data-structure as an array, linked-list, graph, tree. In stack, this operation is called Push. In the queue, this operation is called Enqueue.
    Below is the program to illustrate insertion in array, stack, queue and linkedlist :

Array




// C++ program for insertion in array
#include <iostream>
using namespace std;
 
// Function to print the array element
void printArray(int arr[], int N)
{
    // Traverse the element of arr[]
    for (int i = 0; i < N; i++) {
 
        // Print the element
        cout << arr[i] << ' ';
    }
}
 
// Driver Code
int main()
{
    // Initialise array
    int arr[4];
 
    // size of array
    int N = 4;
 
    // Insert elements in array
    for (int i = 1; i < 5; i++) {
        arr[i - 1] = i;
    }
 
    // Print array element
    printArray(arr, N);
    return 0;
}


Stack




// C++ program for insertion in array
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the element in stack
void printStack(stack<int>& St)
{
 
    // Traverse the stack
    while (!St.empty()) {
 
        // Print top element
        cout << St.top() << ' ';
 
        // Pop top element
        St.pop();
    }
}
 
// Driver Code
int main()
{
    // Initialise stack
    stack<int> St;
 
    // Insert Element in stack
    St.push(4);
    St.push(3);
    St.push(2);
    St.push(1);
 
    // Print elements in stack
    printStack(St);
    return 0;
}


Queue




// C++ program for insertion in queue
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the
// element in queue
void printQueue(queue<int>& Q)
{
    // Traverse the stack
    while (!Q.empty()) {
 
        // Print top element
        cout << Q.front() << ' ';
 
        // Pop top element
        Q.pop();
    }
}
 
// Driver Code
int main()
{
    // Initialise queue
    queue<int> Q;
 
    // Insert element
    Q.push(1);
    Q.push(2);
    Q.push(3);
    Q.push(4);
 
    // Print elements
    printQueue(Q);
    return 0;
}


LinkedList




// C++ program for insertion in LL
#include <bits/stdc++.h>
using namespace std;
struct Node {
    int data;
    Node* next;
};
 
// Function that allocates a new
// node with given data
Node* newNode(int data)
{
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}
 
// Function to insert a new node
// at the end of linked list
Node* insertEnd(Node* head, int data)
{
    // If linked list is empty,
    // Create a new node
    if (head == NULL)
        return newNode(data);
 
    // If we have not reached the end
    // Keep traversing recursively
    else
        head->next = insertEnd(head->next, data);
    return head;
}
 
/// Function to traverse given LL
void traverse(Node* head)
{
    if (head == NULL)
        return;
 
    // If head is not NULL,
    // print current node and
    // recur for remaining list
    cout << head->data << " ";
 
    traverse(head->next);
}
 
// Driver Code
int main()
{
    // Given Linked List
    Node* head = NULL;
    head = insertEnd(head, 1);
    head = insertEnd(head, 2);
    head = insertEnd(head, 3);
    head = insertEnd(head, 4);
 
    // Function Call to traverse LL
    traverse(head);
}


Output

1 2 3 4 

Time Complexity: O(N)
Auxiliary Space: O(1)

  • Deletion: It is the operation which we apply on all the data-structures. Deletion means to delete an element in the given data structure. The operation of deletion is successful when the required element is deleted from the data structure. The deletion has the same name as a deletion in the data-structure as an array, linked-list, graph, tree, etc. In stack, this operation is called Pop. In Queue this operation is called Dequeue.
    Below is the program to illustrate dequeue in Stack, Queue and Linkedlist:

Stack




// C++ program for insertion in array
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the element in stack
void printStack(stack<int> St)
{
    // Traverse the stack
    while (!St.empty()) {
 
        // Print top element
        cout << St.top() << ' ';
 
        // Pop top element
        St.pop();
    }
}
 
// Driver Code
int main()
{
    // Initialise stack
    stack<int> St;
 
    // Insert Element in stack
    St.push(4);
    St.push(3);
    St.push(2);
    St.push(1);
 
    // Print elements before pop
    // operation on stack
    printStack(St);
 
    cout << endl;
 
    // Pop the top element
    St.pop();
 
    // Print elements after pop
    // operation on stack
    printStack(St);
    return 0;
}


Queue




// C++ program to illustrate dequeue
// in queue
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the element
// of the queue
void printQueue(queue<int> myqueue)
{
    // Traverse the queue and print
    // element at the front of queue
    while (!myqueue.empty()) {
 
        // Print the first element
        cout << myqueue.front() << ' ';
 
        // Dequeue the element from the
        // front of the queue
        myqueue.pop();
    }
}
 
// Driver Code
int main()
{
    // Declare a queue
    queue<int> myqueue;
 
    // Insert element in queue from
    // 0 to 5
    for (int i = 1; i < 5; i++) {
 
        // Insert element at the
        // front of the queue
        myqueue.push(i);
    }
 
    // Print element beforepop
    // from queue
    printQueue(myqueue);
 
    cout << endl;
 
    // Pop the front element
    myqueue.pop();
 
    // Print element after pop
    // from queue
    printQueue(myqueue);
    return 0;
}


LinkedList




// C++ program for insertion in LL
#include <bits/stdc++.h>
using namespace std;
struct Node {
    int data;
    Node* next;
};
 
// Function that allocates a new
// node with given data
Node* newNode(int data)
{
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}
 
// Function to insert a new node
// at the end of linked list
Node* insertEnd(Node* head, int data)
{
    // If linked list is empty,
    // Create a new node
    if (head == NULL)
        return newNode(data);
 
    // If we have not reached the end
    // Keep traversing recursively
    else
        head->next = insertEnd(head->next, data);
    return head;
}
 
/// Function to traverse given LL
void traverse(Node* head)
{
    if (head == NULL)
        return;
 
    // If head is not NULL,
    // print current node and
    // recur for remaining list
    cout << head->data << " ";
 
    traverse(head->next);
}
 
// Driver Code
int main()
{
    // Given Linked List
    Node* head = NULL;
    head = insertEnd(head, 1);
    head = insertEnd(head, 2);
    head = insertEnd(head, 3);
    head = insertEnd(head, 4);
 
    // Print before deleting the first
    // element from LL
    traverse(head);
 
    // Move head pointer to forward
    // to remove the first element
 
    // If LL has more than 1 element
    if (head->next != NULL) {
        head = head->next;
    }
    else {
        head = NULL;
    }
 
    cout << endl;
 
    // Print after deleting the first
    // element from LL
    traverse(head);
}


Output

1 2 3 4 
2 3 4 

Time Complexity: O(N)
Auxiliary Space: O(1)

 Some other method :

Create: – 
It reserves memory for program elements by declaring them. The creation of data structure 
Can be done during 

  1. Compile-time
  2. Run-time. 

You can use malloc() function.
Selection:-
It selects specific data from present data. You can select any specific data by giving condition in loop .
Update
It updates the data in the data structure. You can also update any specific data by giving some condition in loop like select approach. 
Sort 
Sorting data in a particular order (ascending or descending).
We can take the help of many sorting algorithms to sort data in less time. Example: bubble sort which takes O(n^2)time to sort data. There are many algorithms present like merge sort, insertion sort, selection sort, quick sort, etc.
Merge
Merging data of two different orders in a specific order may ascend or descend. We use merge sort to merge sort data.

Split Data 
Dividing data into different sub-parts to make the process complete in less time.



Previous Article
Next Article

Similar Reads

Various operations on Fibonacci nodes in a Singly Linked list
Given a singly linked list containing N nodes, the task is to perform the following operations on the Fibonacci nodes present in it: Print all Fibonacci nodes present in the singly linked list.Find the total count of Fibonacci nodes present in the singly linked list.Find the minimum and the maximum Fibonacci nodes.Remove all the Fibonacci nodes fro
15+ min read
Complexity analysis of various operations of Binary Min Heap
A Min Heap is a Complete Binary Tree in which the children nodes have a higher value (lesser priority) than the parent nodes, i.e., any path from the root to the leaf nodes, has an ascending order of elements. In the case of a binary tree, the root is considered to be at height 0, its children nodes are considered to be at height 1, and so on. Each
3 min read
Menu driven program in C++ to perform various basic operations on array
Prerequisite: Switch Statement in C/C++, Functions in C/C++, Loops in C and C++, C/C++ do-while loop with Examples Write a menu-driven program to perform below various basic operations in the array: Print all the even values in the array.Print all the odd values in the array.Sum &amp; average of elements in the array.Find the maximum and minimum el
5 min read
Does a Data Scientist/Machine Learning Engineer require in depth knowledge of Data Structures and Algorithms?
In today's world, data scientists and machine learning engineers play a crucial role in analyzing data and building intelligent systems. As technology continues to advance, the demand for these experts is growing rapidly. Real-world data problems are complex, requiring strong skills in handling data and creating efficient algorithms. In this articl
10 min read
Number of triangles formed by joining vertices of n-sided polygon with two common sides and no common sides
Given N-sided polygon we need to find the total number of triangles formed by joining the vertices of the given polygon with exactly two sides being common and no side being common.Examples: Input : N = 6 Output : 6 2 The image below is of a triangle forming inside a Hexagon by joining vertices as shown above. The triangle formed has two sides (AB
5 min read
Print common nodes on path from root (or common ancestors)
Given a binary tree and two nodes, the task is to Print all the nodes that are common for 2 given nodes in a binary tree. Examples: Given binary tree is : 1 / \ 2 3 / \ / \ 4 5 6 7 / / \ 8 9 10 Given nodes 9 and 7, so the common nodes are:- 1, 3 Asked in : Amazon Find the LCA of given two nodes.Print all ancestors of the LCA as done in this post, a
11 min read
Role of SemiColon in various Programming Languages
Semicolon is a punctuation mark (;) indicating a pause, typically between two main clauses, that is more pronounced than that indicated by a comma. In programming, Semicolon symbol plays a vital role. It is used to show the termination of instruction in various programming languages as well, like C, C++, Java, JavaScript and Python. In this article
5 min read
Various load balancing techniques used in Hash table to ensure efficient access time
Load balancing refers to the process of distributing workloads evenly across multiple servers, nodes, or other resources to ensure optimal resource utilization, maximize output, minimize response time, and avoid overload of any single resource. Load balancing helps to improve the reliability and scalability of applications and systems, as well as r
3 min read
Data Structures | Linked List | Question 1
What does the following function do for a given Linked List with first node as head? void fun1(struct node* head) { if(head == NULL) return; fun1(head-&gt;next); printf(\"%d \", head-&gt;data); } (A) Prints all nodes of linked lists (B) Prints all nodes of linked list in reverse order (C) Prints alternate nodes of Linked List (D) Prints alternate n
2 min read
Data Structures | Stack | Question 1
Following is C like pseudo code of a function that takes a number as an argument, and uses a stack S to do processing. void fun(int n) { Stack S; // Say it creates an empty stack S while (n &gt; 0) { // This line pushes the value of n%2 to stack S push(&amp;S, n%2); n = n/2; } // Run while Stack S is not empty while (!isEmpty(&amp;S)) printf(&quot;
1 min read
three90RightbarBannerImg