Linked Lists in Action This chapter introduces linked lists. This presentation shows how to...

Linked Lists in Action

This chapter introduces linked lists.

This presentation shows how to implement the most common operations on linked lists.

LINKED LISTS

Collection Classes - LINKED LIST The Java 2 platform contains a Collections API

This group of classes represent various data structures that store and manage objects

It includes classes such as ArrayList and LinkedListArrayList and LinkedList

22

Abstract Data Types – A Review

An abstract data type (ADT) is :

an organized collection of information containing

a set of operations used to manage that information

The set of operations includes methods such as add, delete , find etc..

The set of operations/methods define the interfaceinterface to to the ADTthe ADT

33

Abstract Data Types

A List ADT, for instance would define the operations that be used with the list, such as add, delete.

We have looked an array implementation of a list, now we will look at a Linked List.

44

Static vs. Dynamic Structures

A static data structure has a fixed size

Arrays are static; once you define the number of elements it can hold, it doesn’t change.

55

DRAWBACKS OF ARRAYS

The array implementation of our collection has one serious drawback:

you must know the maximum number of items in your collection when you create it.

66

Linked Lists

WHAT IF YOU DON’T KNOW THE NUMBER OF ITEMS BEFOREHAND?????

WHAT IF THE NUMBER OF ITEMS WILL VARY OVER TIME?

We need a dynamic data structure that grows and shrinks as necessary

77

Array Limitations Arrays

Simple, Fast

but Must specify size at construction time WHICH GIVES RISE TO “Murphy’s law”

Construct an array with space for n n = twice your estimate of largest collection

Tomorrow you’ll need n+1

88

Linked Lists - it is never fullit is never fullA linked list is a very flexible,

dynamic data structure:

no preset size required

items may be added to it or deleted from it at will.

No need to increase capacity when full -

it is never fullit is never full

99

Object References

Recall that an object reference is a variable that stores the address of an object in memory.

A reference can also be called a pointer (to an object in memory)

and they are often depicted graphically:studentstudent

John Smith407253.57

1010

References as Links

Object references can be used to create links between objects

Suppose a Person class contains a reference to another Person object

John Smith 40725

3.57 Person Jane

Jane Jones588213.72

1111

Self-Referential Objects

A Person object, for instance, could contain a reference variable to another Person object:

public class Person{ private String name; private String address;

private Person next; // a link to another Person object

// whatever else

}

1212

Intermediate Nodes

Problem:

Objects should not have to deal with the

details of the structure in which they are stored

E.g., the person class stored a link to the next person object in the list

1313

Linked Lists Instead, we can use a separate node class that :

holds a reference to the stored object and

a link to the next node in the list

This type of reference can be used to form a Linked List.

1414

A Linked List of Persons

So by having a separate structure to contain the list of persons:

One object(object 1) is not dependent for its existence on another object (object 2)

And removing object2 would not require removing object1.

1515

Object References - ListNode class

Consider an object that contains a reference to another object of the same type:

class ListNode<T>class ListNode<T>

{{ T data;T data; // object stored in data– e.g. Client object// object stored in data– e.g. Client object

ListNode next; ListNode next; // reference to the next node // reference to the next node

}}

1616

data = Client

next = refers to next listnode

Two objects of this class can be instantiated and chained together.

The next reference of one Node object refers to the next node in the list.

The second objectsecond object’s’s next reference next reference refers to a third Node third Node object, and so on,

creating a linked list of Node objects.

1717

Client 1

next

Client2

next

NODE S IN THE LIST

Each node will contain some data as specified by the programmer.

This constitutes a linked listlinked list

1818

Linked Nodes In a linked listlinked list, each item is allocated space as it is allocated space as it is

added to the list. (called dynamically)added to the list. (called dynamically)

A link (next) is kept within each item to the next Client in the list.

1919

Client 1

next

Client2

next

Each node of the list has two elements :

1. the object being stored in the list, e.g. a client and

2. a reference to the next node in the list (nextnext)

The nextnext reference in the last node in the list contains a NULL pointer to indicate that it is the end or tend or tail of the list.

2020

Client 1

nextnext

Client2

next = null

Linked Lists As items are added to a list,

memory for a node is dynamically allocated. (Allocated as needed)

Thus the number of items that may be added to a list

is limited only by the amount of memory available.

2121

HEAD OF THE LIST The variable (or handle) which holds on to the list is

simply a pointer(reference) to the node at the

head of the list.

It is called headhead

Head Head holds the memory holds the memory address of the first nodeaddress of the first node

2222

Clientnext = null

Linked List -Flexible space use Dynamically allocate space for each element as

needed Includes a pointer to the next item

Linked list Each ListNode of the list contains

the data item (e.g. a Cliente.g. a Client)

nextnext - a reference to the next node

Data Next

object 2323

Linked Lists - WHAT IS HEAD?

Let’s implement a Collection structure – a linked list -

which has a reference to the first node calledHEAD

Head is initially NULL

Head = null

2424

Linked Lists The Linked List structure has a reference to the list: head which is initially NULL

TO Add first item to the head of the list Allocate memory for the ListNode Set its data reference to some object Set next to NULL Set head to reference the new node

Data Next

object

HeadListNode

2525

Add second item to the head of the list Allocate memory for the node - NewNodeNewNodeSet its data reference to some object (object2)Set new node .next to point to the node Head is pointing toSet Head to point to (reference) the new node

Data Next

object1

Head

FIRST node

Data Next

object2

NewNodeNewNode

2626

2727

Linked Lists Add second item to the head of the list

Allocate memory for the node Set its data pointer to an object Set new node next to point to the node Head is pointing to Set Head to point to new node

Data Next

object1

Head

node

Data Next

object2

New node

Constructors of a ListNodeclass ListNode{amine the constructor for the class.

// This is one of This is one of the the constructors constructors in the ListNode clasin the ListNode classspublic ListNode(T initialData){ data = initialData; // data for the node next = null; // reference to next node}

where :

data - is the initial data of a new node e.g. a client , next - a reference to the next node in the list.

2828

How to start the linked list Declare a head node to point to the first node in the

list . To create the first node

ListNode head = null; // initialize head

// now create the first node

head = new ListNode (“dan”);

Head now refers to a one-node linked list.

The data is “dan” and next is equal to null. See previous slide constructor

2929

We will use We will use StringsStrings as as data .

data

next

dan

null

// Constructor ListNodepublic class ListNode{ private String data; private ListNode next; // constructors}Create the first Node:

head = new ListNode (“dan”);

Declarations for linked ListsDeclarations for linked Lists

Head

3030

ListNode

data

next

nat

Declarations for linked Lists For this example, each node in the

linked list is an object of the class ListNode, as shown here with String data

next

null

public class ListNode{ private String data; private ListNode next; ...// Constructor sets next to null initally}

data

next

jay

datadan

Head

3131

Declarations for linked Lists

Each Each ListNode also contains a next reference which refers to the next ListNode in the list.

datajay

datanat

public class ListNode { private String data; private ListNode next; ... }

datadan

next

null

next

HeadHead

3232

A program keeps track of the FIRST node by STORING ITS ADDRESS IN HEAD.

Head is a reference to a ListNode. Head is a reference to a ListNode. It holds the address of the first node. It holds the address of the first node.

Head and next both refer to list nodesHead and next both refer to list nodes They store the address of the next nodeThey store the address of the next node

data

next

dan

data

next

jay

datanat

null

head

5050

5050

next =52next =52

5252

next =60next =60

6060

50 is the address of the first node

50 is the address of the first node

50

Head

3333

52 is the address of the second node

52 is the address of the second node

NEXT holds an address

In the previous slide, the head node holds the address of the first node which is 50

The second node’ next reference holds the address of the next node which is 52.

The third node’ next reference holds the address of the next node which is 60.

3434

Declarations for Linked Lists

We represent the empty list by storing

null in the head reference.

ListNode head = null;

headnull

3535

The null reference

The null reference is a special JAVA constant.

It means the reference has no address

so it does not refer to anything.

3636

Null referencesNull references

Null references are used in several instances.

When a object is declared but not instantiated. Client client;

Client is initially null

For the next part next part of the final node in a linked list.

When we have an empty list, the head and tail reference variables are null.

3737

Null Pointer Exceptions

When a reference variable is null,

you cannot call any of the methods associated with variables’s class. E.g.;

ListNode head = null; // head is a null referemce

head.next; // error - no next reference yet exists.

The second line will result in a NullPointerException.

3838

Inserting Nodes at the front of the list. To add to front of list,

we create a reference to the head node and call it head.

Remember head is initially null.

The code to create the head node is:

ListNode head = null;

3939

4040

We could use this code if the list is initially empty:ListNode head = null;ListNode head = null;

// create the node -- uses constructorcreate the node -- uses constructorListNode newnode = new ListNode(data1, ListNode newnode = new ListNode(data1, null);null);head = newnode;head = newnode; //Point head to it //Point head to it

ORBelow is a shorter version of the previous two lines:

ListNode head = new ListNode(data1, null)ListNode head = new ListNode(data1, null)

Inserting an Node at the Front

head data1

null

This is a constructor IN THE Linkedlist class:

public ListNode ( T data, ListNode nxt){ data = initialData; next = nxt;}

INSERTING A NODE

head = new ListNode(data1, head = new ListNode(data1, null);null);

//Where head is initially null

head = new ListNode(data1, head = new ListNode(data1, null);null);

//Where head is initially null

Does the constructor workcorrectly for the

first node on a new

list ?

4141

Creating the first node in a list - Review

head = new ListNode( data1, null)

creates a new node with data1 as the data and null is stored in next.next.

Head now holds the address of the node with data1 :

4242

Head = 50

data1

null

5050

Inserting an Node at the Front Create a new node…red boxes

are addresses of nodes.

Head holds the address of the first node - 50

data1

nullheadhead

A new nodeA new node

5050

50

4343

Let’s add another node to the front of the listLet’s add another node to the front of the list


We want to add a new entry, data2, to the front of the linked list shown here.

null

head data1

New node

50

4444

50

Inserting an Node at the Front Create a new node... Place the data in the new

node's data field – this is data2.

Next = nullhead

data1

data2

5050

Create the new node:

ListNode newnode = new ListNode( data2, ListNode newnode = new ListNode( data2, null)null)

Create the new node:

ListNode newnode = new ListNode( data2, ListNode newnode = new ListNode( data2, null)null)

4545

50

newnodenewnode

null

Inserting an Node at the Front of the list, reassign head Inserting an Node at the Front of the list, reassign head to itto it

null

head

data2

data1

next = 50next = 50

5050

Connect the next (50) reference of newnode to the node head is currently pointing to.

So now So now headhead and and newnode.nextnewnode.next point to the same nodepoint to the same node

newnode

4646

ListNode newnode = new ListNode( data2, null)ListNode newnode = new ListNode( data2, null)

newnode.next = headnewnode.next = head

newnode.next refers to the same node as head

newnode.nextnewnode.next


null

head

ListNode newnode = new Listnode(data2, null) newnode.next = head; head = newnode ; // we store address 84 in head

data2 is now the new first node of the linked list – its address is 84

data1data284

NEXT = 50

84

4747

50Finally, we point head to the newnode head = newnode;head = newnode;Head holds address of Head holds address of the newnode - 84the newnode - 84

Newnode’s Newnode’s address is 84address is 84

4848

The brute force way to insert the node at the head of the list would The brute force way to insert the node at the head of the list would be:be:

public void insertFirst(T data){// create a nodeListNode newnode = new ListNode(data, null);

if(isEmpty()) // is the list is empty head = newnode; // point head to the new node

else // list is not empty

{ // set the next pointer of newnode to what head is pointing to newnode.next = head ; head = newnode // point head to newnode }}

CHALLENGECHALLENGE

For homework, extra credit pts on your quiz if you can do the insertion code in the previous slide in one line of code.

You may assume that head has been set to null.

4949

Adding to a list

This strategy is fast and efficient, but each item is added to the head of the list.

An alternative is a list which contains both head and tail pointers:

The code for Add is modified to make a list in which new nodes are added to the list at the end.

5050

Caution! Always make sure Always make sure

that your linked list that your linked list methods work methods work correctly with an correctly with an empty listempty list.

EMPTY LIST

Linked Lists Add time

Constant - independent of n – no loops Search time

Worst case - n

Data Next

object

Head

Collection

nodeData Next

object2

node

5252

Pseudocode for Inserting ListNodes

Nodes are often inserted at places other than the front of a linked list.

There is a general pseudocode that you can follow for any insertion function. . .

First determine if the node is the first node , if so, call method insertFirst(data)

5353

Otherwise (if the new node will not be first):

then a reference named current must be placed on the list

This special node is called the selected node and the new node is inserted right after the selected node.

Pseudocode for Inserting NodesPseudocode for Inserting Nodes

5454


dan

jay

nat

nullhead

Otherwise (if the new node will not be first): Start by setting a reference named current to refer to the

node before the new node.

THE NEW NODE WILL BEINSERTED AFTER THE NODE CURRENT IS POINTING TO

THE NEW NODE WILL BEINSERTED AFTER THE NODE CURRENT IS POINTING TO

current

next

5555


What is the name of this link?

dan

jay

nat

nullhead


Start by setting a reference named current to refer to the node just before the new node's position.

Look at the linkwhich is in the node

previous

Look at the linkwhich is in the node

previous

Look at the link(next) which Look at the link(next) which is is in the nodein the node current iscurrent ispointing topointing to

Look at the link(next) which Look at the link(next) which is is in the nodein the node current iscurrent ispointing topointing to

next

5656

current


What is the name of this link ?

dan

jay

nat

nullhead

Otherwise (if the new node will not be first): Start by setting a reference named current to refer

to the node which is just before the new node's position

current

next

5757

This link is called current.next Or current.getNext()

This link is called current.next Or current.getNext()

Pseudocode for Inserting Nodes

dan

jay

nullhead

Otherwise (if the new node will not be first):Otherwise (if the new node will not be first):

Start by setting a reference named current to refer to the node which is just before the new node's position

Current refers to the headof a small linked

list, with jay and nat

Current refers to the headof a small linked

list, with jay and nat

current

next

5858

nat


dan

10

nat

nullhead


Let’s insert a new nodeafter the node containing dan

Let’s insert a new nodeafter the node containing dan

jay

currentcurrent

current

next

5959

next

next

These are the contructors for the Listnodepublic ListNode() // NO PARAMETERS// NO PARAMETERS

{{

data = null; // data for the node

next = null; // reference to next node

}

///************************************************************

public ListNode(T initialData) // with THE DATA PARAMETE// with THE DATA PARAMETERR

{

data = initialData; // data for the node

next = null; // reference to next node

}

///************************************************************

public ListNode(T initialData, Listnode nextnode) // both paramters{

data = initialData; // data for the node

next = nextNode; // reference to next node

}

6060

6161

InsertAfterInsertAfter Let create the new node and put Fred in it

dannat

sam

head

jaycurrent

NEWNODE

ListNode newnode = new ListNode(); newnode.data = “Fred”;newnode.data = “Fred”; newnode.next = current.next;newnode.next = current.next; current.next = newnode;current.next = newnode;

fred

next

next

null

6161

next

next

InsertAfter

public void insertAfter(T newData){ // where newData = “Fred” ListNode newnode = new ListNode(); newnode.data = newData;

// Now we have to attach newnode.next to the list newnode.next = current.next; current.next = newnode;}

We use constructor with one parameter

6262

Then : Store the address in current.next into

newnode.next so they both refer to ‘jay’

dannat

sam

head

jaycurrent

NEWNODE

pvoid insertAfter(String newData){ ListNode newnode = new ListNode();ListNode newnode = new ListNode(); newnode.data = newData;newnode.data = newData; newnode.next = current.next;newnode.next = current.next; current.next = newnode;current.next = newnode;}}

fred

nextnext

next

null

6363

next

next

6464

dannat

sam

head

jaycurrent

NEWNODE

pvoid insertAfter(String newData){ ListNode newnode = new ListNode();ListNode newnode = new ListNode(); newnode.data = newData;newnode.data = newData; newnode.next = current.next;newnode.next = current.next; current.next = newnode;}

fred

nextnext

next

null

6464

next

next

Now, point current.next to newnodeNow, point current.next to newnode

Reduce number of lines

6565

public void insertAfter(String newData) { ListNode newnode = new

ListNode(); newnode.data = newData; newnode.next = current.next; current.next = newnode; }

Can we reduce the first three lines of code in this method to one line?

InsertAfterInsertAfter Then : Reduce the first three lines to one line

dannat

sam

head

jay

current

current

public void insertAfter(String newData){ // first three lines in one line ListNode newnode = new ListNode(newData, current.next)ListNode newnode = new ListNode(newData, current.next) current.next = newnode;}

20

next

next

fred

head

6666

next

null

next

NEWNODE

6767

InsertAfter - a shorter versionInsertAfter - a shorter version Then : Set the current.next to refer to the new node

dannat

samhead

jay

current

current

// Let’s compact the code all to one line:public void insertAfter(String newData){

ListNode newnode = new ListNode(newData, current.next)ListNode newnode = new ListNode(newData, current.next) current.next = newnode;}

fred

next

next

head

6767

next

null

next

NEWNODE

Pseudocode for Removing ListNodes

Nodes often need to be removed from a linked list.

As with insertion, we can

remove a node from the front of a list,

remove a node from elsewhere.

We’ll look at the technique for removing a node from the front of a linked list.

6868

Removing the Head Node

fred nat sam

null

headdan

head = head.next;Draw the change that this statement will make to the linked list.

next

6969

next next


fred nat sam

nullhead

dan

head = head.next;This points head to node after the first Node

next

7070

next next


head = head.next; orhead = head.getNext();// if node class is separateNow the node is deleted from the head of the list.

fred nat sam

nullhead

dan

7171

Summary

It is easy to insert or remove a node at the front of a list.

You also need a technique for inserting or removing a node elsewhere.

We will now provide an implementation that will

delete at the head node and also

elsewhere on the list.

7272

Deleting a node not at the head

Deleting a node not at the head is similar to adding a node to the middle of the list.

current will point to the node to be deleted.

WE also need another reference to the node that is just before current.

This reference is called previous :

7373

Deleting from the middle calls find(target) method Deleting from the middle calls find(target) method firstfirst

fred jay sam

nullhead

dan

deleteNode()

Previous refers to the node before the one to be deleted - Current refers to node to be deleted

previous

This arrow is previous.next

This arrow is current.next

current

7474

next next

Deleting a Node

The method remove{T data} requires that current refer to the node to be deleted.

Remove calls Find(T data) which assigns current to refer to the node to be deleted.

It also places previous on the node behind current

7575

Deleting Anywhere on the List

We call the method witWe call the method with: h: Remove(T data)

fred nat sam

null

This arrow is previous. nextThis arrow is previous. next This arrow is current.nextcurrent.nextThis arrow is current.nextcurrent.next

previous current

7676

head

dan

next next

previous.nextprevious.next points to the points to the node current node current refers to. current.nextrefers to. current.next points to the node after points to the node after the node to be deleted (“sam”).the node to be deleted (“sam”).

Deleting from the middle

fred nat sam

nullhead

dan

The next portion of previous now points(refers) to the node after current. We must also advance current to the next nodeprevious current.

previous.next = current.next; current = current.next;

next

7777

nextnext

Deleting anywhere on the list 1) previous.next now contains the

address of the node (Sam) . 2) Current 2) Current is advanced to refer to the

node which contains “Sam”

NOW previous.next and current previous.next and current refer to same node refer to same node

fred

nat

sam

null

previous current.



7878

nextnext

Removing a node -The Find method puts previous and current on the list

where the node is to be deleted

public void remove(T data) { // remove first calls the find method find(data);

if(current != null && previous != null){ previous.next = current.next; current = current.next;} }

7979

Remove()

The remove(T data) method works even if the node is a tail node.

In this case, the next of the previous node will be assigned the null value.

8080

Deleting from the list at the tailDeleting from the list at the tail

fred nat sam

null

head

dan

The next portion of previous now points to what current.next points, and current points to null. previous current


null

8181

next

Pseudo-code for Removing a nodepublic void remove() {

// if current and previous are not null

// point previous.next to what current.next is pointing to

// Point current to what current.next is pointing to

// else if at the head node – point head to what

//current.next is pointing to and set current// equal to headAlways check for the Empty List FIRSTAlways check for the Empty List FIRST

}}

8282

Traversing a Linked List

To traverse a linked list, we must first assign a next variable - such as cur - to some node.

To traverse the list, we move cur to the next node by using the code:

cur = cur.next // advance cur to the next node

This assignment says “move cur to point to what cur.next points to” - which

advances cur to next node. Or we can use:

cur = cur.getNext{} // uses getter method for ‘next’8383

Searching a linked list To find a particular node in a list,

we create a method that returns the node that contains the element. The method:

public ListNode Find(T target) { }

searches for a node containing the target (the data)

It returns a reference to the first node that contains the target data.

To call the method , use:

ListNode node = ListNode node = Find(target)Find(target)8484

onList()

Because Find( target) returns a ListNode, we need to write another method that will return a boolean.

Our application class should not have to deal with ListNodes.

Our methods should be implementation independent.

The user does not have to know if we used an ArrayList of Linked List

So returning a boolean can be done in any class8585

The Find (target ) method returns a ListNode

public ListNode find (target)

This is necessary for some methods that use it.

However, outside classes will not know what a Listnode is. SO

We write another Find method for the outside classes that returns a boolean

public boolean find (target)

public boolean find(T target)8686

Searching / traversing a list.public boolean Find(T target)

{

// this is how you traverse a linked list

boolean found = false;

ListNode curr; // declare variable to traverse the list

for(curr = head; curr!= null; curr= curr.getNext()) {

// put in code to find target and return true if found

} // close loop

return found ;

}// close method

8787

Doubly Linked Lists

Doubly linked lists have a pointer to the preceding item as well as one to the next.

They permit scanning or searching of the list in both directions.

(To go backwards in a simple list, it is necessary to go back to the start and scan forwards.)

Many applications require searching backwards and forwards through sections of a list:

8888

Linked Lists - Doubly linked

Doubly linked lists Can be scanned in both directions

public ListNode(T initialData,) { data = initialData; Listnode previous, next; }

head

tail

prev prev prev

8989

nextnext

Doubly Linked Lists In this case, the node structure is altered to have two

links:

class ListNode

{

T data;

ListNode previous, next; // link to node before

} // and after

9090

Circularly Linked Lists

By ensuring that the tail of the list is always pointing to the head,

we can build a circularly linked list.

A circularly linked list would more likely be used in an application which required "round-robin" scheduling or processing.

9191

Analysis of Linked Operations Since the order is irrelevant, and

there is no capacity to expand

adding an element to the List is O(1)

Removing a particular element, because it must be found, is O(n)

Removing any item, any item, can be done at the head or tail and thus is O(1);

9292

Linked List The linked list implementation has exchanged

flexibility for efficiency –

On some systems, the need to allocate memory can be relatively expensive.

Pre-allocation in the array-based implementation is generally more efficient.

BUT, there are circumstances where Linked List is needed.

9393

LINKED LIST VS ARRAY

However, there are many situations where a linked list is more efficient e.g.

Applications that are unsorted - WHY?

Applications where the size is relatively small . WHY?

More examples of such trade-offs will be found later.

9494

Free Memory Memory is just an array of data.

Each entry has an address and a value

After a series of memory allocations and

de-allocations, there are blocks of free memory

scattered throughout the available heap space.

9595

Memory allocation

In order to be able to re-use this memory,

memory allocators will link freed blocks together in a free memory list

The computer keeps references to blocks of free memory

9696

Free Memory An external pointer(head) points to the

first block in the free list.

When a new block of memory is requested,

the allocator scans the free list looking for a suitable block

It will delete the block from the free list

(re-linking the free list around the deleted block).

9797

Free Memory

Many variations of memory allocators have been proposed:

Refer to a text on operating systems or implementation of functional languages for more details.

The entry in the index under garbage collection will address it.

9898

An abstract data type defines a type of structure that stores data ( e.g. an array)

It stores the data in a class along with the operations that can be performed on that data

e.g. An ArrayList, A LinkedList, a Stack, A Graph etc.

Abstract Data Types

9999

Abstract Data TYPE

The Abstract Data Type lists a set of abstract methods

Each class that implements the ADT must implement all these methods.

E.g. in the List interface has methods like:

add, delete etc.

100100

Cohesion

Well- designed ADT’s have strong Well- designed ADT’s have strong relationships between the relationships between the parts of a parts of a class class so so

CohesionCohesion is a goal that you should is a goal that you should seek in designing your ADT’sseek in designing your ADT’s

101101

Well-designed ADT’s have little or no Well-designed ADT’s have little or no couplingcoupling To create our Abstract Data Type we need

to be sure that the methods are cohesive.

Coupling measures the strength of the relationship between two components.

It represents the glue that holds two separate components together.

This should be minimal in an object-oriented program

102102

Coupling and Cohesion

We want to minimize the degree of coupling between any two classes of our system

so they can operate as independently independently as possibleas possible. .

Thus any changes we make will only effect a small portion of the program.

ALL the methods for the Linked List should be in the Linked List class.

103103

CLASS INDEPENDENCE FROM OTHER CLASsES

This makes errors easier to track

and less likely to affect

another part of our system.

104104

Coupling and Cohesion

We want to maximize the cohesion in a class

Cohesion means that the more tightly related the parts of an item are

the more logical its operations are.

Coupling means that an object depends on another class for some of its operations or data

This creates systems that are very difficult to debug

105105

ADT’s

Cohesion is the strength of the relationships among the parts of one component

so that the parts of the component can be thought of as one piece.

E.g. in a Client class, we would have a firstname and lastname etc. but not have a reference to another client defined inside it.

106106

Objectives

Your goals are:

1.a method should only accomplish one logical

function

2. an object should represent a single concept or entity. A Student , A Client

An ADT by its definition minimizes the coupling between objects.

107107

Linked Lists in Action This chapter introduces linked lists. This presentation shows how to...

Documents

Transcript of Linked Lists in Action This chapter introduces linked lists. This presentation shows how to...