## Presentation on theme: "Singly linked lists Doubly linked lists"— Presentation transcript:

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

Examples Linked lists Trees Binary trees Binary search trees AVL trees
B trees Will look at all of these All use objects which are created dynamically, using memory from a special storage area (pool/heap).

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 4

next node For an easy introduction we will have a list of Strings
element 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
constructors next node element

The Node Class for String objects
get next node element

The Node Class for String objects
set next node element

Don’t like

better

The list

head = null size = 0

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

dog owl cat StringList L = L.addFront(“pig”) head  size = 4 StringList L = dog owl cat pig

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

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 Update head to point to next node in the list

Removing at the Head Update head to point to next node in the list
Allow garbage collector to reclaim the former first node

head  StringList L = size = 4 head StringList L = size = 3 YIKES! dog
owl cat pig head size = 3 StringList L = dog owl cat pig 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 Iterating over a list

The toString method Iterating over a list

The toString method What’s happening here? Iterating over a list

The toString method What’s happening here? implicit cursor.toString() Iterating over a list

The toString method Iterating over a list

The toString method 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 Iterating over a list

Linear Search: isPresent
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” return true temp temp temp It’s easy when you know how head > Searching for “bucket” temp temp temp temp temp temp temp It’s easy when you know how head ADS2 Lecture 4 return false 45 (Alice’s slide)

Linear Search: isPresent

Linear Search: isPresent
Assume we haven’t found what 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?