ADTs,, Arrays, Linked Lists

ADTs ADTs , Arrays, Linked Lists , Arrays, Linked Lists

Outline and Required Reading:

Outline and Required Reading:

COSC 2011, Fall 2003, Section A Instructor: N. Vlajic

• ADTs (§ 2.1.2)

• Arrays (§ 1.5)

• Linked Lists (§ 4.3.1, 4.3.2)

Abstract Data Type

1) data structure (DS)

2) set of operation supported on the DS 3) error conditions

Abstract Data Type (ADT)

“abstract”

ADT

Data Structure

Interface add() remove()

find()

request result

Basic Data Structures

(used in advanced ADT) _•••• linked list

Abstract Data Type (ADT) (cont.)

Data Structure

Interface add() remove()

find()

request

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!)

•••• 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

Abstract Data Type (ADT) (cont.)

What should we know about

standard ADTs?

Why should we know standard ADTs?

(1) what operations they support

(2) complexity of supported operations (3) memory cost of operations

Standard ADTs

0 1 2 3 4 5 6 7

ADT Taxonomy

Linear ADTs

(1) there is a unique first element (2) there is a unique last element

(3) every element has a unique predecessor (except 1^st) (4) every element has a unique successor (except last)

A1 A2

Non-linear ADTs

A1

A2 A3 A1

Example 1

Abstract Data Type (ADT) (cont.)

(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.

Array

Array –

•

•

randomNumber = numbers[5];

numbers[2] = 100;

Major Limitation –

Index = 0 1 2 3 4 5 6 7

Array of length 8

Element at position 5

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

Linked List

Linked List –

•••• 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

A1

…

head node tail node

∅ ∅

∅ ∅

A2 An

element link node

∅ ∅

∅ ∅

NOTE: neighbouring nodes can be “far away” physically!

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 ListSingly Linked List (each node is linked to one of its neighbours)

•••• Doubly Linked ListDoubly Linked List (each node is linked to both of its neighbours)

Object Reference

Reference Variable –

•••• 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;

intRef = new Integer(5);

null

Reference intRef

5

Reference intRef

Integer Object

Object Reference (cont.)

Integer p, q;

p = new Integer(5);

p = new Integer(6);

6

p

q = p;

q

6 Declaring

Reference Variables

Allocating an Object

Allocating Another Object

marked for garbage collection

Assigning a Reference

Object Reference (cont.)

q = new Integer(9);

p = null;

q = p;

q

6 Allocating

an Object

Assigning null to a Reference Variable

Assigning a Reference with a null Value

p q

6 9

p

q

9

null 9

marked for garbage collection

marked for garbage collection

Singly Linked List

Singly –

Linked List

A1

…

head node tail node

∅ ∅

∅ ∅

A2 An

∅ ∅

∅ ∅

public class SLLNode { Object element;

SLLNode next;

public SLLNode(Object elem, SLLNode succ) { this.element = elem;

this.next = succ; } }

Reference variables!

SLLNode

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; } }

Singly Linked List (cont.)

Creating and Linking Two SLLNodes

SLLNode n = new SLLNode(new Integer(5), null);

5

n

5 9

first

SLLNode first = new SLLNode(NewInteger(9), n)

n

5 9 SLLNode n = new SLLNode(NewInteger(9), n)

Should, in the 2^nd case, the first node be collected by the garbage collection!?

Singly Linked List (cont.)

A1 ^A2

…

^{∅ ∅ ∅ ∅}

∅ ∅

∅ ∅

public class SLL {

private SLLNode head;

private SLLNode tail;

public SLL() {

this.head = null;

this.tail = null;

…

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?!

An

Constructs an empty linked list!

SLL

head tail

Singly Linked List (cont.)

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; } } }

Adding New Node at the Rear of SLL with Reference to Head Only!

A1 A2 An

∅ ∅ ∅ ∅

∅ ∅

∅ ∅

curr head

…

Singly Linked List (cont)

Example 1

for (SLLNode curr = head; curr != null; curr = curr.getNext()) { System.out.print(curr.element + “ “); } }

Example 2

. . .

head = head.next; }

A1 A2

∅ ∅

∅ ∅

head

…

Singly Linked List (cont)

Example 3

public void deleteFirst() { . . .

curr = head;

head = head.next;

curr.setNext(null);

curr = null;

}

A1 A2

∅ ∅

∅ ∅

head

…

marked for garbage collection

Singly Linked List (cont)

Example 4

public void delete(SLLNode prev) { . . .

SLLNode curr = prev.getNext();

prev.setNext(curr.getNext());

curr.setNext(null);

curr = null;

}

A1 Ak Ak+1

∅ ∅

∅ ∅

prev head

…

…

marked for garbage collection

Singly Linked List (cont)

Example 5

public void insert(Object element) { . . .

SLLNode curr = prev.getNext();

SLLNode newNode = new SLLNode(element, curr);

prev.setNext(newNode);

}

A1 Ak

∅ ∅

∅ ∅

prev head

…

…

Ak+1

Doubly Linked List

Doubly –

Linked List

…

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; }

…

A1 ^{A2 An}

∅ ∅ ∅ ∅

∅ ∅

∅ ∅

DLLNode

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 add/remove at a cursor

frequent capacity changes add/remove at a two-way cursor

Use an array.

Use a singly linked list.

Use a doubly linked list.

Use a linked list.

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 1^st and 2^nd node of a) a singly linked list (SLL)

b) a doubly linked list (DLL)