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

A linked list is a linear data structure, in which the elements are not stored at adjacent memory areas. The elements in a linked list are linked using pointers as demonstrated in the underneath picture:

A linked list data structure incorporates a series of associated nodes. Here, each node store the data and the address of the next node For instance,

You need to begin someplace, so we give the address of the first node a special name called HEAD.

Likewise, the last node in the linked list can be identified because its next segment points to NULL.

Let’s see how each node of the LinkedList is represented. Each node consists of:

• A data item
• An address of another node

We wrap both the data item and the next node reference in a struct as:

```struct node
{
int data;
struct node *next;
};```

Understanding the structure of a linked list node is the way to having a grasp on it.

Each struct node has a data item and a pointer to another struct node. Allow us to create a simple Linked List with three items to understand how this functions.

```/* Initialize nodes */
struct node *one = NULL;
struct node *two = NULL;
struct node *three = NULL;

/* Allocate memory */
one = malloc(sizeof(struct node));
two = malloc(sizeof(struct node));
three = malloc(sizeof(struct node));

/* Assign data values */
one->data = 1;
two->data = 2;
three->data=3;

/* Connect nodes */
one->next = two;
two->next = three;
three->next = NULL;

In the event that you didn’t understand any of the lines over, all you require is a refresher on pointers and structs.

In just a few steps, we have created a simple linked list with three nodes.

The power of LinkedList comes from the ability to break the chain and rejoin it. For example on the off chance that you needed to put an element 4 somewhere in the range of 1 and 2, the means would be:

• Create a new struct node and allocate memory to it.
• Add its data value as 4
• Point its next pointer to the struct node containing 2 as the data value
• Change the next pointer of “1” to the node we just created.

Accomplishing something comparable in an array would have required moving the places of the relative multitude of ensuing elements.

In python and Java, the linked list can be actualized using classes as demonstrated in the codes below.

Lists are quite possibly the most well known and productive data structures, with usage in every programming language like C, C++, Python, Java, and C#.

Aside from that, linked lists are a great method to learn how pointers work. By rehearsing how to manipulate linked lists, you can set yourself up to learn further advanced data structures like graphs and trees.

## Linked List Implementations in Python, Java, C, and C++ Examples

Python

```# Linked list implementation in Python

class Node:
# Creating a node
def __init__(self, item):
self.item = item
self.next = None

def __init__(self):

if __name__ == '__main__':

# Assign item values
second = Node(2)
third = Node(3)

# Connect nodes
second.next = third

# Print the linked list item
```

Java

```// Linked list implementation in Java

// Creating a node

static class Node {
int value;
Node next;

Node(int d) {
value = d;
next = null;
}
}

public static void main(String[] args) {

// Assign value values
Node second = new Node(2);
Node third = new Node(3);

// Connect nodess
second.next = third;

// printing node-value
}
}
}```

C

```// Linked list implementation in C

#include <stdio.h>
#include <stdlib.h>

// Creating a node
struct node {
int value;
struct node *next;
};

// print the linked list value
while (p != NULL) {
printf("%d ", p->value);
p = p->next;
}
}

int main() {
// Initialize nodes
struct node *one = NULL;
struct node *two = NULL;
struct node *three = NULL;

// Allocate memory
one = malloc(sizeof(struct node));
two = malloc(sizeof(struct node));
three = malloc(sizeof(struct node));

// Assign value values
one->value = 1;
two->value = 2;
three->value = 3;

// Connect nodes
one->next = two;
two->next = three;
three->next = NULL;

// printing node-value
}```

C++

```// Linked list implementation in C++

#include <bits/stdc++.h>
using namespace std;

// Creating a node
class Node {
public:
int value;
Node* next;
};

int main() {
Node* one = NULL;
Node* two = NULL;
Node* three = NULL;

// allocate 3 nodes in the heap
one = new Node();
two = new Node();
three = new Node();

// Assign value values
one->value = 1;
two->value = 2;
three->value = 3;

// Connect nodes
one->next = two;
two->next = three;
three->next = NULL;

// print the linked list value
}
}```

Space Complexity: O(n)