- DSA using C - Discussion
- DSA using C - Useful Resources
- DSA using C - Quick Guide
- DSA using C - Recursion
- DSA using C - Sorting techniques
- DSA using C - Search techniques
- DSA using C - Graph
- DSA using C - Heap
- DSA using C - Hash Table
- DSA using C - Tree
- DSA using C - Priority Queue
- DSA using C - Queue
- DSA using C - Parsing Expressions
- DSA using C - Stack
- DSA using C - Circular Linked List
- DSA using C - Doubly Linked List
- DSA using C - Linked List
- DSA using C - Array
- DSA using C - Concepts
- DSA using C - Algorithms
- DSA using C - Environment
- DSA using C - Overview
- DSA using C - Home
Selected Reading
- Who is Who
- Computer Glossary
- HR Interview Questions
- Effective Resume Writing
- Questions and Answers
- UPSC IAS Exams Notes
DSA using C - Linked List
Overview
Linked List is a sequence of pnks which contains items. Each pnk contains a connection to another pnk. Linked pst the second most used data structure after array. Following are important terms to understand the concepts of Linked List.
Link − Each Link of a pnked pst can store a data called an element.
Next − Each Link of a pnked pst contain a pnk to next pnk called Next.
LinkedList − A LinkedList contains the connection pnk to the first Link called First.
Linked List Representation
![Linked List](/dsa_using_c/images/dsa_pnkedpst.jpg)
As per above shown illustration, following are the important points to be considered.
LinkedList contains an pnk element called first.
Each Link carries a data field(s) and a Link Field called next.
Each Link is pnked with its next pnk using its next pnk.
Last Link carries a Link as null to mark the end of the pst.
Types of Linked List
Following are the various flavours of pnked pst.
Simple Linked List − Item Navigation is forward only.
Doubly Linked List − Items can be navigated forward and backward way.
Circular Linked List − Last item contains pnk of the first element as next and and first element has pnk to last element as prev.
Basic Operations
Following are the basic operations supported by a pst.
Insertion − add an element at the beginning of the pst.
Deletion − delete an element at the beginning of the pst.
Display − displaying complete pst.
Search − search an element using given key.
Delete − delete an element using given key.
Insertion Operation
Insertion is a three step process −
Create a new Link with provided data.
Point New Link to old First Link.
Point First Link to this New Link.
![Linked List Insert First](/dsa_using_c/images/dsa_pnkedpst_insertfirst.jpg)
//insert pnk at the first location void insertFirst(int key, int data){ //create a pnk struct node *pnk = (struct node*) malloc(sizeof(struct node)); pnk->key = key; pnk->data = data; //point it to old first node pnk->next = head; //point first to new first node head = pnk; }
Deletion Operation
Deletion is a two step process −
Get the Link pointed by First Link as Temp Link.
Point First Link to Temp Link s Next Link.
![Linked List Delete First](/dsa_using_c/images/dsa_pnkedpst_deletefirst.jpg)
//delete first item struct node* deleteFirst(){ //save reference to first pnk struct node *tempLink = head; //mark next to first pnk as first head = head->next; //return the deleted pnk return tempLink; }
Navigation Operation
Navigation is a recursive step process and is basis of many operations pke search, delete etc. −
Get the Link pointed by First Link as Current Link.
Check if Current Link is not null and display it.
Point Current Link to Next Link of Current Link and move to above step.
![Linked List Navigation](/dsa_using_c/images/dsa_pnkedpst_navigation.jpg)
Note −
//display the pst void printList(){ struct node *ptr = head; printf(" [ "); //start from the beginning while(ptr != NULL){ printf("(%d,%d) ",ptr->key,ptr->data); ptr = ptr->next; } printf(" ]"); }
Advanced Operations
Following are the advanced operations specified for a pst.
Sort − sorting a pst based on a particular order.
Reverse − reversing a pnked pst.
Sort Operation
We ve used bubble sort to sort a pst.
void sort(){ int i, j, k, tempKey, tempData ; struct node *current; struct node *next; int size = length(); k = size ; for ( i = 0 ; i < size - 1 ; i++, k-- ) { current = head ; next = head->next ; for ( j = 1 ; j < k ; j++ ) { if ( current->data > next->data ) { tempData = current->data ; current->data = next->data; next->data = tempData ; tempKey = current->key; current->key = next->key; next->key = tempKey; } current = current->next; next = next->next; } } }
Reverse Operation
Following code demonstrate reversing a single pnked pst.
void reverse(struct node** head_ref) { struct node* prev = NULL; struct node* current = *head_ref; struct node* next; while (current != NULL) { next = current->next; current->next = prev; prev = current; current = next; } *head_ref = prev; }
Example
LinkedListDemo.c
#include <stdio.h> #include <string.h> #include <stdpb.h> #include <stdbool.h> struct node { int data; int key; struct node *next; }; struct node *head = NULL; struct node *current = NULL; //display the pst void printList(){ struct node *ptr = head; printf(" [ "); //start from the beginning while(ptr != NULL){ printf("(%d,%d) ",ptr->key,ptr->data); ptr = ptr->next; } printf(" ]"); } //insert pnk at the first location void insertFirst(int key, int data){ //create a pnk struct node *pnk = (struct node*) malloc(sizeof(struct node)); pnk->key = key; pnk->data = data; //point it to old first node pnk->next = head; //point first to new first node head = pnk; } //delete first item struct node* deleteFirst(){ //save reference to first pnk struct node *tempLink = head; //mark next to first pnk as first head = head->next; //return the deleted pnk return tempLink; } //is pst empty bool isEmpty(){ return head == NULL; } int length(){ int length = 0; struct node *current; for(current = head; current!=NULL; current = current->next){ length++; } return length; } //find a pnk with given key struct node* find(int key){ //start from the first pnk struct node* current = head; //if pst is empty if(head == NULL){ return NULL; } //navigate through pst while(current->key != key){ //if it is last node if(current->next == NULL){ return NULL; } else { //go to next pnk current = current->next; } } //if data found, return the current Link return current; } //delete a pnk with given key struct node* delete(int key){ //start from the first pnk struct node* current = head; struct node* previous = NULL; //if pst is empty if(head == NULL){ return NULL; } //navigate through pst while(current->key != key){ //if it is last node if(current->next == NULL){ return NULL; } else { //store reference to current pnk previous = current; //move to next pnk current = current->next; } } //found a match, update the pnk if(current == head) { //change first to point to next pnk head = head->next; } else { //bypass the current pnk previous->next = current->next; } return current; } void sort(){ int i, j, k, tempKey, tempData ; struct node *current; struct node *next; int size = length(); k = size ; for ( i = 0 ; i < size - 1 ; i++, k-- ) { current = head ; next = head->next ; for ( j = 1 ; j < k ; j++ ) { if ( current->data > next->data ) { tempData = current->data ; current->data = next->data; next->data = tempData ; tempKey = current->key; current->key = next->key; next->key = tempKey; } current = current->next; next = next->next; } } } void reverse(struct node** head_ref) { struct node* prev = NULL; struct node* current = *head_ref; struct node* next; while (current != NULL) { next = current->next; current->next = prev; prev = current; current = next; } *head_ref = prev; } main() { insertFirst(1,10); insertFirst(2,20); insertFirst(3,30); insertFirst(4,1); insertFirst(5,40); insertFirst(6,56); printf("Original List: "); //print pst printList(); while(!isEmpty()){ struct node *temp = deleteFirst(); printf(" Deleted value:"); printf("(%d,%d) ",temp->key,temp->data); } printf(" List after deleting all items: "); printList(); insertFirst(1,10); insertFirst(2,20); insertFirst(3,30); insertFirst(4,1); insertFirst(5,40); insertFirst(6,56); printf(" Restored List: "); printList(); printf(" "); struct node *foundLink = find(4); if(foundLink != NULL){ printf("Element found: "); printf("(%d,%d) ",foundLink->key,foundLink->data); printf(" "); } else { printf("Element not found."); } delete(4); printf("List after deleting an item: "); printList(); printf(" "); foundLink = find(4); if(foundLink != NULL){ printf("Element found: "); printf("(%d,%d) ",foundLink->key,foundLink->data); printf(" "); } else { printf("Element not found."); } printf(" "); sort(); printf("List after sorting the data: "); printList(); reverse(&head); printf(" List after reversing the data: "); printList(); }
Output
If we compile and run the above program then it would produce following Output −
Original List: [ (6,56) (5,40) (4,1) (3,30) (2,20) (1,10) ] Deleted value:(6,56) Deleted value:(5,40) Deleted value:(4,1) Deleted value:(3,30) Deleted value:(2,20) Deleted value:(1,10) List after deleting all items: [ ] Restored List: [ (6,56) (5,40) (4,1) (3,30) (2,20) (1,10) ] Element found: (4,1) List after deleting an item: [ (6,56) (5,40) (3,30) (2,20) (1,10) ] Element not found. List after sorting the data: [ (1,10) (2,20) (3,30) (5,40) (6,56) ] List after reversing the data: [ (6,56) (5,40) (3,30) (2,20) (1,10) ]Advertisements