This document discusses linked lists and their advantages over arrays. It provides code examples for creating and manipulating singly linked lists, including adding nodes to the beginning, end, or a specific position in the list. It also shows how to count nodes, delete nodes by value or location, display the list, reverse the list, and lists some disadvantages of linked lists like slower access times compared to arrays.

1. © 2004 Goodrich, Tamassia© 2004 Goodrich, Tamassia 1

2. © 2004 Goodrich, Tamassia
Arrays: pros and cons
Advantages:
Fast element access.
Disadvantages:
 Impossible to resize.
Why require Linked List:
• Many applications require resizing!
• Required size not always immediately available.
2

3. © 2004 Goodrich, Tamassia
Singly Linked Lists (SLL)
A singly linked list is a concrete data
structure consisting of a sequence of
nodes
Each node stores value
Each node stores link to the next
node
Last node has null value
SLL can only point to the next Node
in the list but not to the previous.
3
next
value node
20 15 12 10
NULL

4. © 2004 Goodrich, Tamassia
Creating list structure
struct Node
{
int Data;
struct Node *Next;
}*Head;
4

5. © 2004 Goodrich, Tamassia
Starting SLL
Initially we set 'Head' as NULL which means list is
empty.
//Set HEAD as NULL
Head=NULL;
5

6. © 2004 Goodrich, Tamassia
Add element at beginning
6
We create 'temp' node and save the Data part.
If Head is NULL it means list is empty. So we set temp
node as the Head of the list and set the Next as NULL.
Else we set the Next in temp node as Head and reassign
Head with temp.

7. © 2004 Goodrich, Tamassia
Code for add at beginning
// Adding a Node at the Beginning of the List
void addBeg(int num)
{
struct Node *temp;
temp=(struct Node *)malloc(sizeof(struct Node));
temp->Data = num;
if (Head == NULL)
{
//List is Empty
Head=temp;
Head->Next=NULL;
}
else
{
temp->Next=Head;
Head=temp;
}
}
7

8. © 2004 Goodrich, Tamassia
Add element at the end
8

9. © 2004 Goodrich, Tamassia
Code for add at the end
//Adding a Node at the end of the list
void addEnd(int num)
{
struct Node *temp1, *temp2;
temp1=(struct Node *)malloc(sizeof(struct Node));
temp1->Data=num;
// Copying the Head location into another node.
temp2=Head;
if(Head == NULL)
{
// If List is empty we create First Node.
Head=temp1;
Head->Next=NULL;
}
else
{
// Traverse down to end of the list.
while(temp2->Next != NULL)
temp2=temp2->Next;
// Append at the end of the list.
temp1->Next=NULL;
temp2->Next=temp1;
}
}
9

10. © 2004 Goodrich, Tamassia
Add at specific position
10

11. © 2004 Goodrich, Tamassia
Counting Elements
// Counting number of elements in the List
int length()
{
struct Node *cur_ptr;
int count=0;
cur_ptr=Head;
while(cur_ptr != NULL)
{
cur_ptr=cur_ptr->Next;
count++;
}
return(count);
}
11

12. © 2004 Goodrich, Tamassia
// Adding a new Node at specified position
void addAt(int num, int loc)
{
int i;
struct Node *temp, *prev_ptr, *cur_ptr;
cur_ptr=Head;
if(loc > (length()+1) || loc <= 0)
{
printf("nInsertion at given location is not
possiblen ");
}
12

13. © 2004 Goodrich, Tamassia
else
{
// If the location is starting of the list
if (loc == 1)
{
addBeg(num);
}
else
{
for(i=1;i<loc;i++)
{
prev_ptr=cur_ptr;
cur_ptr=cur_ptr->Next;
}
temp=(struct Node *)malloc(sizeof(struct Node));
temp->Data=num;
prev_ptr->Next=temp;
temp->Next=cur_ptr;
}
}
13

14. © 2004 Goodrich, Tamassia
Delete node using value
14
• If the value to be deleted is the head of the list.

15. © 2004 Goodrich, Tamassia
Delete node using value
15
• If the value to be deleted is not the head of the list.

16. © 2004 Goodrich, Tamassia
Delete node using value
// Deleting a node from List depending upon the data in the node.
int delNodeData(int num)
{
struct Node *prev_ptr, *cur_ptr;
cur_ptr=Head;
while(cur_ptr != NULL)
{
if(cur_ptr->Data == num)
{
if(cur_ptr==Head)
{
Head=cur_ptr->Next;
free(cur_ptr);
return 0;
}
else
{
prev_ptr->Next=cur_ptr->Next;
free(cur_ptr);
return 0;
}
}
else
{
prev_ptr=cur_ptr;
cur_ptr=cur_ptr->Next;
}
}
printf("nElement %d is not found in the List", num);
return 1;
}
16

17. © 2004 Goodrich, Tamassia
Delete using location
// Deleting a node from List depending upon the location in the list.
int delNodeLoc(int loc)
{
struct Node *prev_ptr, *cur_ptr;
int i;
cur_ptr=Head;
if(loc > (length()) || loc <= 0)
{
printf("nDeletion of Node at given location is not possiblen ");
}
else
{
// If the location is starting of the list
if (loc == 1)
{
Head=cur_ptr->Next;
free(cur_ptr);
return 0;
}
else
{
for(i=1;i<loc;i++)
{
prev_ptr=cur_ptr;
cur_ptr=cur_ptr->Next;
}
prev_ptr->Next=cur_ptr->Next;
free(cur_ptr);
}
}
return 1;
}
17

18. © 2004 Goodrich, Tamassia
Displaying List
// Displaying list contents
void display()
{
struct Node *cur_ptr;
cur_ptr=Head;
if(cur_ptr==NULL)
{
printf("nList is Empty");
}
else
{
printf("Elements in the List: ");
//traverse the entire linked list
while(cur_ptr!=NULL)
{
printf(" -> %d ",cur_ptr->Data);
cur_ptr=cur_ptr->Next;
}
printf("n");
}
}
18

19. © 2004 Goodrich, Tamassia
Reversing List
//Reversesing a Linked List
void reverse()
{
struct Node *prev_ptr, *cur_ptr, *temp;
cur_ptr=Head;
prev_ptr=NULL;
while(cur_ptr != NULL)
{
temp=prev_ptr;
prev_ptr=cur_ptr;
cur_ptr=cur_ptr->Next;
prev_ptr->Next=temp;
}
Head=prev_ptr;
}
19

20. © 2004 Goodrich, Tamassia
Disadvantages
Slower access to node
Can’t access particular node directly. We have to
traverse whole list till the concern node found.
Every insertion and deletion my involve shifting
nodes
20