Linked-List with operations and algorithms.ppt

• a linked list is a data structure which can change
during execution.
• successive elements are connected by pointers.
• it can grow or shrink in size during execution of a
program.
• it can be made just as long as required.–it does not
waste memory space.
11/10/24

ARRAY VERSUS LINKED LISTS
• Arrays are suitable for:
• Inserting/Deleting an element at the end.
• Randomly accessing any element.
• Searching the list for a particular value.
• Linked Lists are suitable for:
• Inserting an element.
• Deleting an element.
• Applications where sequential access is required.
• In situations where the number of elements cannot be
predicted before hand.

CIRCULAR LINKED LIST
• the pointer from the last element in the list points
back to the first element.
11/10/24

DOUBLY LINKED LIST
• pointers exist between adjacent nodes in both
directions.
• the list can be traversed either forward or backward.
• usually two pointers are maintained to keep track of
the list, head and tail.
11/10/24

11/10/24
Lijo V.P 13600 SCOPE VIT

BASIC OPERATIONS ON A LIST
• CREATING A LIST
• TRAVERSING THE LIST
• INSERTING AN ITEM IN THE LIST
• DELETING AN ITEM FROM THE LIST
11/10/24

CREATING THE LINKED LIST
STRUCT STUD
{
INT ROLL;
STRUCT STUD *NEXT;
};
11/10/24

CREATING THE LINKED LIST
• to start with, we have to create a node (the first
node), and make head point to it.
11/10/24

ALGORITHM FOR CREATION OF LINKED
LIST
• INPUT THE NUMBER OF NODES TO BE CREATED FROM THE USER
• CHECK WHETHER LINKED LIST IS EMPTY OR NOT.
• IF ITS EMPTY
• ALLOCATE SPACE FOR NEW NODE
• ASSIGN IT TO HEAD NODE.
• MAKE THE TEMPORARY POINTER TO POINT HEAD NODE
• IF ITS HAVING ALREADY A NODE
• ALLOCATE THE SPACE FOR NEW NODE
• ASSIGN IT TO THE PREVIOUS NODE POINTER PART. .
• MOVE THE TEMPORARY POINTER TO POINT THE CURRENT NODE
• GET THE INPUT FOR ROLLNO.
• REPEAT THE ABOVE 3 STEPS TILL THE LOOP FAILS
• ASSIGN NULL TO THE LAST NODE POINTER PART.
11/10/24

CODE FOR CREATION OF LINKED LIST
11/10/24

ALGORITHM FOR TRAVERSING THE LIST
• CREATE A TEMPORARY POINTER
• ASSIGN THE HEAD NODE OF THE LIST TO TEMPORARY POINTER
• START THE LOOP WITH A CONDITION OF TEMPORARY POINTER IS
NOT EQUAL TO NULL
• PRINT THE DATA
• MAKE THE TEMPORARY POINTER TO POINT THE NEXT NODE IN THE LIST
11/10/24

CODE FOR TRAVERSING THE LIST
11/10/24

INSERTING A NODE IN A LIST
11/10/24

INSERTING A NODE AT BEGINNING
• ALLOCATE SPACE TO NEW NODE
• GET THE INPUT (ROLL NUMBER)
• ASSIGN NEWNODE POINTER PART TO POINT THE FIRST NODE.
• MAKE HEAD TO POINT THE NEW NODE
11/10/24

INSERTING A NODE AT LAST
• GET THE INPUT (ROLL NUMBER(RNO))
• ASSIGN HEAD NODE TO TEMPORARY POINTER(P)
• START A WHILE LOOP WITH A CONDITION OF TEMPORARY
POINTER’S NEXT PART(P->NEXT) IS NOT EQUAL TO NULL.
• MAKE THE LAST NODE POINTER PART TO POINT NEW NODE
• ASSIGN THE NEW NODE POINTER PART AS NULL
11/10/24

INSERTING A NODE IN MIDDLE
POINTER’S DATA PART(P->ROLL) IS NOT EQUAL TO NEW ROLL
NO(RNO).
• AFTER THE WHILE LOOP EXIT
• MAKE THE PREVIOUS NODE POINTER PART TO POINT THE NEW NODE
• ASSIGN THE NEW NODE POINTER PART TO POINT THE NEXT NODE11/10/24

CODE FOR INSERTION A NODE
11/10/24
void insert (node *head)
{
int k = 0, rno;
node *p, *q, *new;
new = (node *) malloc(sizeof(node));
scanf("%d %s %d", &new->roll,new->name, &new->age);
printf("nInsert before roll (-ve for end):");
scanf("%d", &rno);
p = head;
if (p->roll == rno) /* At the beginning */
{
new->next = p;
*head = new;
}

CODE FOR INSERTION A NODE
ELSE
{
WHILE ((P->NEXT != NULL) && (P->ROLL != RNO))
{
Q = P;
P = P->NEXT;
}
IF (P->NEXT == NULL) /* AT THE END */
{
P->NEXT = NEW;
NEW->NEXT = NULL;
}
ELSE IF (P->ROLL == RNO) /* IN THE MIDDLE */
{
Q->NEXT = NEW;
NEW->NEXT = P;
}
}
}
11/10/24

DELETING A NODE FROM THE LIST
11/10/24

DELETING A NODE FROM THE LIST
• HERE ALSO WE ARE REQUIRED TO DELETE A SPECIFIED NODE.
• SAY, THE NODE WHOSE ROLL FIELD IS GIVEN
• HERE ALSO THREE CONDITIONS ARISE:
• DELETING THE FIRST NODE.
• DELETING THE LAST NODE.
• DELETING AN INTERMEDIATE NODE.
11/10/24

DELETE A NODE AT BEGINNING
• GET THE INPUT FROM USER(ROLL NUMBER TO BE DELETED)
• MAKE THE HEAD TO POINT THE SECOND NODE
• RELEASE THE FIRST NODE USING EXPLICIT DEALLOCATION
11/10/24

DELETE A NODE AT LAST
POINTER’S NEXT PART(P->NEXT) IS NOT EQUAL TO NULL.
• MAKE THE LAST PREVIOUS NODE POINTER PART TO NULL
• RELEASE THE LAST NODE USING EXPLICIT DEALLOCATION.
11/10/24

DELETING A NODE IN MIDDLE
• START A WHILE LOOP WITH A CONDITION OF TEMPORARY POINTER’S
DATA PART(P->ROLL) IS NOT EQUAL TO NEW ROLL NO(RNO).
• AFTER THE WHILE LOOP EXIT, CHECK FOR A CONDITION WHETHER
TEMPORARY POINTER DATA PART IS EQUAL TO THE NEW ROLL NO.
• IF ROLL NUMBER IS NOT EQUAL
• PRINT A MESSAGE THAT ROLL NUMBER IS NOT AVAILABLE
• IF ROLL NUMBERS ARE EQUAL
• MAKE THE PREVIOUS NODE POINTER PART TO POINT TO THE NEXT NODE ADDRESS
• RELEASE THE CURRENT NODE USING EXPLICIT DE-ALLOCATION
11/10/24

CODE FOR DELETING NODES
11/10/24
node* delete (node *head)
{
int rno;
node *p, *q;
printf("nDeletefor roll :");
scanf("%d", &rno);
p = head;
if (p->roll == rno) /* Delete the first element */
{
*head = p->next;
free (p);
}

11/10/24
else
{
while ((p->next != NULL) && (p->roll != rno))
{
q = p;
p = p->next;
}
if ((p->next == NULL) &&( p->roll == rno))
{/*last element*/
q->next=NULL;
free(p);
}

ELSE IF((P->NEXT == NULL)&&( P->ROLL != RNO))
/* DELETE ANY OTHER ELEM */
{
Q->NEXT = P->NEXT;
FREE (P);
}
}
RETURN(HEAD);
}
11/10/24

THANK YOU
11/10/24

Linked-List with operations and algorithms.ppt

More Related Content

Recently uploaded (20)

Featured (20)

Linked-List with operations and algorithms.ppt