Singly Linked List

It's like a chain of paper clips

A singly linked list is a type of data structure that is used to store a collection of items. It is called a "singly" linked list because each item in the list is connected to only one other item.

Imagine that you have a chain of paper clips, with each paper clip connected to the next one. This chain of paper clips is like a singly linked list. Each paper clip represents an item in the list, and the connection between each paper clip represents the link between the items in the list.

Singly-linked lists are useful because they allow you to store and access a large number of items, even if you don't know how many items there will be in advance. You can add new items to the list, remove items from the list, and move through the list to access individual items.

For example, you might use a singly linked list to store a list of your favorite foods. You could add new foods to the list as you think of them, remove foods that you no longer like, and move through the list to find a specific food.

In summary, a singly linked list is a way of storing a collection of items in a way that makes it easy to add, remove, and access individual items. It is like a chain of paper clips, with each paper clip representing an item in the list and the connections between each paper clip representing the links between the items.

Implementation

In a singly linked list, each item in the list is represented by a node. A node is a simple data structure that contains two parts: a piece of data (also known as an element or a value), and a reference to the next node in the list (also known as a link or a pointer).

Here is an example of a singly linked list containing three nodes:

node1 = {
  data: "apple",
  next: node2
}

node2 = {
  data: "banana",
  next: node3
}

node3 = {
  data: "cherry",
  next: null
}

In this example, the first node (node1) contains the data "apple" and a reference to the second node (node2). The second node (node2) contains the data "banana" and a reference to the third node (node3). The third node (node3) contains the data "cherry" and a reference to null, which indicates that it is the last node in the list.

To create a singly linked list in your own program, you can define a node class that contains a data field and a next field. Here is an example of a node class in Python:

class Node:
  def __init__(self, data):
    self.data = data
    self.next = None

To create a new node, you can instantiate an object of the Node class and pass in the data you want to store in the node. For example:

node1 = Node("apple")

To link two nodes together, you can set the next field of the first node to the second node. For example:

node1 = Node("apple")
node2 = Node("banana")
node1.next = node2

After linking the two nodes together, the singly linked list will look like this:

node1 = {
  data: "apple",
  next: node2
}

node2 = {
  data: "banana",
  next: null
}

To add a new node to the end of the list, you can traverse the list until you reach the last node, and then set the next field of that node to the new node. For example:

node1 = Node("apple")
node2 = Node("banana")
node1.next = node2
node3 = Node("cherry")
node2.next = node3

After adding the new node, the singly linked list will look like this:

node1 = {
  data: "apple",
  next: node2
}

node2 = {
  data: "banana",
  next: node3
}

node3 = {
  data: "cherry",
  next: null
}

THE END !!

Or so you thought

Here is an implementation in C

// Define a node structure
struct Node
{
  int data;
  struct Node *next;
};

// Create a new node
struct Node *node1 = malloc(sizeof(struct Node));
node1->data = 10;
node1->next = NULL;

// Link two nodes together
struct Node *node1 = malloc(sizeof(struct Node));
node1->data = 10;
node1->next = NULL;

struct Node *node2 = malloc(sizeof(struct Node));
node2->data = 20;
node2->next = NULL;

node1->next = node2;

// Add a new node to the end of the list
struct Node *node1 = malloc(sizeof(struct Node));
node1->data = 10;
node1->next = NULL;

struct Node *node2 = malloc(sizeof(struct Node));
node2->data = 20;
node2->next = NULL;

node1->next = node2;

struct Node *node3 = malloc(sizeof(struct Node));
node3->data = 30;
node3->next = NULL;

node2->next = node3;

In this example, the first node (node1) contains the data 10 and a reference to the second node (node2). The second node (node2) contains the data 20 and a reference to the third node (node3). The third node (node3) contains the data 30 and a reference to null, which indicates that it is the last node in the list.

You can use these code snippets as a starting point for implementing a singly linked list in C. You may need to modify the code to suit your specific needs and requirements.

Okay, see you next time, happy hacking.