This presentation will help in discovering the knowledge of data structures

2. Program : CS(computer Science)
Semester : 3rd
Course : Data Structures & Algorithms
Presented By : Daniyal,Moazzam,Ayyan
Presented To : Prof. Asad Bilal
Topic : Linked List

3. Institute :
Introduction :
A linked list is a linear data structure, in which the
elements are not stored at contiguous memory locations.
The elements in a linked list are linked using pointers It is
implemented on the heap memory rather than the stack
memory as shown in the below image:

5. Types of Linked List
There are Three key types of linked lists:
Singly linked lists.
Doubly linked lists.
Circular linked lists.

6. Singly Linked List
 A Singly Linked List is a specialized case of a linked list. In a
singly linked list, each node links to only the next node in the
sequence i.e.;

7. Creation Of Node
 Node is a combination of two things One is Data & other is
Pointer that stores the address of next node.
Null
Head
5 Next

8. Code of Creating A Node in Singly Linked List
#include <iostream>
using namespace std;
class Node{
public:
int data;
Node* next;
Node (int d){
this-> data= d;
this-> next= Null;
}
};
int main(){
Node* node1 = new Node(5);
Node* head = node1;
}

9. Insertion in Singly Linked List
Insertion At Head:
• Create a Node
Temp Head
Null Null
Temp Head
Temp-> next= Head
Null
Head
Head = Temp
Null
1 5
1 5
1 5
next next
next next
next next

10. Code of Inserting Node at Head in Singly LL
void insertAtHead (Node* &head, int d) {
// new node create
Node* temp = new Node(d);
temp -> next = head;
head = temp;
}
int main(){
Node* node1 = new Node(5);
Node* head = node1;
insertAtHead (head,1);
}

11. Insertion at Tail:
• Create a Node
Temp Head/Tail
Null Null
Head/Tail Temp
Tail-> next = Temp
Null
Head / Temp/Tail
Tail = Temp
Null
2 next 1 next
1 next
Tail
2 next
1 next 2 next

12. Code of Inserting Node at Tail in Singly LL
void insertAtTail (Node* &head, Node* &tail, int d) {
// new node create
Node* temp = new Node(d);
tail -> next = temp;
tail = temp;
}
int main(){
Node* node1 = new Node(1);
Node* head = node1;
Node* tail = node1;
insertAtTail (head,tail,2);
}

13. Insertion at Middle

14. Code of Insertion at Middle
void insertAtPosition(Node* &tail, Node* & head, int position, int d) {
Node* temp = head;
int cnt = 1;
while(cnt < position-1) {
temp = temp->next;
cnt++;
}
//creating a node for d
Node* nodeToInsert = new Node(d);
nodeToInsert -> next = temp -> next;
temp -> next = nodeToInsert;
}
int main(){
insertAtPosition(tail, head, 2, 100);
}

15. Code for Traversing a Linked List
void print(Node* &head) {
if(head == NULL) {
cout << "List is empty "<< endl;
return ;
}
Node* temp = head;
while(temp != NULL ) {
cout << temp -> data << " ";
temp = temp -> next;
}
cout << endl;
}

16. Doubly Linked List
A Doubly Linked List (DLL) contains an extra pointer, typically
called the previous pointer, together with the next pointer and
data which are there in the singly linked list. i.e.;

17. Creation Of Node
 In Doubly linked list Node is a combination of three things One is
Data & other two are Pointer one stores the address of next
node and other stores the address of previous node.
Null Null
Head
5 Next
Previous

18. Code of Creating Node in Doubly Linked List
#include<iostream>
using namespace std;
class Node {
public:
int data;
Node* prev;
Node* next;
//constructor
Node(int d ) {
this-> data = d;
this->prev = NULL;
this->next = NULL;
}
};

19. Code for Insertion in Linked List
 Insertion at Head:
• Create a node
Temp Head
Null Null Null Null
Temp Temp->next = Head
Null Null Null
Temp
Head->Previous = Temp
Null Null
Head Temp
Head = Temp
Null Null
Previ
ous
1
Nex
t
Previ
ous
2
Nex
t
Previ
ous
1
Nex
t
Nex
t
1
1
Previ
ous
Previ
ous
Nex
t
Previ
ous
Previ
ous
Previ
ous
2
2
2
Nex
t
Nex
t
Nex
t
Head

20. Code for insertion at Head
void insertAtHead(Node* &tail, Node* &head, int d)
{
//empty list
if(head == NULL) {
Node* temp = new Node(d);
head = temp;
tail = temp;
}
else{
Node* temp = new Node(d);
temp -> next = head;
head -> prev = temp;
head = temp;
}
}
int main(){
insertAtHead(tail,head, 1);
}

21. Code for Insertion in Linked List
 Insertion at Tail:
• Create a node:
Head / Tail Temp
Null
Null Null Null
Head / Tail Tail->Next = Temp Temp
Null Head
Null
Head
Head->Previous = Temp
Null Null
Tail = Temp
Previ
ous
1
Nex
t
Previ
ous
2
Nex
t
Previ
ous
1
Nex
t
Nex
t
1
Previ
ous
Previ
ous
Previ
ous
2
2
Nex
t
Nex
t
temp/tail

22. Code for insertion at Tail
void insertAtTail(Node* &tail,Node* &head, int d)
{
if(tail == NULL) {
Node* temp = new Node(d);
tail = temp;
head = temp;
}
else{
Node* temp = new Node(d);
tail -> next = temp;
temp -> prev = tail;
tail = temp;
}
}
int main(){
insertAtTail(tail,head, 25);
}

23. Code of insertion at Middle
void insertAtPosition(Node* & tail, Node* &head, int position, int d)
Node* temp = head;
int cnt = 1;
while(cnt < position-1) {
temp = temp->next;
cnt++;
}
//creating a node for d
Node* nodeToInsert = new Node(d);
nodeToInsert ->next = temp -> next;
temp -> next -> prev = nodeToInsert;
temp -> next = nodeToInsert;
nodeToInsert -> prev = temp;
}
int main(){
insertAtPosition(tail, head, 7, 102);
}

24. Code for Traversing a Linked List
void print(Node* head)
{
Node* temp = head ;
while(temp != NULL) {
cout << temp -> data << " ";
temp = temp -> next;
}
cout << endl;
}

25. Circular Linked List
The circular linked list is a linked list where all nodes are
connected to form a circle. In a circular linked list, the first
node and the last node are connected to each other
which forms a circle. There is no NULL at the end.

26. Create a node
In Circular List Node is a combination of two things One is Data &
other is Pointer that stores the address of next node and the last
node points the first node.
1 Next

27. Code for creation a node in Circular Linked List
#include<iostream>
#include<map>
using namespace std;
class Node {
public:
int data;
Node* next;
//constructor
Node(int d) {
this->data = d;
this->next = NULL;
}
int main(){
Node* tail = NULL;
}

28. Code for Insertion a node in circular Linked List
void insertNode(Node* &tail, int element, int d) {
//empty list
if(tail == NULL) {
Node* newNode = new Node(d);
tail = newNode;
newNode -> next = newNode;
}
else{
//non-empty list
//assuming that the element is present in the list
Node* curr = tail;
while(curr->data != element) {
curr = curr -> next;
}
//element found -> curr is representing element wala node
Node* temp = new Node(d);
temp -> next = curr -> next;
curr -> next = temp;
}
}

29. Traversing a Node in Circular Linked List
void print(Node* tail) {
Node* temp = tail;
//empty list
if(tail == NULL) {
cout << "List is Empty "<< endl;
return ;
}
do
{
cout << tail -> data << " ";
tail = tail -> next;
}
while(tail != temp);
cout << endl;
}

30. Code for Deletion
of Nodes

31. Deletion of a Node in Singly Linked List
void deleteNode(int position, Node* & head) {
//deleting first or start node if(position == 1) {
Node* temp = head;
head = head -> next;
//memory free start node
temp -> next = NULL;
delete temp;
}
else
{
//deleting any middle node or last node
Node* curr = head;
Node* prev = NULL;
int cnt = 1;
while(cnt < position) {
prev = curr;
curr = curr -> next;
cnt++;
}
prev -> next = curr -> next;
curr -> next = NULL;
delete curr; }
}

32. Deletion of a Node in Doubly Linked List
void deleteNode(int position, Node* & head) {
//deleting first or start node
if(position == 1) {
Node* temp = head;
temp -> next -> prev = NULL;
head = temp ->next;
temp -> next = NULL;
delete temp;
}
else
{
//deleting any middle node or last node
Node* curr = head;
Node* prev = NULL;
int cnt = 1;
while(cnt < position) {
prev = curr;
curr = curr -> next;
cnt++;
}
curr -> prev = NULL;
prev -> next = curr -> next;
curr -> next = NULL;
delete curr; }
}

33. Deletion of node in Circular Linked List
void deleteNode(Node* &tail, int value) {
//empty list
if(tail == NULL) {
cout << " List is empty, please check again" << endl;
return;
}
else{
//assuming that "value" is present in the Linked List
Node* prev = tail;
Node* curr = prev -> next;
while(curr -> data != value) {
prev = curr;
curr = curr -> next;
}
prev -> next = curr -> next;
//1 Node Linked List
if(curr == prev) {
tail = NULL;
}
//>=2 Node linked list
else if(tail == curr ) {
tail = prev;
} curr -> next = NULL;
delete curr;
} }

36. So, We have our Questions for You People
?