A Linked List Node

Linked List
Like arrays, Linked List is a linear data structure. Unlike arrays, linked list elements are not
stored at a contiguous location; the elements are linked using pointers.
Representation:
A linked list is represented by a pointer to the first node of the linked list. The first node is called
the head. If the linked list is empty, then the value of the head is NULL.
Each node in a list consists of at least two parts:
1) data
2) Pointer (Or Reference) to the next node
Why Linked List?

Arrays can be used to store linear data of similar types, but arrays have the following limitations.
1) The size of the arrays is fixed: So we must know the upper limit on the number of elements in
advance. Also, generally, the allocated memory is equal to the upper limit irrespective of the
usage.
2) Inserting a new element in an array of elements is expensive because the room has to be
created for the new elements and to create room existing elements have to be shifted.
For example, in a system, if we maintain a sorted list of IDs in an array id[].
id[] = [1000, 1010, 1050, 2000, 2040].
And if we want to insert a new ID 1005, then to maintain the sorted order, we have to move all
the elements after 1000 (excluding 1000).
Deletion is also expensive with arrays until unless some special techniques are used.
For example, to delete 1010 in id[], everything after 1010 has to be moved.
Advantages over arrays
1) Dynamic size
2) Ease of insertion/deletion
Drawbacks:
1) Random access is not allowed. We have to access elements sequentially starting from the first
node. So we cannot do binary search with linked lists efficiently with its default implementation.
2) Extra memory space for a pointer is required with each element of the list.
3) Not cache friendly. Since array elements are contiguous locations, there is locality of reference
which is not there in case of linked lists.
// A linked list node

struct Node
{
int data;
struct Node *next;
};
A node can be added in three ways
1) At the front of the linked list
2) After a given node.
3) At the end of the linked list.
Add a node at the front: (A 4 steps process)

The new node is always added before the head of the given Linked List. And newly added node
becomes the new head of the Linked List. For example if the given Linked List is 10->15->20->25
and we add an item 5 at the front, then the Linked List becomes 5->10->15->20->25. Let us call the
function that adds at the front of the list is push(). The push() must receive a pointer to the head
pointer, because push must change the head pointer to point to the new node.
/* Given a reference (pointer to pointer) to the head of a list and an int, inserts a new node on
the front of the list. */
void push(struct Node** head_ref, int new_data)
{
/* 1. allocate node */
struct Node* new_node = (struct Node*) malloc(sizeof(struct Node));

/* 2. put in the data */
new_node->data = new_data;

/* 3. Make next of new node as head */
new_node->next = (*head_ref);

/* 4. move the head to point to the new node */
(*head_ref) = new_node;
}
Add a node after a given node: (5 steps process)

We are given pointer to a node, and the new node is inserted after the given node.
/* Given a node prev_node, insert a new node after the given prev_node */
void insertAfter(struct Node* prev_node, int new_data)

{
/*1. check if the given prev_node is NULL */
if (prev_node == NULL)
{
printf("the given previous node cannot be NULL");
return;
}

/* 2. allocate new node */
struct Node* new_node =(struct Node*) malloc(sizeof(struct Node));


/* 4. Make next of new node as next of prev_node */
new_node->next = prev_node->next;

/* 5. move the next of prev_node as new_node */
prev_node->next = new_node;
}
Add a node at the end: (6 steps process)

The new node is always added after the last node of the given Linked List. For example if the given
Linked List is 5->10->15->20->25 and we add an item 30 at the end, then the Linked List becomes
5->10->15->20->25->30.Since a Linked List is typically represented by the head of it, we have to
traverse the list till end and then change the next of last node to new node.
/* Given a reference (pointer to pointer) to the head of a list and an int, appends a new node at the
end */
void append(struct Node** head_ref, int new_data)

{
/* 1. allocate node */
struct Node* new_node = (struct Node*) malloc(sizeof(struct Node));

struct Node *last = *head_ref; /* used in step 5*/


/* 3. This new node is going to be the last node, so make next of it as NULL*/
new_node->next = NULL;

/* 4. If the Linked List is empty, then make the new node as head */
if (*head_ref == NULL)
{
*head_ref = new_node;
return;
}

/* 5. Else traverse till the last node */
while (last->next != NULL)
last = last->next;

/* 6. Change the next of last node */
last->next = new_node;
return;
// This function prints contents of linked list starting from head

void printList(struct Node *node)
{
while (node != NULL)
{
printf(" %d ", node->data);
node = node->next;
}
}
To delete a node from linked list, we need to do following steps.

1) Find previous node of the node to be deleted.
2) Changed next of previous node.
3) Free memory for the node to be deleted.
/* Given a reference (pointer to pointer) to the head of a list and a key, deletes the first
occurrence of key in linked list */
void deleteNode(struct Node **head_ref, int key)
{
// Store head node
struct Node* temp = *head_ref, *prev;

// If head node itself holds the key to be deleted
if (temp != NULL && temp->data == key)
{
*head_ref = temp->next; // Changed head
free(temp); // free old head
return;
}
// Search for the key to be deleted, keep track of the previous node as we need to change 'prev->next'
while (temp != NULL && temp->data != key)
{
prev = temp;
temp = temp->next;
}
// If key was not present in linked list
if (temp == NULL) return;

// Unlink the node from linked list
prev->next = temp->next;
free(temp); // Free memory
}

A Linked List Node

Uploaded by

Copyright:

Available Formats

A Linked List Node

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

A Linked List Node

Uploaded by

Copyright:

Available Formats

Linked List

Why Linked List?

// A linked list node

Add a node at the front: (A 4 steps process)

Add a node after a given node: (5 steps process)

void insertAfter(struct Node* prev_node, int new_data)

Add a node at the end: (6 steps process)

void append(struct Node** head_ref, int new_data)

// This function prints contents of linked list starting from head

To delete a node from linked list, we need to do following steps.

You might also like