Linked List in Data structure (Introduction)

What are Linked List in Data Structure?

A linked list is a linear data structure. In which we can store the data in a sequence manner. unlike array linked list is dynamic data structure the size of a linked list can grow or shrink depending on the situation.

The element of a linked list is called a node. Every element or node contains two main entities first entity is the information or the data whereas the second entity is the pointer to the next node.

TCS NQT Registration Steps Large

More Information

The structure of the linked list is like a train. A linked list has the following components –

  • Data: Data is the value stored in it, it could be anything an integer or a string or anything else really.
  • Pointer (Link) – Each linked list contains a pointer which points to address of the next node in the linked list train.

Apart from this the following are also keywords used in linked lists –

  • Node – Any single unit of a linked list, its data and pointer(s), is called a node.
  • Head: First is the head who is defined the beginning of the list.
  • Tail: second is tail which defined end of the list.
linked list

Why we use Linked List in Data Structure?

Generally for storage arrays are used. But, there are many many disadvantaged with arrays –

Fixed Size

  • The size of the array is fixed and needs to be pre-defined
    • Example – int a[10]; or int a[ ] = {1, 2, 3, 4, 5}
    • We can’t declare an array without declaring the size.

Memory wastage (Not Optimised)

  • If you declare an array of size 10 and just assign values to first two elements
  • The memory is allocated to all of them even though, we may not end up using them.

Need for Contiguous Memory

  • Arrays need Contiguous memory, which some times is bad.
    • Example – Consider there are only three memories of size 10, 10 and 400
    • We need to store an array of size 15
    • In this case, the array will use memory location is size 400 and not combine memory A and B of size 10 and 10 respectively.
    • Thus wasting a lot of memory

Inserting in Array is expensive

  • Let us say you have an array a[] = {10, 20, 40, 60, 80} and we need to add 50 in a same sorted format.
  • Then, we have to move all elements after 40 to one additional position
  • Also, same goes for deletion if we want to delete 20. Then all elements after it have to be moved to one position in the opposite direction.

Linked Lists

Advantages

Disadvantages

  • We have to search elements linearly, and can’t do random access
  • We can’t do efficient searches like binary search
  • Extra space for pointers is needed
  • Linked lists are not cache friendly as arrays are stored in contigious format they can be cached easily
  • Loss of data threat is there, if we lose one pointer location the rest of linked list can’t be accessed.

Types of Linked link

There are three types of linked list, that are mentioned in following ways-

  1. Singly linked list
  2. Doubly linked list
  3. Circular linked list
linked list1

Singly-linked list

In a singly list there is the two field on the list.

  • Data: First field is data that it stores
  • Link (pointer): Link that refers to address of the next linked list node.
  • The last node of linked lits points to NULL and means end of the list

In a Singly linked list node, it only contains the address of the next node and not the previous node, so we can only traverse in one direction only. 

struct Node {
int data;
struct Node* next;
};
class Node {
public:
int data;
Node* next;
};
class LinkedList {
Node head; // head

/* Linked list Node*/
class Node {
int data;
Node next;

// For creating new node a Constructor
// Next is by default initialized
// as null
Node(int d) { data = d; }
}
}
# Node class
class Node:

# Function to initialize the node object
def __init__(self, data):
self.data = data # Assign data
self.next = None # Initialize
# next as null

# Linked List class
class LinkedList:

# Function to initialize the Linked
# List object
def __init__(self):
self.head = None

Program to Create a Singly List

Here we will construct a linked list with 4 elements as follows –

//We are creating program for linked list creation
#include <stdio.h>
#include <stdlib.h>
//stdlib used to provide a declaration of ‘malloc’

// structure of linked list
struct Node {
int data;
struct Node* next;
// Pointer pointing towards next node
};

//function to print the linked list
void display(struct Node* node)
{
while (node != NULL) {
printf(" %d ", node->data);
node = node->next;
}
}

// main function
int main()
{
//creating 4 pointers of type struct Node
//So these can point to address of struct type variable

struct Node* head = NULL;
struct Node* node2 = NULL;
struct Node* node3 = NULL;
struct Node* node4 = NULL;

// allocate 3 nodes in the heap
head = (struct Node*)malloc(sizeof(struct Node));
node2 = (struct Node*)malloc(sizeof(struct Node));
node3 = (struct Node*)malloc(sizeof(struct Node));
node4 = (struct Node*)malloc(sizeof(struct Node));

/* Using malloc method we have created 4 memory blocks
Each memory block is of type struct and has int data and Pointer of type Node
So it can point towards a node type struct.

head node2 node3 node4
| | | |
| | | |
+---+-----+ +----+----+ +----+----+ +----+----+
|data|next| |data|next| |data|next| |data|next|
+---+-----+ +----+----+ +----+----+ +----+----+

# As of now data has garbage value and its pointer
points towards random addresses*/

head->data = 5; // data set for head node
head->next = node2; // next pointer assigned to address of node2

node2->data = 10;
node2->next = node3;

node3->data = 12;
node3->next = node4;

node4->data = 3;
node4->next = NULL;
//last node assigned to Null as linked list ends here

/* Finally linked list looks like

head node2 node3 node4
| | | |
| | | |
+---+-----+ +----+----+ +----+----+ +----+----+
| 5 | next|---->| 10 | next|--->|12 | next|---->| 3 | next| ---> NULL
+---+-----+ +----+----+ +----+----+ +----+----+

*/

display(head);

return 0;
}
linked list2

Doubly linked list

A doubly linked list is a kind of complex linked list, in which it contains the address of the previous node as well as the next node. A doubly linked list contains the following –

  • Data: The data present in the node.
  • Link (Previous) – A pointer to the previous node in the linked list.
  • Link (Next) – A pointer to the next node in the linked list

In this way, for a doubly-linked list we can travel in both directions for traversals.

linked list 6

Circular linked list

 

  • This is a type of linked list in which the last node points to the starting node.
  • There is no null at the end.
  • A circular linked list can be a singly circular linked list and doubly circular linked list.
  •  In Circular linked list there exist no nodes which have null at address space.
Linked Lists in java meme

4 comments on “Linked List in Data structure (Introduction)”