View
267
Download
1
Category
Tags:
Preview:
Citation preview
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
The Node Class for String objects
Sometimes called “head”
next
node
element
The Node Class for String objects
Sometimes called “tail”
next
node
element
The Node Class for String objects
next
node
element
constructors
The Node Class for String objects
next
node
element
get
The Node Class for String objects
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
Inserting at the Head
Allocate a new node
Inserting at the Head
Allocate a new node
New node points to old head
Inserting at the Head
Allocate a new node
New node points to old head
Head points to new node
Inserting at the Head
Allocate a new node
New node points to old head
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
size = 4StringList L =
dog owl catpig
head
size = 3StringList L =
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
Iterating over a list
This is a pointer that traverses the list
The toString method
Iterating over a list
The toString method
Iterating over a list
What’s happening here?
The toString method
Iterating over a list
What’s happening here?
implicit cursor.toString()
The toString method
Iterating over a list
The toString method
Iterating over a list
So we don’t have a list (pig,dog,owl,cat,)
Iterating over a list
Iterating over a list
… 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)
Linear Search: isPresent
Linear Search: isPresent
Assume we haven’t foundwhat we are looking for
Linear Search: isPresent
Our travelling cursor
Linear Search: isPresent
Quit if we have hit end-of-list or we found what we are looking for
Linear Search: isPresent
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!!!!
Linear Search: isPresent
Is this what we are looking for?
Linear Search: isPresent
Move the cursor down the list
Linear Search: isPresent
Did we find it?
Linear Search: isPresent
• 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?)
Linear Search: isPresent
NOTE similarity
Linear Search: isPresent
Is this better?
Linear Search: isPresent
Is this better?
Linear Search: isPresent
Is this better?
Linear Search: isPresent
Is this better?
Linear Search: isPresent
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
Recommended