Download presentation

Presentation is loading. Please wait.

1
Linked Lists Chapter 4

2
**Linked List : Definition**

A collection of data items of the same type that are stored in separate objects referred to as "nodes". Each node contains, in addition to its data value(s) a reference to an object of the same type. This reference is used to connect one node to the next node in the list.

3
**Linked List : Definition**

An external reference usually referred to as the "head" of the list contains the address of the first node object. Diagram of a sample linked list containing character data: head A B C D null

4
**A Linked List Node Class**

First attempt at a class for a linked list of integers: public class IntegerNode { public int item; public IntegerNode next; } The problem with this solution is that it uses no data hiding - all data fields in a class should be "private" and data should be set/retrieved only with constructors, accessors, and mutators.

5
**Final IntegerNode Class**

public class IntegerNode { private int item; private IntegerNode next; public IntegerNode(int newItem) { item = newItem; next = null; } // end constructor public IntegerNode(int newItem, IntegerNode nextNode) { next = nextNode;

6
**Final IntegerNode Class (2)**

public void setItem(int newItem) { item = newItem; } // end setItem public int getItem() { return item; } // end getitem public void setNext(IntegerNode nextNode) { next = nextNode; } // end setNext public IntegerNode getNext() { return next; } // end getNext } // end class IntegerNode

7
**A Polymorphic Linked List Node**

public class Node { private Object item; private Node next; public Node(Object newItem) { item = newItem; next = null; } // end constructor public Node(Object newItem, Node nextNode) { next = nextNode;

8
**A Polymorphic Linked List Node**

public void setItem(Object newItem) { item = newItem; } // end setItem public Object getItem() { return item; } // end getitem public void setNext(Node nextNode) { next = nextNode; } // end setNext public Node getNext() { return next; } // end getNext } // end class Node To instantiate a Node containing an Integer: Node n = new Node(new Integer(6)); or containing a character: Node n = new Node(new Character('A'));

9
**Inserting a Node into a Linked List**

newNode = new Node ( Integer (5) ); newNode.setNext ( cur ); prev.setNext ( newNode ); prev cur head 1 3 7 9 newNode 5

10
**Inserting a Node into a Linked List (First Node)**

newNode = new Node ( Integer (5) ); newNode.setNext ( head ); head = newNode; prev cur head 1 3 7 9 newNode 5

11
**Deleting a Node from a Linked List**

prev.setNext ( cur.getNext() ); prev cur head 1 3 7 9

12
**Traversing a Linked List**

for ( Node cur = head ; cur != null ; cur = cur.getNext() ) { System.out.println ( cur.getItem() ); } cur head 1 3 7 9 null

13
**Recursive Linked List Traversal**

private static void writeList(Node nextNode) { // // Writes a list of objects. // Precondition: The linked list is referenced by nextNode. // Postcondition: The list is displayed. The linked list // and nextNode are unchanged. if (nextNode != null) { // write the first data object System.out.println(nextNode.getItem()); // write the list minus its first node writeList(nextNode.getNext()); } // end if } // end writeList

14
**Removing Tail Recursion**

private static void writeList(Node nextNode) { // // Writes a list of objects. // Precondition: The linked list is referenced by nextNode. // Postcondition: The list is displayed. The linked list // and nextNode are unchanged. // nextNode holds the head of the list on entry while (nextNode != null) { // if becomes while // write the data object referenced by nextNode System.out.println(nextNode.getItem()); // replace recursive call with parameter update nextNode = nextNode.getNext(); } // end while } // end writeList

15
**Insert and Delete operations on an empty list**

Problem with insertion and deletion methods: They require special cases and different actions for first nodes. The addition of a dummy head node to the linked list eliminates the special cases -the node does not contain any data -an empty list consists of head and the dummy node

16
**Abstract Data Type List**

A linked list is actually just one implementation of the higher object which is a General List A General List could be implemented using arrays rather than linked lists How would that implementation change from the linked list implementation?

17
**Criteria for Linked Lists - ACIDS**

Decide which General List implementation is better by observing General List operations: ACIDS tests how easily are operations done Add Change Inspect Delete Sort

18
**ACIDS Criteria Linked lists are better for adding or deleting items.**

Insertion and deletion require constant time complexity once position is located. In array based lists insertion and deletion require linear time complexity since all n items might have to be moved.

19
**ACIDS Criteria Arrays are better for sorting or finding items.**

Allow random access to elements. This allows the use of divide and conquer algorithms.

20
Interface for ADT List // **************************************************** // Interface for the ADT list public interface ListInterface { // list operations: public boolean isEmpty(); public int size(); public void addFirst(Comparable item); public void addLast(Comparable item); public void remove(Comparable item); public Node find(Comparable item); public void removeAll(); } // end ListInterface

21
**Comparable Node Class public class Node { private Comparable item;**

private Node next; public Node(Comparable newItem) { item = newItem; next = null; } // end constructor public Node(Comparable newItem, Node nextNode) { next = nextNode;

22
**Comparable Node Class (2)**

public void setItem(Comparable newItem) { item = newItem; } // end setItem public Comparable getItem() { return item; } // end getitem public void setNext(Node nextNode) { next = nextNode; } // end setNext public Node getNext() { return next; } // end getNext } // end class Node

23
**Implementation of ADT List**

// **************************************************** // Reference-based implementation of ADT list. public class List implements ListInterface { // reference to linked list of items private Node head; private int numItems; // number of items in list public List() { numItems = 0; head = null; } // end default constructor public boolean isEmpty( ) { return numItems == 0; } // end isEmpty public int size( ) { return numItems; } // end size

24
**Implementation of ADT List (2)**

public Node find(Comparable findItem) { // Locates a specified node in a linked list. // Returns a reference to the desired node. Node curr = head; // Note order (if curr == null, do not use curr.getItem) while((curr != null) && (findItem.compareTo(curr.getItem()) != 0)) { curr = curr.getNext(); } // end while return curr; } // end find public void addFirst(Comparable item) { // insert a new first node into the list Node newNode = new Node(item, head); head = newNode; numItems++; } // end addFirst

25
**Implementation of ADT List (3)**

public void addLast(Comparable item) { // insert a new last node into the list Node curr = head; if (curr == null) { // insert a new first (and only) node Node newNode = new Node(item, head); head = newNode; } else { while(curr.getNext() != null) curr = curr.getNext(); // curr now contains a ref to the last node on the list Node newNode = new Node(item); curr.setNext(newNode); numItems++; } // end addLast

26
**Implementation of ADT List (4)**

public void remove(Comparable removeItem) { if(isEmpty()) return; Node curr = head, prev = null; if(curr == null) return; while((curr!=null)&&(removeItem.compareTo(curr.getItem())!= 0)) { prev = curr; curr = curr.getNext(); } // end while - if curr == null removeItem was not found if(curr != null) { // if node is not found do nothing if(curr == head) // remove first node head = head.getNext(); else prev.setNext(curr.getNext()); // remove node after prev numItems--; } } // end remove

27
**Implementation of ADT List (5)**

public void removeAll() { // setting head to null causes list to be // unreachable and thus marked for garbage collection head = null; numItems = 0; } // end removeAll

28
**Implementation of ADT List (6)**

public void printList() { // calls the recursive method to print the linked list printNode(head); System.out.println(); } private void printNode(Node curr) { // the recursive printing method if(curr != null){ System.out.print(curr.getItem()+" "); printNode(curr.getNext());

29
**Implementation of ADT List (7)**

public void printReverse() { // calls the recursive method to print reversed printReverse(head); // Signature forces the method below System.out.println(); } // Distinguished from above by its signature (parameter list) private void printReverse(Node curr) { // the recursive printing method to list IN REVERSE if(curr != null){ // Recursively print everything AFTER this node printReverse(curr.getNext()); // before printing this node itself System.out.print(curr.getItem()+" "); } // end List

30
**Iterative reversed listing Why recursion is your friend**

//NOTE: this is not in fact part of the implementation private void printReverse(Node head) { // the iterative printing method to list IN REVERSE if(head != null){ int n, // Number of items to skip skip; // Loop for skipping for ( n = this.numItems-1; n >= 0; n-- ) { Node curr = head; for ( skip = 0; skip < n; skip++ ) { curr = curr.getNext(); } System.out.print(curr.getItem()+" ");

31
Doubly Linked Lists Even though each node in a singly linked list has a well defined predecessor it is impossible to move from a node to its predecessor Doubly linked lists solve this problem by allowing movement in both directions through a list Accomplished by adding a pointer to each node which contains the address of the previous node

32
**Doubly Linked List Implementation**

public class Node { private Comparable item; private Node next; private Node prev; public Node(Comparable newItem) { item = newItem; next = null; prev = null; } // end constructor public Node(Comparable newItem, Node nextNode, Node prevNode) { next = nextNode; prev = prevNode;

33
**Doubly Linked List Implementation (2)**

Assume: add set and get methods for prev reference to the Node class. possibly change the insertion and deletion methods in the List class.

34
**Doubly Linked List Insertion**

cur A M Z X tmp // inserting AFTER cur tmp = new Node(Character('X'), cur.next, cur); cur.next.prev = tmp; cur.next = tmp;

35
**Doubly Linked List Deletion**

A M Z cur // deleting cur cur.Next.Prev = cur.Prev; cur.Prev.Next = cur.Next; cur = null;

36
**Header Nodes for Doubly Linked Lists**

Inserting /deleting first and last nodes are special cases for doubly linked lists (with head and tail references) By adding a dummy header node to both ends of the list -a single routine with no conditions can be used to insert into or delete from doubly linked lists.

37
**Circular Linked Lists The last node in the list points to first**

B C D Head The last node in the list points to first A single node list points to itself Problems can arise when traversing the list to its end - easy to construct an infinite loop

38
**Solution: Use Object Inequality**

Node cur = head; // Bottom-driven loop, so enter only if non-zero passes if ( cur != null ) { do { System.out.println ( cur.getItem() ); cur = cur.getNext() ) } while ( cur != head ); }

Similar presentations

OK

CS2006 - Data Structures I Chapter 6 Stacks I 2 Topics ADT Stack Stack Operations Using ADT Stack Line editor Bracket checking Special-Palindromes Implementation.

CS2006 - Data Structures I Chapter 6 Stacks I 2 Topics ADT Stack Stack Operations Using ADT Stack Line editor Bracket checking Special-Palindromes Implementation.

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google

Ppt on children's day Ppt on national defence academy Open ppt on ipad 2 Ppt on adr and gdr in india Ppt on chromosomes and genes and alleles Download seminar ppt on android Ppt on mammals and egg laying animals Ppt on conservation of land resources in india Ppt on formal education system Ppt on water pollution remedies