How is linked list implemented nodes structure referential structure?

Self Referential Structures

Self Referential structures are those structures that have one or more pointers which point to the same type of structure, as their member.

Table of Contents Show

Self Referential Structures
Linked List Data Structure
Linked list Data Structure
Linked List in A Data Structure: All You Need to Know
Table of Contents
What is a Linked List?

In other words, structures pointing to the same type of structures are self-referential in nature.
Example:

CPP

struct node {

int data1;

char data2;

struct node* link;
};

int main()
{

struct node ob;

return 0;
}

Python3

class node:

def __init__(self):

self.data1=0

self.data2=''

self.link=None

if __name__ == '__main__':

ob=node()

In the above example ‘link’ is a pointer to a structure of type ‘node’. Hence, the structure ‘node’ is a self-referential structure with ‘link’ as the referencing pointer.
An important point to consider is that the pointer should be initialized properly before accessing, as by default it contains garbage value.
Types of Self Referential Structures

Self Referential Structure with Single Link
Self Referential Structure with Multiple Links

Self Referential Structure with Single Link: These structures can have only one self-pointer as their member. The following example will show us how to connect the objects of a self-referential structure with the single link and access the corresponding data members. The connection formed is shown in the following figure.

CPP

#include <stdio.h>

struct node {

int data1;

char data2;

struct node* link;
};

int main()
{

struct node ob1; // Node1

// Initialization

ob1.link = NULL;

ob1.data1 = 10;

ob1.data2 = 20;

struct node ob2; // Node2

// Initialization

ob2.link = NULL;

ob2.data1 = 30;

ob2.data2 = 40;

// Linking ob1 and ob2

ob1.link = &ob2;

// Accessing data members of ob2 using ob1

printf("%d", ob1.link->data1);

printf("\n%d", ob1.link->data2);

return 0;
}

Python3

class node:

def __init__(self):

self.data1=0

self.data2=0

self.link=None

if __name__ == '__main__':

ob1=node() # Node1

# Initialization

ob1.link = None

ob1.data1 = 10

ob1.data2 = 20

ob2=node() # Node2

# Initialization

ob2.link = None

ob2.data1 = 30

ob2.data2 = 40

# Linking ob1 and ob2

ob1.link = ob2

# Accessing data members of ob2 using ob1

print(ob1.link.data1)

print(ob1.link.data2)

Output: 30 40

Self Referential Structure with Multiple Links: Self referential structures with multiple links can have more than one self-pointers. Many complicated data structures can be easily constructed using these structures. Such structures can easily connect to more than one nodes at a time. The following example shows one such structure with more than one links.
The connections made in the above example can be understood using the following figure.

CPP

#include <stdio.h>

struct node {

int data;

struct node* prev_link;

struct node* next_link;
};

int main()
{

struct node ob1; // Node1

// Initialization

ob1.prev_link = NULL;

ob1.next_link = NULL;

ob1.data = 10;

struct node ob2; // Node2

// Initialization

ob2.prev_link = NULL;

ob2.next_link = NULL;

ob2.data = 20;

struct node ob3; // Node3

// Initialization

ob3.prev_link = NULL;

ob3.next_link = NULL;

ob3.data = 30;

// Forward links

ob1.next_link = &ob2;

ob2.next_link = &ob3;

// Backward links

ob2.prev_link = &ob1;

ob3.prev_link = &ob2;

// Accessing data of ob1, ob2 and ob3 by ob1

printf("%d\t", ob1.data);

printf("%d\t", ob1.next_link->data);

printf("%d\n", ob1.next_link->next_link->data);

// Accessing data of ob1, ob2 and ob3 by ob2

printf("%d\t", ob2.prev_link->data);

printf("%d\t", ob2.data);

printf("%d\n", ob2.next_link->data);

// Accessing data of ob1, ob2 and ob3 by ob3

printf("%d\t", ob3.prev_link->prev_link->data);

printf("%d\t", ob3.prev_link->data);

printf("%d", ob3.data);

return 0;
}

Python3

class node:

def __init__(self):

self.data=0

self.prev_link=None

self.next_link=None

if __name__ == '__main__':

ob1=node() #Node1

# Initialization

ob1.prev_link = None

ob1.next_link = None

ob1.data = 10

ob2=node() #Node2

# Initialization

ob2.prev_link = None

ob2.next_link = None

ob2.data = 20

ob3=node() # Node3

# Initialization

ob3.prev_link = None

ob3.next_link = None

ob3.data = 30

# Forward links

ob1.next_link = ob2

ob2.next_link = ob3

# Backward links

ob2.prev_link = ob1

ob3.prev_link = ob2

# Accessing data of ob1, ob2 and ob3 by ob1

print(ob1.data,end='\t')

print(ob1.next_link.data,end='\t')

print(ob1.next_link.next_link.data)

# Accessing data of ob1, ob2 and ob3 by ob2

print(ob2.prev_link.data,end='\t')

print(ob2.data,end='\t')

print(ob2.next_link.data)

# Accessing data of ob1, ob2 and ob3 by ob3

print(ob3.prev_link.prev_link.data,end='\t')

print(ob3.prev_link.data,end='\t')

print(ob3.data)

Output: 10 20 30 10 20 30 10 20 30

In the above example we can see that ‘ob1’, ‘ob2’ and ‘ob3’ are three objects of the self referential structure ‘node’. And they are connected using their links in such a way that any of them can easily access each other’s data. This is the beauty of the self referential structures. The connections can be manipulated according to the requirements of the programmer.
Applications:
Self referential structures are very useful in creation of other complex data structures like:

Linked Lists
Stacks
Queues
Trees
Graphs etc

Article Tags :

Data Structures

Practice Tags :

Data Structures

Read Full Article

Linked List Data Structure

Last Updated : 01 Feb, 2022

Practice Problems on Linked List
Recent Articles on Linked List

A linked list is a linear data structure, in which the elements are not stored at contiguous memory locations. The elements in a linked list are linked using pointers as shown in the below image:

In simple words, a linked list consists of nodes where each node contains a data field and a reference(link) to the next node in the list.

Topics :

Singly Linked List
Circular Linked List
Doubly Linked List

Misc
Quick Links

Singly Linked List :

Introduction to Linked List
Linked List vs Array
Linked List Insertion
Linked List Deletion (Deleting a given key)
Linked List Deletion (Deleting a key at given position)
Write a function to delete a Linked List
Find Length of a Linked List (Iterative and Recursive)
Search an element in a Linked List (Iterative and Recursive)
Write a function to get Nth node in a Linked List
Nth node from the end of a Linked List
Print the middle of a given linked list
Write a function that counts the number of times a given int occurs in a Linked List
Detect loop in a linked list
Find length of loop in linked list
Function to check if a singly linked list is palindrome
Remove duplicates from a sorted linked list
Remove duplicates from an unsorted linked list
Swap nodes in a linked list without swapping data
Pairwise swap elements of a given linked list
Move last element to front of a given Linked List
Intersection of two Sorted Linked Lists
Intersection point of two Linked Lists.
QuickSort on Singly Linked List
Segregate even and odd nodes in a Linked List
Reverse a linked list

More >>

Circular Linked List :

Circular Linked List Introduction and Applications,
Circular Linked List Traversal
Split a Circular Linked List into two halves
Sorted insert for circular linked list
Check if a linked list is Circular Linked List
Convert a Binary Tree to a Circular Doubly Link List
Circular Singly Linked List | Insertion
Deletion from a Circular Linked List
Circular Queue | Set 2 (Circular Linked List Implementation)
Count nodes in Circular linked list
Josephus Circle using circular linked list
Convert singly linked list into circular linked list
Circular Linked List | Set 1 (Introduction and Applications)
Circular Linked List | Set 2 (Traversal)
Implementation of Deque using circular array
Exchange first and last nodes in Circular Linked List

More >>

Doubly Linked List :

Doubly Linked List Introduction and Insertion
Delete a node in a Doubly Linked List
Reverse a Doubly Linked List
The Great Tree-List Recursion Problem.
Copy a linked list with next and arbit pointer
QuickSort on Doubly Linked List
Swap Kth node from beginning with Kth node from end in a Linked List
Merge Sort for Doubly Linked List
Create a Doubly Linked List from a Ternary Tree
Find pairs with given sum in doubly linked list
Insert value in sorted way in a sorted doubly linked list
Delete a Doubly Linked List node at a given position
Count triplets in a sorted doubly linked list whose sum is equal to a given value x
Remove duplicates from a sorted doubly linked list
Delete all occurrences of a given key in a doubly linked list
Remove duplicates from an unsorted doubly linked list
Sort the biotonic doubly linked list
Sort a k sorted doubly linked list
Convert a given Binary Tree to Doubly Linked List | Set
Program to find size of Doubly Linked List
Sorted insert in a doubly linked list with head and tail pointers
Large number arithmetic using doubly linked list
Rotate Doubly linked list by N nodes
Priority Queue using doubly linked list
Reverse a doubly linked list in groups of given size
Doubly Circular Linked List | Set 1 (Introduction and Insertion)
Doubly Circular Linked List | Set 2 (Deletion)

More >>

Misc :

Skip List | Set 1 (Introduction)
Skip List | Set 2 (Insertion)
Skip List | Set 3 (Searching and Deletion)
Reverse a stack without using extra space in O(n)
An interesting method to print reverse of a linked list
Linked List representation of Disjoint Set Data Structures
Sublist Search (Search a linked list in another list)
How to insert elements in C++ STL List ?
Unrolled Linked List | Set 1 (Introduction)
A Programmer’s approach of looking at Array vs. Linked List
How to write C functions that modify head pointer of a Linked List?
Given a linked list which is sorted, how will you insert in sorted way
Can we reverse a linked list in less than O(n)?
Practice questions for Linked List and Recursion
Construct a Maximum Sum Linked List out of two Sorted Linked Lists having some Common nodes
Given only a pointer to a node to be deleted in a singly linked list, how do you delete it?
Why Quick Sort preferred for Arrays and Merge Sort for Linked Lists?
Squareroot(n)-th node in a Linked List
Find the fractional (or n/k – th) node in linked list
Find modular node in a linked list
Construct a linked list from 2D matrix
Find smallest and largest elements in singly linked list
Arrange consonants and vowels nodes in a linked list
Partitioning a linked list around a given value and If we don’t care about making the elements of the list “stable”
Modify contents of Linked List

Quick Links :

‘Practice Problems’ on Linked List
‘Videos’ on Linked List
‘Quizzes’ on Linked List

If you still need more assistance with your placement preparation, have a look at our Complete Interview Preparation Course. The course has been designed by our expert mentors to help students crack the coding interview of top product or service-based organizations . You get access to premium lectures, 200+ coding questions bank, resume building tips, and lifetime access to the course content. So to make sure that your next programming interview doesn’t feel like an interrogation, enroll in Complete Interview Preparation and give a boost to your placement preparation.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Linked list Data Structure

In this tutorial, you will learn about linked list data structure and it's implementation in Python, Java, C, and C++.

A linked list is a linear data structure that includes a series of connected nodes. Here, each node stores the data and the address of the next node. For example,

Linked list Data Structure

You have to start somewhere, so we give the address of the first node a special name called HEAD. Also, the last node in the linked list can be identified because its next portion points to NULL.

Linked lists can be of multiple types: singly, doubly, and circular linked list. In this article, we will focus on the singly linked list. To learn about other types, visit Types of Linked List.

Note: You might have played the game Treasure Hunt, where each clue includes the information about the next clue. That is how the linked list operates.

Linked List in A Data Structure: All You Need to Know

Lesson 3 of 54By Simplilearn

Last updated on Sep 19, 20216018

PreviousNext

Tutorial Playlist
Data Structure Tutorial
Overview
Arrays in Data Structures: A Guide With Examples
Lesson - 1
All You Need to Know About Two-Dimensional Arrays
Lesson - 2
All You Need to Know About a Linked List in a Data Structure
Lesson - 3
The Complete Guide to Implement a Singly Linked List
Lesson - 4
The Ultimate Guide to Implement a Doubly Linked List
Lesson - 5
The Fundamentals for Understanding Circular Linked List
Lesson - 6
The Ultimate Guide To Understand The Differences Between Stack And Queue
Lesson - 7
Implementing Stacks in Data Structures
Lesson - 8
Your One-Stop Solution for Stack Implementation Using Array
Lesson - 9
Your One-Stop Solution for Queue Implementation Using Array
Lesson - 10
Your One-Stop Solution to Learn Depth-First Search(DFS) Algorithm From Scratch
Lesson - 11
Your One-Stop Solution for Stack Implementation Using Linked-List
Lesson - 12
The Definitive Guide to Understand Stack vs Heap Memory Allocation
Lesson - 13
All You Need to Know About Linear Search Algorithm
Lesson - 14
All You Need to Know About Breadth-First Search Algorithm
Lesson - 15
A One-Stop Solution for Using Binary Search Trees in Data Structure
Lesson - 16
The Best Tutorial to Understand Trees in Data Structure
Lesson - 17
A Complete Guide to Implement Binary Tree in Data Structure
Lesson - 18
A Holistic Look at Using AVL Trees in Data Structures
Lesson - 19
All You Need to Know About Tree Traversal in Data Structure
Lesson - 20
The Best Guide You’ll Ever Need to Understand B-Tree in Data Structure
Lesson - 21
The Best Guide You'll Ever Need to Understand Spanning Tree in Data Structure
Lesson - 22
The Best and Easiest Way to Understand an Algorithm
Lesson - 23
Your One-Stop Solution to Understand Shell Sort Algorithm
Lesson - 24
Your One-Stop Solution to Quick Sort Algorithm
Lesson - 25
The Most Useful Guide to Learn Selection Sort Algorithm
Lesson - 26
Everything You Need to Know About Radix Sort Algorithm
Lesson - 27
Everything You Need to Know About the Counting Sort Algorithm
Lesson - 28
Everything You Need to Know About the Merge Sort Algorithm
Lesson - 29
Insertion Sort Algorithm: One-Stop Solution That Will Help You Understand Insertion Sort
Lesson - 30
Everything You Need to Know About the Bubble Sort Algorithm
Lesson - 31
The Best Guide You’ll Ever Need to Understand Bucket Sort Algorithm
Lesson - 32
Your One-Stop Solution to Understand Recursive Algorithm in Programming
Lesson - 33
The Definitive Guide to Understanding Greedy Algorithm
Lesson - 34
Your One-Stop Solution to Understand Backtracking Algorithm
Lesson - 35
The Fundamentals of the Bellman-Ford Algorithm
Lesson - 36
Your One-Stop Solution for Graphs in Data Structures
Lesson - 37
The Best Guide to Understand and Implement Solutions for Tower of Hanoi Puzzle
Lesson - 38
A Simplified and Complete Guide to Learn Space and Time Complexity
Lesson - 39
All You Need to Know About the Knapsack Problem : Your Complete Guide
Lesson - 40
The Fibonacci Series: Mathematical and Programming Interpretation
Lesson - 41
The Holistic Look at Longest Common Subsequence Problem
Lesson - 42
The Best Article to Understand What Is Dynamic Programming
Lesson - 43
A Guide to Implement Longest Increasing Subsequence Using Dynamic Programming
Lesson - 44
A Holistic Guide to Learn Stop Solution Using Dynamic Programming
Lesson - 45
One Stop Solution to All the Dynamic Programming Problems
Lesson - 46
Understanding the Fundamentals of Binomial Distribution
Lesson - 47
Here’s All You Need to Know About Minimum Spanning Tree in Data Structures
Lesson - 48
Understanding the Difference Between Array and Linked List
Lesson - 49
The Best Article Out There to Understand the B+ Tree in Data Structure
Lesson - 50
A Comprehensive Look at Queue in Data Structure
Lesson - 51
Your One-Stop Solution to Understand Coin Change Problem
Lesson - 52
The Best Way to Understand the Matrix Chain Multiplication Problem
Lesson - 53
Your One-Stop Solution to Learn Floyd-Warshall Algorithm for Using Dynamic Programming
Lesson - 54

A linked list is the most sought-after data structure when it comes to handling dynamic data elements. A linked list consists of a data element known as a node. And each node consists of two fields: one field has data, and in the second field, the node has an address that keeps a reference to the next node.

What is a Linked List?

A linked list is a linear data structure that stores a collection of data elements dynamically.

Nodes represent those data elements, and links or pointers connect each node.

Each node consists of two fields, the information stored in a linked list and a pointer that stores the address of its next node.

The last node contains null in its second field because it will point to no node.

A linked list can grow and shrink its size, as per the requirement.
It does not waste memory space.

Post Graduate Program in Data Analytics

In partnership with Purdue UniversityView Course

Top List List

How is linked list implemented nodes structure referential structure?

Self Referential Structures

Linked List Data Structure

Linked list Data Structure

Linked List in A Data Structure: All You Need to Know

Data Structure Tutorial

Arrays in Data Structures: A Guide With Examples

All You Need to Know About Two-Dimensional Arrays

All You Need to Know About a Linked List in a Data Structure

The Complete Guide to Implement a Singly Linked List

The Ultimate Guide to Implement a Doubly Linked List

The Fundamentals for Understanding Circular Linked List

The Ultimate Guide To Understand The Differences Between Stack And Queue

Implementing Stacks in Data Structures

Your One-Stop Solution for Stack Implementation Using Array

Your One-Stop Solution for Queue Implementation Using Array

Your One-Stop Solution to Learn Depth-First Search(DFS) Algorithm From Scratch

Your One-Stop Solution for Stack Implementation Using Linked-List

The Definitive Guide to Understand Stack vs Heap Memory Allocation

All You Need to Know About Linear Search Algorithm

All You Need to Know About Breadth-First Search Algorithm

A One-Stop Solution for Using Binary Search Trees in Data Structure

The Best Tutorial to Understand Trees in Data Structure

A Complete Guide to Implement Binary Tree in Data Structure

A Holistic Look at Using AVL Trees in Data Structures

All You Need to Know About Tree Traversal in Data Structure

The Best Guide You’ll Ever Need to Understand B-Tree in Data Structure

The Best Guide You'll Ever Need to Understand Spanning Tree in Data Structure

The Best and Easiest Way to Understand an Algorithm

Your One-Stop Solution to Understand Shell Sort Algorithm

Your One-Stop Solution to Quick Sort Algorithm

The Most Useful Guide to Learn Selection Sort Algorithm

Everything You Need to Know About Radix Sort Algorithm

Everything You Need to Know About the Counting Sort Algorithm

Everything You Need to Know About the Merge Sort Algorithm

Insertion Sort Algorithm: One-Stop Solution That Will Help You Understand Insertion Sort

Everything You Need to Know About the Bubble Sort Algorithm

The Best Guide You’ll Ever Need to Understand Bucket Sort Algorithm

Your One-Stop Solution to Understand Recursive Algorithm in Programming

The Definitive Guide to Understanding Greedy Algorithm

Your One-Stop Solution to Understand Backtracking Algorithm

The Fundamentals of the Bellman-Ford Algorithm

Your One-Stop Solution for Graphs in Data Structures

The Best Guide to Understand and Implement Solutions for Tower of Hanoi Puzzle

A Simplified and Complete Guide to Learn Space and Time Complexity

All You Need to Know About the Knapsack Problem : Your Complete Guide

The Fibonacci Series: Mathematical and Programming Interpretation

The Holistic Look at Longest Common Subsequence Problem

The Best Article to Understand What Is Dynamic Programming

A Guide to Implement Longest Increasing Subsequence Using Dynamic Programming

A Holistic Guide to Learn Stop Solution Using Dynamic Programming

One Stop Solution to All the Dynamic Programming Problems

Understanding the Fundamentals of Binomial Distribution

Here’s All You Need to Know About Minimum Spanning Tree in Data Structures

Understanding the Difference Between Array and Linked List

The Best Article Out There to Understand the B+ Tree in Data Structure

A Comprehensive Look at Queue in Data Structure

Your One-Stop Solution to Understand Coin Change Problem

The Best Way to Understand the Matrix Chain Multiplication Problem

Your One-Stop Solution to Learn Floyd-Warshall Algorithm for Using Dynamic Programming

Table of Contents

What is a Linked List?

Post Graduate Program in Data Analytics

Pos Terkait

Periklanan

BERITA TERKINI

Toplist Popular

Periklanan

Terpopuler

Token Data

Periklanan

Tentang Kami

Legal

Dukungan

Social