• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Linklist
 

Linklist

on

  • 620 views

SINGLY LINKLIST (INSERTION,DELETION,SORT,SEARCH) ...

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)

Statistics

Views

Total Views
620
Views on SlideShare
620
Embed Views
0

Actions

Likes
1
Downloads
28
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Linklist Linklist Presentation Transcript

    • 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 animationSHEETAL WAGHMARE FROM IIT KHARAGPUR
    • CONTENTSSINGLY LINKLIST (INSERTION,DELETION,SORT,SEARCH)STACK(PUSH,POP)QUEUE(ADD,REMOVE)CIRCULAR LINKLISTDOUBLE ENDED QUEUECIRCULAR QUEUEPRIORITY QUEUEDOUBLY 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 SHEETAL WAGHMARE FROM IIT 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. SHEETAL WAGHMARE FROM IIT 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 ListsAs an abstract data type, a list is a finite sequence (possibly empty) ofelements with basic operations that vary from one application toanother.Basic operations commonly include:Construction: Allocate and initialize a list object (usually empty)Empty: Check if list is emptyInsert: Add an item to the list at any pointDelete: Remove an item from the list at any pointTraverse: Go through the list or a part of it, accessing andprocessing 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. SHEETAL WAGHMARE FROM IIT 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 SHEETAL WAGHMARE FROM IIT 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) SHEETAL WAGHMARE FROM IIT 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 SHEETAL WAGHMARE FROM IIT 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: SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Conventions of Linked ListThere 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 item3. A reference back to the first node, making it a circular list. SHEETAL WAGHMARE FROM IIT 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. SHEETAL WAGHMARE FROM IIT 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, SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Inserting to the Fronthead 93 head 48 17 142 There is no work to find the correct location Empty or not, head will point to the right location SHEETAL WAGHMARE FROM IIT 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 SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Inserting to the Middlehead 17 48 142 93 // 142 // Used when order is important Go to the node that should follow the one to add  Recursion or iteration SHEETAL WAGHMARE FROM IIT 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:=NEWElse [insert after node with location Loc] set LINK[NEW]:=LINK[LOC] and LINK[LOC]:=NEW[end of if structure]5. Exit after.exe SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Inserting to the Endhead 48 17 142 //93 // Find the end of the list (when at NIL)  Recursion or iteration SHEETAL WAGHMARE FROM IIT 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 SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Inserting to End of a Linked List 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. SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Inserting to End of a Linked List 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=NULLSet START=NEW and LOC=START5. Repeat step 6 untill LINK[LOC] != NULL6. Set LOC=LINK[LOC]7. Set LINK[LOC]=NEW8. Exit SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Inserting at the End of a Linked List head 48 17 142 53 current Rnew_data 53 current Rnew_data 53 current Rnew_data 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. [end of if structure] 2. [ITEM in first node?] if INFO[START]==ITEM then Set LOC=START and LCOP=NULL and return. [end of if structure] 3 . Set SAVE=START and PTR=LINK[START] [intializes pointers] 4. Repeat step 5 and 6 while PTR != NULL 5. Contd……. SHEETAL WAGHMARE FROM IIT 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 . SHEETAL WAGHMARE FROM IIT 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 SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • SortingSHEETAL WAGHMARE FROM IITKHARAGPUR
    • 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. SHEETAL WAGHMARE FROM IIT 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 SHEETAL WAGHMARE FROM IIT 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 SHEETAL WAGHMARE FROM IIT 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 SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • PRIORITY QUEUE priority queue.swfSHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Circular Link list SHEETAL WAGHMARE FROM IIT 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; SHEETAL WAGHMARE FROM IIT 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 RearSHEETAL WAGHMARE FROM IITKHARAGPUR New
    • CIRCULAR QUEUE circular queue.swfProcedure CQINSERT(FRONT, Procedure CQDELETEREAR, 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 SHEETAL WAGHMARE FROM IIT 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 timesSHEETAL WAGHMARE FROM IITKHARAGPUR
    •  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 SHEETAL WAGHMARE FROM IIT 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:SHEETAL WAGHMARE FROM IITKHARAGPUR
    • 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 SHEETAL WAGHMARE FROM IIT 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 SHEETAL WAGHMARE FROM IIT 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) SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Insert at the End function insertEnd(List list, Node newNode) if list.lastNode == null insertBeginning(list, newNode) else insertAfter(list, list.lastNode, newNode) SHEETAL WAGHMARE FROM IIT 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 nodeSHEETAL WAGHMARE FROM IITKHARAGPUR
    • 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.SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Multi-listshead SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Multi-listshead SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • Multi-lists (Not Required) headhead SHEETAL WAGHMARE FROM IIT KHARAGPUR
    • EXAMPLE SHEETAL WAGHMARE FROM IIT KHARAGPUR