Advantages and Disadvantages of Linked List Over Array

Linked Lists and arrays are both the most useful data structures. Both have advantages and disadvantages; it completely depends on the situation in which data structure will be best to use by comparing their time and space complexity.

Data Structure

The way of arranging and storing the data so that it is easy to access is called Data Structure. It serves as a container to store values in an efficient and manageable way.

Classification of Data Structure:

Advantages and Disadvantages of Linked List Over Array

1. Primitive: These are the basic data structures used to derive other data structures. For example, int, float, String, etc.

2. Non-Primitive: These data structures are derived from primitive data structures. Non- Primitive data structures are categorized into two types:

Linear: Linear data structures have a linear and simple structure. Linear is further divided into two sub-types:
- Static: Array
- Dynamic: Linked List, stack, queue.
Non-Linear: Non-Linear data structures have a complex structure. For example, Tree and Graph.

The following operations help differentiate and find the advantages and disadvantages of the two data structures.

Traversing: The process of accessing each element/value in the data structure is called Traversing.
Searching: Finding where an element/value is located in the data structure is called searching.
Inserting: Inserting is the process of adding a new value to the data structure.
Deleting: The process of removing a value from the structure and freeing the space is called deleting.
Merging: The process of joining two sets of values together is called merging.
Sorting: The process of arranging the values according to a particular sequence is called searching. Example: Numerically, Alphabetically, etc.

Array

The array is a type of data structure used to contiguously store different values in the memory. Arrays have a limited number of elements restricted by their size, which can be set while defining an array.

A sample structure of an array is shown below:

Indexing starts from 0 onwards.

Types of Array

1. One Dimensional Array

It is the simplest form of an array.

For example,

Int arr[5] = {15,34,78,23,56};

2. Two-Dimensional Array

Generally, a two-dimensional array is a collection of one-dimensional arrays as an element. We can define a two-dimensional integer array with dimensions m x n and use it later in the code. We can create a 2-D array by giving the two values of rows and columns in the two-square brackets.

For example,

int arr[2][2]= {{2,6}, {6,2}};

You can assume it is a 2x2 matrix.

3. Multidimensional Array

The array containing multiple dimensions is called a multidimensional array. We can create a 3-D array by giving the three values of three coordinates in the three-square brackets.

For example,

int arr[2][6][4];

Insertion: Inserting an element in the array at a specified position. It is beneficial to use an array for insertion at the last position if the space is free. Insertion in between or at the very first position in the array takes time and space. So we must not use an array for this type of insertion.

Code for insertion in the array

#include <iostream>
#include <stdlib.h>
using namespace std;
//insert element at the ith index of an array.
int insert(int arr[], int i, int val, int s){
           if(i>s){
                       return -1;
//index out of size.
                                   }
                                   
           else{
                       for(int j =(s-1); j>=i ; j--){
                       arr[j+1]=arr[j];
           }
           arr[i]=val;
           return arr[i];
           }
           
}

int main(){
           
           cout << "enter the size of the array" << endl;
           int n;
           cin >> n;
           int arr[n];
           int s= sizeof(arr);
           int i, val, b;
           cout << "enter the index" << endl;
           cin >> i;
           cout << "enter the value" << endl;
           cin >> val;
           for(int i=0; i<n; i++){
                       cout << "enter the " << i << " the element ";
                                               cin >> arr[i];                          
                       } 
           
            b=insrt( arr, i, val,s);
            cout << b;
           
           return 0;
}

Deletion: Deleting an element from an array. For deletion, we must shift other elements, which is time-consuming.

Int p;
Int n; //size of array
Int arr[5]={8,5,0,2,23}
Cout<< "enter the position of the element to be deleted:"
Cin >> p;
for(int i= p-1; i<n; i++){
           arr[i]= arr[i+1];
}

n--; 

Searching: Search for an element in the given array. Searching in a sorted array is advisable rather than an unsorted array. Because the worst case of searching is the element at the last position, we must traverse the full array to reach the last position.

Binary Search: In this searching algorithm, we always aim to reach the middle element by dividing the structure into two equal parts with the help of variables middle, low, and high. The values of high, middle, and low change in every division. The necessary condition to apply/use the Binary Search algorithm is that: The Data Structure should be sorted. If not, we must sort it.

int binary search(int arr[], int s, int e){  
           int l,h,m;
           l=0;
           h=s-1;
           m=(l+h)/2;
           
           while(l<=h){
           if(arr[m]==e){
                       return m;
           }
           
           else if(arr[m]<e){
                       l=m+1;
           }
           
           else{
                       h=m-1;
           }
   
}
return -1;      
                       
}

int main(){
           int arr[]={23,36,48,69,70,245,299,658};
           int e=69;
           int s= sizeof(arr)/sizeof(int);
           int x=binarysearch(arr,s,e);
           cout << "element found at index" << x;
           
           return 0;
}

Sorting: Arranging the values in a logical order.

#include<iostream>
using namespace std;
void slctnSort(int a[], int s) {
   int m, i, j, temp;
   for (i = 0; i < s - 1; i++) {
      m = i;
      for (j = i + 1; j < s; j++)
      if (a[j] < a[m])
      m = j;
      temp = a[i];
      a[i] = a[m];
      a[m] = temp;
   }
}
int main() {
   int a[] = { 55,78,32,67,87,43,3,4,90,99 };
   int s = sizeof(a)/ sizeof(a[0]);
   int i;
  
cout<<"original array is:"<<endl;
   for (i = 0; i < s; i++)
   cout<< a[i] <<" ";
  
cout<<endl;
   slctnSort(a, s);
   cout<< "Sorted array is: "<<endl;
   for (i = 0; i < s; i++)
   cout<< a[i] <<" ";
   return 0;
}

Linked List

A linked List is also one among the linear data structures. A simple linked list structure contains the data section and the next section. The nodes are stored randomly in the primary memory space and are not necessarily contiguous. This is the main benefit of the Linked List, as it helps in better memory management. The data section stores the actual value/data. The next section stores the address of the next node.

A sample structure of a linked list is shown below:

Types of Linked Lists

1. Singly-Linked List: It is a very simple type of Linked List with a linear structure with a data section and a next section.

For Example:

2. Doubly Linked List: Doubly linked list contains one extra part than the singly linked list, that is, the previous section along with data and the next.

For Example:

Code:

class Node{
           public:
                       int data;
                       Node* next;
                       Node* prev;
                       
                       Node(int d){
                                   data=d;
                                   next=NULL;
                                   prev=NULL;
                       }
           
};

void insertAthead(Node* &head, int d){
           Node* temp = new Node(d);
           temp->next=head;
           head->prev=temp;
           head=temp;
           
}

void insertAttail(Node* &tail, int d){
           Node* temp= new Node(d);
           tail->next=temp;
           temp->prev=tail;
           tail=temp;
}

void insertAtposition(Node* &head, int position, int p){
                       Node* n1=new Node(p);
                       Node* temp = head;
                       int count=1;
           if(position==1){
                                   insertAthead(head, p);
           }
           
           else{

                       while(count<position -1){
                       temp=temp->next;
                       count++;
           }
           n1->next=temp->next;
           temp->next->prev=n1;
           temp->next=n1;
           n1->prev=temp;
                       
           }
}

void deletell(Node* &head, int position){
           Node* temp= head;
           if(position==1){
                       head=head->next;

           }
           else{
                       temp->next=temp->next->next;
           }
}

printll(Node* &head){
           Node* temp = head;
           while(temp!=NULL){
                       cout << temp->data << " ";
                       temp=temp->next;
           }
           cout << endl;
           
}

int main(){
           Node* n= new Node(73);
           int d, t, p, position;
           Node* head=n;
           Node* tail=n;
           cout << "enter the element to be added at head:";
           cin >>d;
           
           cout << "enter the element to be added at tail:";
           cin >>t;
           
           cout << "enter the element to be added anywhere:";
           cin >>p;
           
           cout << "enter the position:";
           cin >>position;
           
           insertAthead(head, d);
           insertAttail(tail, t);
           insertAtposition(head, position, p);
           cout <<"before deletion" << endl;
           printll(head);
           deletell(head,position);
           cout <<"after deletion" << endl;
           printll(head);
           
           
           return 0;
}

3. Circular Linked List: Circular linked List is a linked list that does not have any predefined starting and end. You can start from any node. We can say that a circular linked List is a singly linked list in which the next of the last node is pointing to the first node or head.

For Example:

Code:

class Node{
           public:
                       int data;
                       Node* next;
                       
                       Node(){}
                       
                       Node(int val){
                                   data=val;
                                   next=NULL;
                       }
};

void insertAthead(Node* &head, int val){
           Node* temp=new Node(val);
           temp->next=head;
           head=temp;
}

void sortll(Node* head){
           Node* temp=head;
           
           if(temp>=temp->next){
                       
           }          
}

void printll(Node* &head){
           Node* temp =head;
           while(temp!=NULL){
                       cout << temp->data << " ";
                       temp=temp->next;
           }
           cout << endl;
}

int main(){
           Node* n1= new Node(10);
           Node* head= n1;
           int d1, d2, d3, d4, d5;
           cout << "enter values:" << endl;
           cin >> d1;
           cin >> d2;
           cin >> d3;
           cin >> d4;
           cin >> d5;
           
           insertAthead(head, d1);
           insertAthead(head, d2);
           insertAthead(head, d3);
           insertAthead(head, d4);
           insertAthead(head, d5);
           
           printll(head);

                       
           return 0;
}

4. Circular Doubly Linked List: It is a combination of a circular linked List and a doubly linked List.

Let us understand it with an example:

Sorting a Linked List

Compare the data of the first node with the data present in each node. If the data of the first node is greater than the data of other nodes, swap the data of the first node and the data of other nodes. After iteration 1, the first node is sorted. Continue the same process for the second node to the last node.

Code:

void sort(node* head){
 struct node* I, *j; 
int temp;
for(i=start; i->next!=null; i=i->next){
    for(j=start; j->next!=null; j=j->next){
           If(i-> data > j->data){
temp=i->data;
i->data = j-> data;
j->data=temp;}
}
}

Sorting through insertion sort:

Code:

void insert sorted(node* head, int val){
node* temp = new node(val);
if(head==null || head->data >val){
temp-> next=head;
head=temp;}
node* p=head;
while(p->next!=null && p->next->data<val)
p=p->next= head->next;
head->next=temp;}

Insertion in a Linked List

  class Node{
           public:
                       int data;
                       Node* next;
                       
                       Node(){}
                       
                       Node(int val){
                                   data=val;
                                   next=NULL;
                       }
};

void insertAthead(Node* &head, int val){
           Node* temp=new Node(val);
           temp->next=head;
           head=temp;
}

void printll(Node* &head){
           Node* temp =head;
           while(temp!=NULL){
                       cout << temp->data << " ";
                       temp=temp->next;
           }
           cout << endl;
}

int main(){
           Node* n= new Node(10);
           int d1,d2,d3,position;
           cout << "enter the elements to be entered." << endl;
           cin >> d1;
           cin >> d2;
           cin >> d3;
           Node* head =n;
           Node* tail=n;
           insertAthead(head, d1);
           insertAthead(head, d2);
           insertAthead(head, d3);
           cout << "values inserted";
           printll(head);
           cout << "enter position to be deleted." << endl;
           cin >> position;
            deletell(head, position);
                       printll(head);
                       
           return 0;
}

Deletion in linked List

void delete(Node* &head,int position){

           Node * temp =head;
           int count=1;
           
           if(position==1){
                       head=head->next;
                       delete temp;
           }

           
           while(count<position -1){
                       temp=temp->next;
                       count++;
           }
           temp->next=temp->next->next;
           
}

Searching for the Data in a Linked List

#include <stdio.h>
using namespace std;

class Node
{
           public:
           int data;
           Node* next;
};

void push(Node** head_p, int val)
{
           Node* new_node = new Node();

           new_node->data = val;

           new_node->next = (*head_p);

           (*head_p) = new_node;
}

bool search(Node* head, int x)
{
           Node* current = head;
           while (current != NULL)
           {
                       if (current->data == x)
                                   return true;
                       current = current->next;
           }
           return false;
}

int main()
{
           Node* head = NULL;
           int x = 30;
           bool answer;
           push(&head, 10);
           push(&head, 20);
           push(&head, 30);
           push(&head, 40);
           push(&head, 50);

           answer=search(head, 30);
           if(answer is true){
cout<< ?element found?<<endl;}
else{
cout << ?element not found?<<endl;}
           return 0;
}

Applications of Linked List

Used in implementing various other data structures like stack, queue, and graph. A real-life example based on the linked List is a rail-bogie system, in which bogies can be inserted anywhere in the chain.

Advantages and Disadvantages of Linked List

Advantages of Linked List

Linked List provides the facility to insert and remove nodes dynamically. Users can increase and decrease the size of a linked list by inserting a node either in the last or in the starting, or in between the linked List and by deleting a node, respectively, according to their requirements.
Linked List follows an efficient memory allocation of node (data). In the linked list format of storing the data, the nodes are not stored in a contiguous way like in an array; rather, nodes are stored at random memory locations. This reduces memory wastage. We need not predefine the size of the linked List.
Linked List provides an easy way the implementation of various data structures like a queue, graph, and stack.
The operations of deletion and insertion are very optimal in the case of Linked List. Unlike in an array, we need not shift or change the positions of an existing node, and we can insert and delete a node in between the linked List at any position. Shifting of elements/nodes is a very time-consuming process.
The best advantage of Linked List comes into action while dealing with a huge amount of data and when data is non-static. i.e., changes with time; as storage of Linked List nodes does not take place in a regular/continuous manner, we can store any node anywhere.

Disadvantages of linked List

In the linked List, two sections of a single node are the data storing part and the next part to store the address of another node. So, to store even a single node, we need more space than storing an element in the array.
To reach a particular node, we need to traverse the nodes present before it; hence traversing in the linked List is a time taking process. For example, in the given linked List, if we intend to access ten, then there is no direct way to 12, and we vNeed to visit all nodes before 12, i.e., 2,4,6,8, and then we can reach 12.

We cannot directly access a specific node in the Linked List because of the absence of an index approach.
Traversing in reverse order is not possible in a singly linked list, but it is possible in a doubly linked list since the previous pointer is present to traverse backward.
Using a linked List as a data structure is not suggestible for storing and sharing a small amount of data.
Understanding the overall implementation of the Linked List is not easy as it includes the concepts of classes, constructors, objects, and even struct. A novice cannot directly go with a linked List without understanding these concepts.

Advantages and Disadvantages of the Array

Advantages of Array

Array data structures have a simple implementation.
Accessing elements in the array is very easy compared to the linked List. There is directed access to the element through indexing.
The array implements other data structures like a queue, stack, etc.

Disadvantages of Array

Data stored in the array takes place in a static manner, which means that we cannot change the size of the array at run time as in the linked List.
We must exceed the number of stored elements in the array. For example, if the array's length is five, then we cannot store more than five elements in the array.
We must specify the type of elements to be stored in the array as the type of array. For example, if we wish to store integer type of elements in the array, then we should define the array as an integer type, and the same for other data types like String, char, etc.
Elements are stored in contiguous memory locations; hence there is no free space in between to add new elements. If there is free space in the array and we wish to insert an element between the array, then we have to push other elements to create a space at that particular location, which is very time-consuming.
Memory wastage takes place in the case if we acquire less memory than reserved. For example, if we declared an array of length 100 and stored 40 elements only in it.

One Can Prefer Linked List Over the Array in Below Mentioned Cases

When you do not know the total number of elements to be processed, this is because, in the array, we must predefine the size and length of an array, which should be followed during the whole code unless changed at the root (where declaration takes place).
When elements could increase or decrease during run time.
When the probability of insertion and deletion at the end or in the beginning position is more, just like in the implementation of stack and queue, a linked List is always preferred over the array. As we have discussed earlier, we must push the elements to add a new element in the array.

Next TopicAdvantages and Disadvantages of Mean, Median, and Mode

← prev next →