Linklist

LINK LIST

SHEETAL WAGHMARE
M.TECH (Computer Science & Data Processing)
IIT KHARAGPUR
EMAIL-ID: shitu2iitkgp@gmail.com
sheetalw3@gmail.com

Instruction To Use This Presentation
 Dear user I have kept some
animated/executable/video files so it will be easy for
you to understand but that wont be run/play in
slideshow

 To see/run that files you have to exit from slideshow
then click on the icon and also install KM Player

 For example: click on the below icons one by one(
one is executable file and other is video) you will be
able to see the animation

SHEETAL WAGHMARE FROM IIT KHARAGPUR

CONTENTS

SINGLY LINKLIST (INSERTION,DELETION,SORT,SEARCH)
STACK(PUSH,POP)
QUEUE(ADD,REMOVE)
CIRCULAR LINKLIST
DOUBLE ENDED QUEUE
CIRCULAR QUEUE
PRIORITY QUEUE
DOUBLY LINKLIST(INSERTION,DELETION,SORT,SEARCH)

SHEETAL WAGHMARE FROM IIT
KHARAGPUR

What’s wrong with Array and Why lists?
 Disadvantages of arrays as storage data structures:
 slow searching in unordered array
 slow insertion in ordered array
 Fixed size
 Linked lists solve some of these problems

KHARAGPUR

List Implementation using Linked Lists
 Linked list
 Linear collection of self-referential class objects, called nodes
 Connected by pointer links
 Accessed via a pointer to the first node of the list
 Link pointer in the last node is set to null to mark the list’s end
 Use a linked list instead of an array when
 You have an unpredictable number of data elements
 You want to insert and delete quickly.

KHARAGPUR

Linked Lists

A B C

Head

 A linked list is a series of connected nodes
 Each node contains at least
 A piece of data (any type)
 Pointer to the next node in the list
 Head: pointer to the first node node
 The last node points to NULL
A

SHEETAL WAGHMARE FROM IIT data pointer
KHARAGPUR

Part II: Linked Lists
As an abstract data type, a list is a finite sequence (possibly empty) of
elements with basic operations that vary from one application to
another.

Basic operations commonly include:

Construction: Allocate and initialize a list object (usually empty)
Empty: Check if list is empty
Insert: Add an item to the list at any point
Delete: Remove an item from the list at any point

Traverse: Go through the list or a part of it, accessing and
processing theWAGHMARE in the order they are stored
SHEETAL
elements FROM IIT
KHARAGPUR

Linked Representation
 Data structure for a linked list:

first

Node

•Data
•Link (pointer): used to store the address of the next node.

KHARAGPUR

Anatomy of a linked list
 A linked list consists of:
 A sequence of nodes

myList

a b c d

Each node contains a value
and a link (pointer or reference) to some other node
The last node contains a null link
The list may (or may not) have a header
KHARAGPUR

More terminology
 A node’s successor is the next node in the sequence
 The last node has no successor
 A node’s predecessor is the previous node in the sequence
 The first node has no predecessor
 A list’s length is the number of elements in it
 A list may be empty (contain no elements)

KHARAGPUR

Linked Lists
 Types of linked lists:
 Singly linked list
 Begins with a pointer to the first node
 Terminates with a null pointer
 Only traversed in one direction
 Circular, singly linked
 Pointer in the last node points
back to the first node
 Doubly linked list
 Two “start pointers” – first element and last element
 Each node has a forward pointer and a backward pointer
 Allows traversals both forwards and backwards
 Circular, doubly linked list
 Forward pointer of the last node points to the first node and backward pointer
of the first node points to the last node
KHARAGPUR

Declarations
 First you must declare a data structure that will be used
for the nodes. For example, the following struct could
be used to create a list where each node holds a float:

KHARAGPUR

Conventions of Linked List
There are several conventions for the link to indicate the end of
the list.
1. A null link that points to no node (0 or NULL)
2. A dummy node that contains no item
3. A reference back to the first node, making it a circular list.

KHARAGPUR

Convention of the linked list
 A special list is maintained which consists of unused memory
cells. This list, which has its own pointer, is called the list of
available space or the free storage list or the free pool.
 The operating system of a computer may periodically collect all
the deleted space onto the free storage list. Any technique
which does this collection is called garbage collection.

KHARAGPUR

Conventions

 Sometimes new data are to be inserted into the data structure but
there is no available space, i.e. the free storage list is empty. This
situation is usually called overflow.
means when AVAIL = NULL and there is an insertion.

 The term underflow refers to the situation where one wants to delete
data from a data structure that is empty. The programmer may handle
underflow by printing the message UNDERFLOW.
means If START = NULL,

KHARAGPUR

Inserting to the Front
head 93
head 48 17 142

 There is no work to find the correct location
 Empty or not, head will point to the right location

KHARAGPUR

Insert first position
 INFIRST(INFO,START,AVAIL,ITEM)
1. [OVERFLOW] if AVAIL=NULL then write:OVERFLOW and exit.
2. [remove first node from AVAIL list]
set NEW=AVAIL and AVAIL=LINK[AVAIL].
3. Set INFO[NEW]=ITEM [copies new data into new node]
4. Set LINK[NEW]=START [new node now points to original first node]
5. Set START=NEW [changes START so it points to the new node]
6. Exit

KHARAGPUR

Inserting to the Middle
head 17 48 142
93
//
142
//

 Used when order is important
 Go to the node that should follow the one to
add
 Recursion or iteration

KHARAGPUR

Algorithm
 INSLOC[INFO,LINK,START,AVAIL,LOC,ITEM]
1. [OVERFLOW] if AVAIL=NULL then write OVERFLOW and exit.
2. [remove first node from AVAIL list]
set NEW:=AVAIL and AVAIL:=LINK[AVAIL]
3. Set INFO[NEW]:=ITEM[copies new data into new node]
4. If LOC=NULL then [insert as a first node ]
set LINK[NEW]:=START and START:=NEW
Else [insert after node with location Loc]
set LINK[NEW]:=LINK[LOC] and LINK[LOC]:=NEW
[end of if structure]
5. Exit

after.exe

KHARAGPUR

Inserting to the End
head 48 17 142
//93 //

 Find the end of the list
(when at NIL)
 Recursion or iteration

KHARAGPUR

Inserting to End of a Linked List
 Recursively traverse the list until at end
 Then:
 Create new node at current
 Fill in data
 Terminate the new node’s next pointer to point to NIL

KHARAGPUR

 1. allocate memory for the new node.
 2. Assign value to the data of the new node.
 3. if START is NULL then(if the list is empty)
 a. Make START point to the NEW node.
 b. make LAST point to the new node
 c. go to step 6.
 4. Make the next field of LAST point to the New node
 5. Mark the new node as LAST.
 6. Make the next field of the new node point to NULL.

KHARAGPUR

 INLAST(INFO,START,AVAIL,ITEM)
1. [OVERFLOW] if AVAIL=NULL then write:OVERFLOW and exit.
2, [remove first node from AVAIL list]
set NEW=AVAIL and AVAIL=LINK[AVAIL].
3. Set INFO[NEW]=ITEM [copies new data into new node]
4. If START=NULL
Set START=NEW and LOC=START
5. Repeat step 6 untill LINK[LOC] != NULL
6. Set LOC=LINK[LOC]
7. Set LINK[LOC]=NEW
8. Exit

KHARAGPUR

Inserting at the End of a Linked List
head 48 17 142 53

current Rnew_data 53




SHEETAL WAGHMARE FROM IIT end.exe
KHARAGPUR

Find the desired element
FINDB(INFO,LINK,START,ITEM,LOC,LOCP]
This function finds the location LOC of the first node N which contains ITEM and the
location LOCP of the node preceding N. if ITEM does not appear in the list, then the
function set LOC=NULL and it item appears in the first node then it sets LOCP=NULL]
1.[list empty?] if START=NULL then set LOC=NULL and
LOCP=NULL and return.
2. [ITEM in first node?] if INFO[START]==ITEM then
Set LOC=START and LCOP=NULL and return.
3 . Set SAVE=START and PTR=LINK[START] [intializes
pointers]
4. Repeat step 5 and 6 while PTR != NULL
5. Contd…….
KHARAGPUR

Contd….
 5. if INFO[PTR]=ITEM then
Set LOC= PTR and LOCP=SAVE and return
[end of IF structure]
6. set SAVE=PTR and PTR=LINK[PTR] [ updates pointers]
[end of step 4 loop]
7. set LOC=NULL. [search unsuccessful]
8. return .

KHARAGPUR

Delete
 DELETE(INFO,LINK,START,AVAIL,ITEM)
 This algorithm deletes from a linked list the first node N which
contains the given ITEM of information
 1.[use function FINDB] call FINDB
 2. if LOC=NULL then write ITEM not in list and exit
 3. [delete node]
 if LOCP=NULL then set START=LINK[START] [delete first
node]
 Else set LINK[ LOCP]=LINK[LOC]
 [end of if structure]
 4.[return deleted node to the AVAIL list]
 set LINK[LOC]=AVAIL and AVAIL=LOC
 Exit deletion.exe
KHARAGPUR

Sorting

KHARAGPUR

Singly Linked Lists and Arrays
Singly linked list Array
Elements are stored in linear Elements are stored in linear
order, accessible with links. order, accessible with an
index.

Do not have a fixed size. Have a fixed size.

Cannot access the previous Can access the previous
element directly. element easily.

No binary search. Binary search.

KHARAGPUR

ARRAY IMPLEMENTATION OF STACK
PUSH:-
1.if(top==max-1)
1.print(stack overflow)
2.else
1.top=top+1
2.stack arr[top]=pushed item
3.endif
end algorithm

POP:-
1.if (top==-1)
1.print(stack underflow)
2.else
1.print(popped element is stack arr[top])
2.top=top-1
3.end if
end algorithm
KHARAGPUR

QUEUE IMPLEMENTATION
 Procedure Q INSERT (Q, FRONT, REAR,MAX,Y)
1.[Overflow ?]
IF REAR>=N
THEN WRITE ("OVERFLOW")
RETURN
2.REAR<-REAR+1
3.Q[REAR]<-Y
4.IF FRONT=0
THEN FRONT<-1
RETURN
 ENQUEUE:-
if(rear==(MAX-1))
print (queue overflow)
elseif (front==-1)
front=0
rear=rear+1
queue_arr[rear]=added_item
endif

KHARAGPUR

 DEQUEUE
if(front==-1 OR front>rear)
print(queue underflow)
else
print(element deleted from queue,queue_arr[front])
front=front+1
end if
end algorithm
 Procedure Q DELETE (Q,FRONT, REAR)
1.UNDERFLOW
IF FRONT=0
THEN WRITE ("UNDERFLOW")
RETURN
2.Y<-Q[FRONT]
3.IF FRONT=REAR
THEN FRONT<-REAR<-0
ELSE REAR<-REAR+1
4.RETURN Y
KHARAGPUR

PRIORITY QUEUE

priority queue.swf


Circular Link list

KHARAGPUR

10
 Insert into an empty
list
New Rear
•Insert into Head of circular link list

10 20 40 55 70

New Cur Prev
Rear
New->next = Cur;
Prev->next = New;

KHARAGPUR

 Insert to middle of a Circular Linked List between
Pre and Cur
New->next = Cur;
Prev->next = New;

10 20 55 70

40
Prev Cur Rear
KHARAGPUR New

CIRCULAR QUEUE circular queue.swf

Procedure CQINSERT(FRONT, Procedure CQDELETE
REAR, Q , N ,Y) (FRONT, REAR, Q)
 1.IF R=N  1.[Underflow?]
 THEN R<-1  IF FRONT =0
 ELSE R<-R+1  WRITE UNDERFLOW
 2.[Overflow?]  2.Y<-Q[REAR]
 IF R=F  3.IF FRONT=REAR
 THEN WRITE ("OVERFLOW")  THEN FRONT<-REAR<-0
 RETURN  RETURN Y
 3.Q[R]<-Y  4.IF FRONT= N
 4.  THEN F<-1
 IF FRONT=0  ELSE F<-F+1
 FRONT<-1 
 RETURN Y
KHARAGPUR

Doubly Linklist
 Traversing the list
 Traversal of a doubly linked list can be in either
direction. In fact, the direction of traversal can change
many times

KHARAGPUR

 Forward:
node := list.firstNode
while node ≠ null
<do something with node.data> //print the data
node := node.next

 Backward:
node := list.lastNode
while node ≠ null
<do something with node.data> // print data
node := node.prev

KHARAGPUR

Inserting into Doubly Linklist
 Inserting a node
 These symmetric functions insert a node either
after or before a given node, with the diagram
demonstrating after:

KHARAGPUR

Insert After

function insertAfter(List list, Node node, Node newNode)
newNode.prev := node
newNode.next := node.next
if node.next == null
list.lastNode := newNode
else
node.next.prev := newNode
node.next := newNode

KHARAGPUR

Insert Before
 function insertBefore(List list, Node node, Node newNode)
newNode.prev := node.prev
newNode.next := node
if node.prev == null
list.firstNode := newNode
else
node.prev.next := newNode
node.prev := newNode

KHARAGPUR

Insert at the Beginning

 function insertBeginning(List list, Node newNode)
if list.firstNode == null
list.firstNode := newNode
list.lastNode := newNode
newNode.prev := null
newNode.next := null
else
insertBefore(list, list.firstNode, newNode)

KHARAGPUR

Insert at the End

 function insertEnd(List list, Node newNode)
if list.lastNode == null
insertBeginning(list, newNode)
else insertAfter(list, list.lastNode, newNode)

KHARAGPUR

Deletion
 Deleting a node
 Deletion of a node is easier than insertion, but requires special
handling if the node to be removed is the firstNode or lastNode:

 function remove(List list, Node node)
if node.prev == null
list.firstNode := node.next
else
node.prev.next := node.next
if node.next == null
list.lastNode := node.prev
else node.next.prev := node.prev
destroy node

KHARAGPUR

Multi-lists
 Multi-lists are essentially the technique of embedding
multiple lists into a single data structure.
 A multi-list has more than one next pointer, like a doubly
linked list, but the pointers create separate lists.


Multi-lists

head

KHARAGPUR

Multi-lists (Not Required)
head
head

KHARAGPUR

EXAMPLE

KHARAGPUR

Linklist

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Linklist

Similar to Linklist (20)

More from SHEETAL WAGHMARE

More from SHEETAL WAGHMARE (7)

Recently uploaded

Recently uploaded (20)

Linklist