List Implementations That Link Data

Chapter 6

2

Chapter Contents

Linked Data Forming a Chains

The Class Node A Linked

Implementation Adding to End of List Adding at Given Position Method remove Method replace Method getEntry

Method contains Remaining methods Using a Class Node with

Set and Get Methods

Tail References Revision of List

Pros and Cons of Using Chain

Java Class Library:LinkedList

3

Linked Data

Consider the analogy of desks in a classroom Placed in classroom as needed Each desk has a unique id, the “address” The desks are linked by keeping the address of

another chair We have a chain of chairs

4

Linked Data

A chain of 5 desks.

5

Forming a Chain First desk placed in room

Blank desk top, no links Address of the first chair given to teacher

One desk in the room.

6

Forming a Chain Second student arrives, takes a desk

Address of first desk placed on new desk Instructor “remembers” address of new desk

Two linked desks

7

Forming a Chain Third desk arrives

New desk gets address of second desk Instructor remembers address of new desk

Three linked desks, newest desk first.

8

Forming Another Chain

This time the first student is always at the beginning of the chain Instructor only remembers first address

The address of a new desk is placed on the previous desk (at end of chain) End of chain found by following links Newest desk does not have a pointer address to

any other desk

9

Forming Another Chain

Two linked desks, newest desk last.

10

Forming Another Chain

Three linked desks, newest desk last.

11

Forming Another Chain

Five linked desks, newest desk last.

12

Adding New Desk

Consider the requirement to organize the chain alphabetically New arrivals are placed somewhere in the chain,

not necessarily at the end Possibilities for placement of a new desk

Case 1: Before all current desks Case 2: Between two existing desks Case 3: After all current desks

13

Adding New Desk: Case 1

Chain of desks prior to adding a new desk to beginning of the chain

14

Adding New Desk: Case 1

Addition of a new desk to beginning of a chain of desks

15

Adding New Desk: Case 2

Two consecutive desks within a chain prior to adding new desk between

16

Adding New Desk: Case 2

Addition of a new desk between two other desks.

17

Removing Desk

Removing an item from a chain Possible cases

Case 1: Desk to be removed is first in the chain Case 2: Desk to be removed is between two

current desks Case 3: Desk to be removed is last in the chain

18

Removing Desk: Case 1

A chain of desks just prior to removing first desk.

19

Removing Desk: Case 1

A chain of desks just after removing first desk.

20

Removing Desk: Case 2

A chain of desks just prior to removing a desk between two other desks.

21

Removing Desk: Case 2

A chain of desks just after removing a desk between two other desks.

22

Removing Desk: Case 3

Before and after removing last desk from a chain.

23

The Class Node

Nodes are objects that are linked together to form a data structure

We will use nodes with two data fields A reference to an entry in the list

(the person sitting at the desk) A reference to another node

(the address on the paper on the desk)

24

The Class Node

Two linked nodes with (a) primitive data; (b) class/object data

private class Node

{

private T data; //data value in that node entry

private Node next; //link to next node

…

}

25

Inner Class Nodeprivate class Node{

private T data; //data value in that node entryprivate Node next; //link to next node

private Node (T dataPortion){

data = dataPortion;next = null;

} //end constructor

private Node( T dataPortion, Node nextNode){

data = dataPortion;next = nextNode;

} // end constructor

}

26

A Linked Implementation of the ADT List

Use a chain of nodes Remember the address of the first node in the

chain Record a reference to the first node

The “head reference”

The implementation contains the class Node as an inner class

27

A Linked Implementation of the ADT List

public class LList<T> implements ListInterface<T>{

private Node firstNode; //head reference to fist nodeprivate Node lastNode; // tail reference to last nodeprivate int length; //number of entries in list

public LList(){

clear();} //end constructor

public final void clear() {

firstNode = null;lastNode = null;length = 0;

} // end clear

// implementation of the public methods add, remove, replace, getEntry, contains, getLength, isEmpty, isFull, and display…

}

28

Adding to the End of An empty List

(a) An empty list and a new node;(b) after adding a new node to a list that was empty

29

Adding to the End of An Non-empty List

A chain of nodes (a) just prior to adding a node at the end; (b) just after adding a node at the end.

30

Adding to the End of the List

public boolean add(T newEntry) {

Node newNode = new Node(newEntry);

if (isEmpty())firstNode = newNode;

elselastNode.next = newNode;

lastNode = newNode;

length++;return true;

}

31

Adding to the Beginning of the List

A chain of nodes (a) prior to adding a node at the beginning; (b) after adding a node at the beginning.

32

Adding at a Given Position Within the List

A chain of nodes (a) prior to adding node between adjacent nodes; (b) after adding node between

adjacent nodes

33

Adding at a Given Position Within the List

The following Java Statements implement these steps: Node newNode = new Node(newEntry); Node nodeBefore = getNodeAt(newPosition -1); Node nodeAfter = nodeBefore.next; newNode.next = nodeAfter; nodeBefore.next = newNode;

34

Removing the first node

A chain of nodes (a) prior to removing first node; (b) after removing the first node

Need to see if there is only one node, if yes, update the lastnode.

35

Removing other than the beginning of the list

A chain of nodes (a) prior to removing interior node; (b) after removing interior node

Need to see if nodeToRemove is at the end, if yes, update the lastnode.

36

The Method remove: first node

firstNode = firstNode.next;

The Method remove: other than the beginning

Node nodeBefore = getNodeAt(givenPosition -1); Node nodeToRemove = nodeBefore.next; Node nodeAfter = nodeToRemove.next; nodeBefore.next = nodeAfter; nodeToRemove = null;

37

Using Class Node that Has Set and Get Methods

Class Node is an inner class The class LList can access private data fields

directly Stylistically better to use the Set and Get

methods of the class Node Thus better to use statements such as:currentNode.getData(); ordesiredNode.setData(newEntry);

38

Using Class Node that Has Set and Get Methods

private T getData(){

return data;}private void setData(T newData){

data = newData;}

private Node getNextNode(){

return next;}

39

Tail References

Consider a set of data where we repeatedly add data to the end of the list

Each time the getNodeAt method must traverse the whole list This is inefficient

Solution: maintain a pointer that always keeps track of the end of the chain The tail reference

40

Tail References

A linked chain with a head and tail reference.

41

Tail References

When adding to an empty list Both head and tail references must point to the

new solitary node When adding to a non empty list

No more need to traverse to the end of the list lastNode points to it Adjust lastNode.next to new node and lastNode to new node

42

Tail References

Adding a node to the end of a nonempty chain that has a tail reference

43

Pros and Cons of a Chain for an ADT List

The chain (list) can grow as large as necessary

Can add and remove nodes without shifting existing entries

But … Must traverse a chain to determine where to

make addition/deletion Retrieving an entry requires traversal

As opposed to direct access in an array

44

Java Class Library: The Class LinkedList

The standard java package java.util contains the class LinkedList

This class implements the interface List Contains additional methods

addFirst()addLast()removeFirst()removeLast()getFirst()getLast()