Unit 1_SLL and DLL.pdf

Data Structures
Sanjivani Rural Education Society’s
Sanjivani College of Engineering, Kopargaon-423603
(An Autonomous Institute Affiliated to Savitribai Phule Pune University, Pune)
NAAC ‘A’ Grade Accredited, ISO 9001:2015 Certified
Department of Information Technology
(NBAAccredited)
Ms. K. D. Patil
Assistant Professor

Linked Organization
• Introduction, References and Basic Types, Linked list ADT,
Implementing Singly linked list, Doubly linked lists, Implementing
Doubly linked list, Implementation of stack using Linked organization,
Applications: well formed-ness of parenthesis, Implementation of
queue using linked organization, cloning Data Structures, Linked list
efficiency
Data Structures – Unit 1 Ms. K. D. Patil Department of Information Technology

Learning Outcomes
• At the end of this unit, student will able to-

Recap!!!
• Data Structures: It is a particular way of organizing data in a computer.
Reference https://www.geeksforgeeks.org/difference-between-linear-and-non-linear-data-structures/

Introduction to Linked Organization
• Drawbacks of Sequential Organization
• The size of array must be known in advance before using it in the program.
• It is almost impossible to expand the size of the array at run time.
• All the elements in the array need to be contiguously stored in the memory.
• Inserting any element in the array needs shifting of all its predecessors.

• The linked list is suitable for use in many kinds of general-purpose databases.
• It allocates the memory dynamically.
• All the nodes of linked list are non-contiguously stored in the memory and linked together
with the help of pointers.
• Sizing is no longer a problem since we do not need to define its size at the time of
declaration.
• List grows as per the program's demand and limited to the available memory space.
• You can use a linked list in many cases in which you use an array, unless you need frequent
random access to individual items using an index.
• Simpler than some other popular structures such as trees.

• A linked list is an ordered collection of finite, homogeneous data elements called
nodes where the linear order is maintained by means of links or pointers
• Node – This part stores the data.
• Link – This part stores the address of the memory location, where the next data of the list is
stored.

Linked List ADT
• // shows how to define a (single) linked list
class LinkedList {
Node head;
class Node
{
int data;
Node next;
Node(int x) // parameterized constructor
{
data = x;
next = null;
}
}
// Method to maintain the collection to be defined
}

Linked List ADT
• Methods
• Insertion operations
• Insertion at front
• Insertion at end
• Insertion at any position
• Traversal
• Printing the collection
• Reversing the ordering of elements

Linked List ADT
• Methods
• Merging operation
• Merging two list into a single list
• Deletion operation
• Deletion from front
• Deletion from end
• Deletion from any position

Types of Linked List
• Single Linked List
• Double Linked List
• Circular Linked List

Insert Operation : Insertion at front (SLL)
public Node insertFront(int data) {
if(head == NULL) // check if linked list is empty
return newNode;
else{ // Create a new node with given data
Node newNode = new Node(data);
newNode.next = head;
// Make the new node as the first node
head = newNode;
Return head;
}
}

Insert Operation : Insertion at End (SLL)
public void insertEnd(int data){
if( head == NULL ){
newNode = new Node(data);
head = newNode;
return head; }
else {
newNode.next = null;
Node temp = head;
while(temp.next != null) {
// traversing the list to get the last node
temp = temp.next;
}
temp.next = newNode;
} }

Insert Operation : Insertion at any position
(SLL)
public void insertKey(int data , int key) {
newNode.next = null;
Node temp = head;
boolean status = false;
while(temp != null) {
if(temp.data == key) {
status = true;
break;
}
temp = temp.next;
}
if(status)
{
newNode.next = temp.next;
temp.next = newNode;
}
}

Delete Operation : Deletion at front (SLL)
• To delete a node from the linked list, we need to do the following steps.
• Find the previous node of the node to be deleted.
• Change the next of the previous node.
• Free memory for the node to be deleted.

Delete Operation : Deletion at front (SLL)
public void deleteFront (int data) {
Node temp = head, prev = null; // Store head node
if (temp != null && temp.data == key) // If head node itself holds the key to be deleted
{
head = temp.next; // Changed head
return;
}

Delete Operation : Deletion at end (SLL)
public void deleteEnd (int data) {
Node temp = head, prev = null; // Store head node
if (temp != null) // If the list is not empty
{
// Move to the end node
prev = temp;
temp = temp.next;
}
x = temp.data;
prev.next = null;
}
return x;
}

Delete Operation : Deletion at any Position
(SLL)
public void deleteAnyPosition (int data, int key) {
Node temp = head, prev = null;
if(temp.data == key) {
prev.next = temp.next; // Display the message
System.out.println(key+ " position element deleted");
break;
}
else {
prev = temp;
temp = temp.next;
}
} }
temp
temp (else part)

Time Complexity of SLL
• Accessing the data in linked list nodes takes linear time because of the need to search
through the entire list via pointers.
• It's also important to note that there is no way of optimizing search in linked lists.
• In the array, we could at least keep the array sorted. However, since we don't know how long
the linked list is, there is no way of performing a binary search:
• Time Complexity is as follows:
• Insertion & Deletion at the beginning and end - O(1)
• Insertion & Deletion at specific position - O(n)
• Indexing - O(n)
• Search - O(n)

Time and Space Complexity of SLL
• Linked lists hold two main pieces of information (the value and pointer) per node.
This means that the amount of data stored increases linearly with the number of
nodes in the list. Therefore, the space complexity of the linked list is O(n)

Doubly Linked List
• Doubly linked list is a data structure that has reference to both the previous and next
nodes in the list. It provides simplicity to traverse, insert and delete the nodes in both
directions in a list.
• It consists of three parts: node data, link to the next node in sequence, link to the
previous node.

Doubly Linked List
• In a doubly linked list, each node contains three data members:
data: The data stored in the node
next: It refers to the reference to the next node
prev: It refers to the reference to the previous node

Doubly Linked List : Define Node, class
Node Creation
public class Node {
int data;
Node prev;
Node next;
public Node(int data)
{
this.data = data;
this.prev = null;
this.next = null;
}
}
class Creation
public class DoublyLinkedList {
Node head;
Node tail;
public DoublyLinkedList()
{
this.head = null;
this.tail = null;
}
}

Doubly Linked List : Traversing
• Start from the head node and follow
the next reference until we reach
the end of the list
• Can also start from the tail node
and follow the prev until we reach
the head of the node
// Traversing from head to the end of the list
public void traverseForward() {
Node current = head;
while (current != null) {
System.out.print(current.data + " ");
current = current.next;
}
}
// Traversing from tail to the head
public void traverseBackward()
{
Node current = tail;
while (current != null) {
System.out.print(current.data + " ");
current = current.prev;
}
}

Doubly Linked List : Insertion
• To insert a node in a doubly linked list
• Create a new node that is going to be inserted
• Update the references of the adjacent nodes to add the new node
• Update the head or tail of the list if the new node is being inserted at the
beginning or end of the list.
• A node can be added to a Doubly Linked List in three ways:
• Insertion at the beginning of the list
• Insertion at a specific position in the list
• Insertion at the end of the list

Doubly Linked List : Insertion at front
• Create a new node to be inserted.
• Set the next pointer of the new node to the current head of the doubly linked list.
• Set the previous pointer of the new node to null, as it will be the new head.
• If the doubly linked list is not empty (i.e., the current head is not null), set the
previous pointer of the current head to the new node.

Doubly Linked List : Insertion at front
public void insertAtBeginning(int data)
{
Node temp = new Node(data);
if (head == null) {
head = temp;
tail = temp;
}
else {
temp.next = head;
head.prev = temp;
head = temp;
}
}
temp

Doubly Linked List : Insertion at end
• Check if the list is empty or not. If it is empty then we will set both the head and tail
to the new node temp.
• If the list is not empty, traverse to the last node of the doubly linked list.
• Set the next pointer of the last node to the new node.
• Set the previous pointer of the new node to the current last node.
• Set the next pointer of the new node to null, as it will be the last node in the list

Doubly Linked List : Insertion at end
public void insertAtEnd(int data)
{
if (tail == null) {
head = temp;
tail = temp;
}
else {
tail.next = temp;
temp.prev = tail;
tail = temp;
}
}
temp

Doubly Linked List : Insertion at specific
position
• Set the next pointer of the new node to the next node of the node at given position.
• Set the previous pointer of the new node to the node at given position.
• Set the next pointer of the node at the given position to the new node.
• If the next node of the new node is not null, set its previous pointer to the new
node.

position
public void insertAtPosition(int data, int position)
{
if (position == 1) {
insertAtBeginning(data);
}
temp
else {
int currPosition = 1;
while (current != null && currPosition < position)
{
currPosition++;
}

position
if (current == null) { insertAtEnd(data); }
else {
temp.next = current;
temp.prev = current.prev;
current.prev.next = temp;
current.prev = temp;
} } }
temp

Doubly Linked List : Deletion
• To delete a node in a doubly linked list
• first, we need to update the references of the adjacent nodes to delete the node
• Update the head or tail of the list if the node is being deleted at the beginning or
end of the list.
• The deletion of a node in a doubly-linked list can be divided into three main
categories:
• Deletion of the first node in the list.
• Deletion of a node at a specific position in the list.
• Deletion of the last node in the list.

Doubly Linked List : Deletion at front
• First, we will check if the list is empty if it is then we return
• if there is only one node in the list then we will set both the head and tail to null
• Otherwise we will simply set the head node to the next node of the current head in
the list, and set the previous reference of the new head node to null.

Doubly Linked List : Deletion at front
public void deleteAtBeginning() {
if (head == null) {
return;
}
if (head == tail) {
head = null;
tail = null;
return;
}
Node temp = head;
head = head.next;
head.prev = null;
temp.next = null;
}
Before Deletion
After Deletion

Doubly Linked List : Deletion at position
• If the given position is 1 (i.e., the first node), update the head of the doubly linked
list to be the next node of the current head.
• Traverse to the node at the given position, keeping track of the previous node.
• Set the next pointer of the previous node to the next node of the node to be
deleted.
• If the next node of the node to be deleted is not null, set its previous pointer to the
previous node.
• Delete the node.

public void delete(int pos)
{
if (head == null) {
return;
}
if (pos == 1) {
deleteAtBeginning();
return;
}
int count = 1;
while (current != null && count != pos) {
count++;
}
Before Deletion
After Deletion of second node

if (current == null) {
System.out.println("Position wrong");
return;
}
if (current == tail) {
deleteAtEnd();
return;
}
current.prev.next = current.next;
current.next.prev = current.prev;
current.prev = null;
current.next = null;
}
Before Deletion
After Deletion of second node

Doubly Linked List : Deletion of last node
• First, we will check if the list is empty if it is then we return
• if there is only one node in the list then we will set both the head and tail to null
• otherwise we will simply set the tail node to the previous node of the current tail
node in the list, set the prev of the current tail node as null and set the next
reference of the new tail node to null.

Doubly Linked List : Deletion of last node
public void deleteAtEnd() {
if (tail == null) {
return;
}
if (head == tail) {
head = null;
tail = null;
return;
}
Node temp = tail;
tail = tail.prev;
tail.next = null;
temp.prev = null;
}
Before Deletion
After Deletion

Time Complexity of DLL
• Time Complexity is as follows:
• Insertion - O(1)
• Deletion - O(1)
• Indexing - O(n)
• Search - O(n)
• Space complexity of the linked list is O(n)

Applications of Linked Organization
• Sparse matrix manipulation
• Polynomial manipulation
• Memory management Applications of linked lists N

References
• R. Lafore, “Data structures and Algorithms in Java”, Pearson education, ISBN: 9788
131718124.
• Michael Goodrich, Roberto Tamassia, Michael H. Goldwasser, “Data Structures and
Algorithms in Java”, 6th edition, wiley publication, ISBN: 978-1-118-77133-4
• R. Gilberg, B. Forouzan, “Data Structure: A Pseudo code approach with C++”, Cengage
Learning.
• https://www.geeksforgeeks.org/linked-list-in-java/
• https://prepinsta.com/java-program/linked-list/
• Animation Video:
https://www.youtube.com/watch?v=iNUS9iZwrVA&ab_channel=TechnologyPremiere

Thank You!!!
Happy Learning!!!

Unit 1_SLL and DLL.pdf

More Related Content

Similar to Unit 1_SLL and DLL.pdf

More from KanchanPatil34

Recently uploaded

Unit 1_SLL and DLL.pdf