Download ADTs, Arrays, Linked Lists

1
ADTs, Arrays, Linked Lists
Outline and Required Reading:
• ADTs (§ 2.1.2)
• Arrays (§ 1.5)
• Linked Lists (§ 4.3.1, 4.3.2)
COSC 2011, Fall 2003, Section A
Instructor: N. Vlajic
2
Abstract Data Type (ADT)
“abstract” ⇒ implementation details are not specified !
Abstract Data Type – entity that consists of:
1) data structure (DS)
2) set of operation supported on the DS
3) error conditions
ADT
Data
Structure
Basic Data Structures
(used in advanced ADT)
Interface
request
add()
remove()
find()
result
• array
• linked list
3
Abstract Data Type (ADT) (cont.)
Data
Structure
Interface
request
add()
remove()
find()
result
Designer’s responsibility:
• choice of data structure
• implementation of operations
User’s requirements:
• correct performance
• efficient performance
The interior mechanisms of an implemented ADT
should be hidden and inaccessible to the user!
(Remember encapsulation, i.e. information hiding, OO-programming principle!)
4
Abstract Data Type (ADT) (cont.)
Standard ADTs
Why should we
know standard
ADTs?
What should we
know about
standard ADTs?
Stacks, Queues, Vectors, Lists, Trees, …
•
standard ADTs are great reusable components
- can be effectively used in solving many real
world problems
•
we may be required to adapt algorithms which
use some of the standard ADTs
(1) what operations they support
(2) complexity of supported operations
(3) memory cost of operations
5
ADT Taxonomy
Linear ADTs - we call an ADT “linear”, if the following is true:
(1)
(2)
(3)
(4)
0
1
2
3
there is a unique first element
there is a unique last element
every element has a unique predecessor (except 1st)
every element has a unique successor (except last)
4 5
Non-linear ADTs
6
A1
7
A2
- if one or more of the above is not true, the ADT is
non-linear
A1
A2
A3
A1
6
Abstract Data Type (ADT) (cont.)
Example 1 [ selecting an ADT ]
(a) If organizing a tour route, where we have to add/delete a city
- use Linked List.
(c) If managing a telephone directory that should provide short
search times - use Sorted Tree.
7
Array
Array –
sequence of indexed components, with the following
general properties:
• array size is fixed at the time of array’s construction
int numbers = new numbers [10];
• any array component can be efficiently inspected or
updated using its index, in O(1) time
randomNumber = numbers[5];
numbers[2] = 100;
Index = 0
1
2
3
4 5
6
7
Element at
position 5
Array of length 8
Major Limitation – size fixed, and must be known in advance
8
Properties of Java Arrays
(1) for an array of length n, the index bounds are 0 and (n-1)
(2) array elements are stored in “side by side” memory locations
(3) every array is homogeneous - all its components must be of
the same type
(4) an array is itself an object
• it is allocated dynamically by means of “new”
• it is automatically deallocated when no longer referred to
9
Linked List
Linked List – sequence of nodes arranged one after another, with each
node connected to the next by a “link” (like a chain)
•
each node is an object containing:
1) a single element - stored object or value
2) links - reference to one or both neighbouring nodes
•
each node (except the last one) has a successor, and
each node (except the first one) has a predecessor
node
∅
A1
…
A2
head node
element
An
∅
tail node
link
NOTE: neighbouring nodes can be “far away” physically!
10
Properties of Linked Lists
(1) linked list can be of any length, i.e. it can contain any number
of elements, and it can grow
(2) the element in any node can be accessed, however we must
hold a link to that node
(3) nodes can be inserted and deleted ⇒ ordering of nodes can
be changed in minimal running time
(4) there are two different types of linked lists
•
Singly Linked List (each node is linked to one of its neighbours)
•
Doubly Linked List (each node is linked to both of its neighbours)
11
Object Reference
Reference Variable – contains the location (address) of an object
• when we declare a reference variable, it does
not reference anything, i.e. it is initialized to
null
• if we attempt to use a reference variable before
initiating an object for it, NullPointerException
will be thrown
Integer intRef;
Reference intRef
intRef = new Integer(5);
Reference intRef
null
5
Integer Object
12
Object Reference (cont.)
Declaring
Reference Variables
Allocating
an Object
Integer
p, q;
p = new Integer(5);
p
q
p
5
marked for
garbage collection
Allocating Another
Object
p = new Integer(6);
p
5
6
Assigning
a Reference
q = p;
p
6
q
13
Object Reference (cont.)
Allocating
an Object
q = new Integer(9);
p
6
q
9
marked for
garbage collection
Assigning null to
a Reference Variable
p = null;
p
6
q
9
Assigning a Reference
with a null Value
q = p;
p
null
q
9
marked for
garbage collection
14
Singly Linked List
Singly
– each node contains a data-element together with a link
to its successor
Linked List
∅
A1
…
A2
head node
SLLNode
An
∅
tail node
public class SLLNode {
Object element;
SLLNode next;
Reference variables!
public SLLNode(Object elem, SLLNode succ) {
this.element = elem;
this.next = succ; }
}
15
Singly Linked List (cont.)
SLLNode Complying with Requirements
“hidden” and “inaccessible”
public class SLLNode {
private Object element;
private SLLNode next;
public SLLNode(Object elem, SLLNode succ) {
this.element = elem;
this.next = succ; }
public Object getElement() {
return element; }
public SLLNode getNext() {
return next; }
public void setElement(Object newElement){
element = newElement; }
public void setNext(SLLNode newNext){
next = newNext; }
}
16
Singly Linked List (cont.)
Creating and Linking
Two SLLNodes
SLLNode n = new SLLNode(new Integer(5), null);
SLLNode first = new SLLNode(NewInteger(9), n)
n
5
n
5
first
9
SLLNode n = new SLLNode(NewInteger(9), n)
5
n
9
Should, in the 2nd case, the first node be collected by the garbage collection!?
17
Singly Linked List (cont.)
SLL
∅
A1
A2
…
An-1
An
head
∅
tail
public class SLL {
private SLLNode head;
private SLLNode tail;
public SLL() {
this.head = null;
this.tail = null;
Constructs an empty
linked list!
…
}
It is a good practice to maintain direct references to head and tail; with them:
1) easy to delete or insert new node at the front of SLL;
2) easy to insert new node at the rear.
But, it is still costly to delete the end node. Why?!
18
Singly Linked List (cont.)
Adding New Node at the Rear of
SLL with Reference to Head Only!
∅
A1
A2
…
An
∅
head curr
public class SLL {
private SLLNode head;
. . .
public void addLast(SLLNode newNode){
SLLNode curr;
if (head==null) head=newNode;
else {
}
}
for (curr = head; curr.getNext() != null; curr=curr.getNext()){ };
curr.setNext=newNode; }
19
Singly Linked List (cont)
Example 1 [ SLL traversal ]
public void traverseSLL() {
for (SLLNode curr = head; curr != null; curr = curr.getNext()) {
System.out.print(curr.element + “ “); } }
Example 2 [ deletion of 1st SLL node ]
public void deleteFirst() {
. . .
head = head.next; }
∅
A1
A2
head
…
20
Singly Linked List (cont)
Example 3 [ deletion of 1st SLL node, with memory management ]
public void deleteFirst() {
. . .
}
curr = head;
head = head.next;
curr.setNext(null);
curr = null;
∅
A1
marked for
garbage collection
A2
head
…
21
Singly Linked List (cont)
Example 4 [ deletion of SLL node after node referenced by “prev”]
public void delete(SLLNode prev) {
. . .
SLLNode curr = prev.getNext();
prev.setNext(curr.getNext());
curr.setNext(null);
curr = null;
}
∅
A1
head
…
Ak
prev
Ak+1
marked for
garbage collection
Ak+2
…
22
Singly Linked List (cont)
Example 5 [ insertion of SLL node after node referenced by “prev”]
public void insert(Object element) {
. . .
SLLNode curr = prev.getNext();
SLLNode newNode = new SLLNode(element, curr);
prev.setNext(newNode);
}
Ak+1
∅
A1
head
…
Ak
prev
Ak+1
…
23
Doubly Linked List
Doubly
Linked List
∅
– each node contains an element together with a link to
its predecessor and a link to its successor
A1
A2
…
An
∅
DLLNode
public class DLLNode {
private Object element;
private DLLNode prev, next;
public DLLNode(Object elem, SLLNode pred, DLLNode succ) {
this.element = elem;
this.prev = pred;
this.next = succ; }
…
}
24
Arrays vs. Single- and Double- Linked Lists
Guidelines for Choosing Between an Array and a Linked List
ADT Requirement
Suggested Implementation
frequent random access operations
Use an array.
add/remove at a cursor
Use a singly linked list.
add/remove at a two-way cursor
Use a doubly linked list.
frequent capacity changes
Use a linked list.
25
Questions
Q.1 Suppose, in your program, you have been using a collection of
numbers, which has been stored in an array of size 1000, named
intCollection. (int intCollection = new int[1000];)
However, you do not need this collection any longer, and you
want to free the memory. What should you do?
Q.2 Examine the following code, and determine how the corresponding
SLL (the sequence of SLL’s elements) looks like.
SLLNode c = new SLLNode( “not to be”, null);
SLL phrase = SLL();
phrase.head = new SLLNode(“to be”, new SLLNode(“or”, c) );
Q.3 Repeat Examples 1 to 5 for Doubly Linked List.
Q.4
Write a short program that swaps the 1st and 2nd node of
a) a singly linked list (SLL)
b) a doubly linked list (DLL)