Download - 1 Chapter 2. Linked Lists - Singly linked lists - Doubly linked lists aka lecture 3

1

Chapter 2. Linked Lists

- Singly linked lists- Doubly linked lists

aka lecture 3

2

Dynamic data structures

• Data collections (e.g. stored library records) can vary considerably in size. Arrays not always best solution:– Inserting/deleting a new element requires much of array

to be rewritten– Array size is fixed, must be estimated before use– If only few items held, much of array (hence memory) is

wasted

• Solution: dynamic data structures (linked data structures)

- don’t need to know how many items to expect

- can increase/decrease memory when items added/deleted

3

Examples

• Linked lists• Trees

– Binary trees– Binary search trees– AVL trees– B trees

All use objects which are created dynamically, using memory from a special storage area (pool/heap).

Will look at all of these

4

Singly Linked Lists (Goodrich § 3.2)

• A singly linked list is a concrete data structure consisting of a sequence of nodes

• Each node stores– element– link to the next node (or null)

• First node in list referred to as head

next

elem node

A B C D

head

next

node

element

For an easy introduction we will have a list of Strings

The thing above is our Node

The Node Class for String objects

next

node

element


Sometimes called “head”

next

node

element


Sometimes called “tail”

next

node

element


next

node

element

constructors


next

node

element

get


next

node

element

set

Over loading

next

node

element

Don’t like

better

The list

head

size

head = null

size = 0

if head == null return true; else return false;

NO!

head

size = 3

dog owl catStringList L =

L.addFront(“pig”)

head

size = 4StringList L =

dog owl catpig

Inserting at the Head

Allocate a new node


Allocate a new node

New node points to old head


Allocate a new node


Head points to new node


Allocate a new node


Head points to new node

Increase size counter

Removing at the Head

1. Update head to point to next node in the list

Removing at the Head

1. Update head to point to next node in the list

2. Allow garbage collector to reclaim the former first node

head


dog owl catpig

head


dog owl catpig

YIKES!

Removing at the Tail

• Removing at the tail of a singly linked list is not efficient!

• There is no constant-time way to update the tail to point to the previous node

-Would need to keep a record of which node is the last node and which node points to the last node (even then can’t do it in constant time!)

Java code for a singly linked list of Strings

• In our implementation instance variables are head (reference to head node) and size (number of nodes currently in list)

- Different implementations have different instance variables (some store the head and last/tail, some size (some not)). Will see later, depends what we actually want to do with our list.

• Our implementation is specific to strings. You will need to adapt it to accept values of other types - we will see a generic linked list later.

We have seen this

Simple Remove and Exception

We have seen this

But not this

The toString method

Iterating over a list

The toString method


This is a pointer that traverses the list

The toString method


The toString method


What’s happening here?

The toString method


What’s happening here?

implicit cursor.toString()

The toString method


The toString method


So we don’t have a list (pig,dog,owl,cat,)



… and this is a very nice template (pattern) for iterating over a linked list

45

Checking to see if a node containing a given value is in the list:Use a variable temp of type Node, initially pointing to (node pointed to by) head and progressively pointing to nodes along list until temp points to node containing value of interest, or temp points to null (i.e. end of list):

> Searching for “when”

It’s easy when you know howhead

temp temp tempreturn true

It’s easy when you know howhead

> Searching for “bucket”temp temp temp temp temp temp temp

return falseADS2 Lecture 4

Linear Search: isPresent

(Alice’s slide)


Assume we haven’t foundwhat we are looking for


Our travelling cursor


Quit if we have hit end-of-list or we found what we are looking for


Quit if we have hit end-of-list or we found what we are looking for

NOTE: we quit if “X or Y” is same as we continue if “¬X and ¬Y” De Morgan’s law!!!!


Is this what we are looking for?


Move the cursor down the list


Did we find it?


• note naming conventions (toString, isPresent, …)• note that we do NOT do things like

• if (x > y) then b = true else b = false• please …• note, no assumptions about order in data• how could we use order if we had it?

• note, I use “cursor” rather than “temp” (why?)


NOTE similarity


Is this better?

61ADS2 Lecture 3

62

Inserting at the Tail

1. Allocate a new node2. Insert new element3. Have new node point to

null4. Have old tail node point

to new node5. Update tail to point to

new node

Exercise for you:•Start off with an empty list and add the following Strings, in the order given. This time insert at the tail each time. •Starting from the head read off the Strings.

“how”, “know”, “you”, “when”, “easy”, “it’s”

Note, need to keep a record of the “last” (or “tail”) node. In Java do this via extra instance variable in list. See lecture 5.

ADS2 Lecture 3

Download - 1 Chapter 2. Linked Lists - Singly linked lists - Doubly linked lists aka lecture 3

Top Related