Download presentation

Presentation is loading. Please wait.

Published byMustafa Lindly Modified over 3 years ago

1
Linked Lists Contents 1.LinkedList implements the Interface List 2.Doubly Linked List implementation of common methods a.boolean add( Object x) -- append to end of the list b.boolean add(int i, Object x) – insert at position i c.boolean remove(int i) – remove object at position i 3.Singly Linked List -- outline of methods 4.Circularly Linked List

2
Linked Lists A LinkedList implements the interface List There are a number of ways in which a LinkedList can be implemented internally, but each implementation should provide the client (code that uses a LinkedList) with a single common set of operations that can be evoked by messages to the LinkedList object. Types of LinkedList implementations include: Doubly linked list Singly linked list Circular-linked list We will examine how the main List operations are implemented in each of these alternatives

3
Linked Lists Doubly-linked List A LinkedList is a connected sequence of Nodes. It is composed of two classes of objects: LinkedLists and Nodes. class Node { //Node methods go here //attributes protected Node pred, succ; public Object data; } class LinkedList implements List { //class Node (see left) is declared here //implementation of List methods goes here //attributes private Node head, tail; private int size; } Node is an internal class visible only to LinkedList objects. The protected attributes: pred and succ, have file scope and are thus directly accessible to the methods in class LinkedList

4
Linked Lists predsuccdatapredsuccdata p This is the the Node that p points toThis Node is the successor of the Node that p points to Useful terminology for referring to Nodes in a LinkedList Nodes are not named objects, but are referred to by a pointer Node p = new Node(theObject); p.succ = new Node(nextObject);

5
Linked Lists LinkedList aList = new LinkedList( ); head size tail aList 0 aList.add( new Integer(24) ); 24 Integer temp = new Integer(24); Node p = new Node (temp); p if (head == 0) head = p; tail = p; size++; 1 aList.add( new Integer(21) ); Integer temp = new Integer(21); Node p = new Node(temp); p 21 //head != 0 tail.succ = p; p.pred = tail; tail = p; size++; 2

6
Linked Lists Putting it together public boolean add (Object theObj) { Node p = new Node(theObj); if (head == 0) head = p; else { tail.succ = p; p.pred = tail; } tail = p; size++; return true; }

7
Linked Lists Inserting an object at position i aList head size tail 3 102124 Insert at front of the list (i == 0) Integer temp = new Integer (3); Node p = new Node(temp); p 3 p.pred = 0; p.succ = head; The successor of Node referenced by p is Node referenced by head if (head != 0) head.pred = p; else (head ==0) -- inserting into an empty list -- set tail = p head = p; size++; 4

8
Linked Lists Inserting an object at position i aList head size tail 3 102124 Inserting at end of non-empty list (i==size) Integer temp = new Integer (3); Node p = new Node(temp); 41 p if (i == size) { //insert at end p.pred = tail; p s predecessor is the Node tail points to p.succ = 0; tail.succ = p; Make Node p points to the successor of Node tail points to tail = p; The Node p points to is now at the end of the list size++; 4

9
Linked Lists Inserting an object at position i aList head size tail 3 102124 Inserting at general position – (0 <= i < size) Integer temp = new Integer (3); Node p = new Node(temp); p 23 Move a handle to the Node at position i – Let i = 2 in this example int count = 0; Node q = head; q count = 0 while (count < i) { count++; q = q.getNext( ); } count = 1 q count = 2 q Insert new Node before the Node that q points to. p.pred = q.getPrev( )); p.succ = q; q.getPrev( ).succ = p; //3 q.pred = p; //4 size++; 4 The order of these statements is important – statement 3 MUST precede statement 4.

10
Linked Lists Putting it all together public boolean add(int i, Object x) { if (i size) { //range error System.err.println (error – index out of range); System.exit(1); //better – throw Exception } Node p = new Node(x); if (i ==0) { //insert at front p.pred = 0; //superfluous p.succ = head; if (head !=0) head.pred = p; else tail = p; head = p; } else if (i == size) { //insert at end p.succ = 0; p.pred = tail; tail.succ = p; tail = p; } else { //insert at general position int count = 0; Node q = head; while (count < i) { count++; q = q.getNext( ); } p.pred = q.getPrev( ); p.succ = q; q.getPrev( ).succ = p; q.pred = p; } size++; return true; } q.getPrev( ) returns a reference to the previous Node – Make the successor of that Node = p.

11
Linked Lists Removing objects from a List head size tail aList 2124 41 3 Remove first Node – (i == 0) Node p = head; if (i ==0) { //remove first Node head = p.getNext( ); if (head != 0) head.pred = 0; else //removing last node tail = 0; size--; } p 2 Automatic garbage collection reclaims the unreferenced Node when p goes out of scope.

12
Linked Lists Removing objects from a List head size tail aList 2124 41 3 Remove the last node – (i == size – 1) if (i ==size-1) { //remove last Node p = tail; //Node * p; set previously if (head != tail) { tail.getPrev().succ = 0; tail = tail.getPrev( ); } else { //removing last node tail = 0; head = 0; } size--; } p tail.getPrev( ) 2 Automatic garbage collection reclaims memory when p goes out of scope

13
Linked Lists Removing objects from a List head size tail aList 2124 41 3 Remove Node in general position – ( i ==1) Node p = head; int pos = 0; while (pos < i) { //find node to cut p = p.getNext( ); //move handle pos++; } p.getPrev( ).succ = p.succ; p.getNext( ).pred = p.pred; size--; } p pos = 0 p pos = 1 p.getPrev( )p.getNext( ) 2 The Node referenced by p is deleted when p goes out of scope

14
Linked Lists Bringing it all back home public boolean remove(int i) { if (i = size) { //range error System.err.println (error – index out of range); System.exit(1); } Node p; if (i == 0 ) // remove first node p = head; head = p.succ; if (head != 0) head.pred = 0; else tail = 0; } //end if else if (i == size-1) { //remove last node p = tail; if (head != tail) { tail.getPrev.succ = 0; tail = tail.getPrev( ); } else { head = 0; tail = 0; } } //end else if else { //remove Node in general position p = head; int pos = 0; while (pos < i ) { //move handle p = p.getNext( ); pos++ } p.getPrev.succ = p.succ; p.getNext.pred = p.pred; } //end else p.setPrev(0); p.setNext(0); //for safety size--; return true; } //end remove

15
Linked Lists Singly-linked Lists public class Node { public Node(Object x) {…} public void setNext( ) {…} public Node getNext( ) {…} public Object getData( ) {…} private Node succ; private Object data; } size head tail aList pp p 3 212447 Move two handles in sequence until p reaches position i – (let i = 2) Node p = head, q = head; q for(int pos = 0; pos < i; pos++) { q = p; p = p.getNext( ); } pos = 0 q pos = 1 pos =2 To perform an insert at pos, insert the new Node after the Node that q references and before the Node that p references To remove the Node at index pos, remove the Node that p references. Use the Node that q references to reattach the links. Implementing methods add( ) and remove( ) will be left as an exercise. datasucc

16
Linked Lists Circularly Linked Lists size head aList 2124 47 3 A circularly-linked list is a singly-linked list where the last Node refers back to the first Node in the list. A tail reference is not used.

17
Linked Lists Traversing a circularly-linked list size head aList 2124 47 3 To traverse a circularly-linked list, move a pair of handles until pos == i (or p.getNext( ) == head) Locate the node containing x = 47 Node p = head, q; while (p.getNext( ) != head && !p.getData( ).equals(x)) { q = p; p = p.getNext( ); } pq p q p An insertion can be performed after the Node that q references, and a removal will remove the Node referenced by p, using q to reattach the list.

18
Linked Lists A circularly-linked list with a single Node size head aList 21 1 Special case – List contains a single Node The succ field of a single Node contains a handle to itself Constructor for Node public Node(Object obj) { data = obj; succ = this ; } Create a Node referring to itself and overwrite the succ field using setNext( ) when adding to the list if Node is not the first Node to be added. The only special circumstances about adding the first or removing the last Node from a circularly-linked list involve setting the contents of head. The object under construction

Similar presentations

Presentation is loading. Please wait....

OK

Linked Lists.

Linked Lists.

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on product portfolio management Good manners for kids ppt on batteries Ppt on waves tides and ocean currents lab Ppt on current trends in hrm Ppt on team building and motivation Ppt on care of public property information Download ppt on animal kingdom classification Ppt on model view controller in java Ppt on strategic management process Ppt on isobars and isotopes of elements