snu idb lab. ch5. linear lists – array representation © copyright 2006 snu idb lab

SNUIDB Lab.

Ch5. Linear Lists – Array Representation

© copyright 2006 SNU IDB Lab.

2SNUIDB Lab.Data Structures

Bird’s-Eye View Ch.5 ~ Ch.7: Linear List

Ch. 5 – array representation Ch. 6 – linked representation Ch. 7 – simulated pointer representation※ In succeeding chapters - matrices, stacks, queues,

dictionaries, priority queues Java’s linear list classes

java.util.ArrayList Java.util.Vector java.util.LinkedList

In an array representation of linear list Elements are stored in an array


Table of Contents Data Objects and Structures The Linear List Data Structure Array Representation Vector Representation Multiple Lists in a Single Array Performance


Data Objects Data Object: A set of instances of values

Boolean = {false, true} Integer = {0, +1, -1, +2, -2, +3, -3, …} daysOfWeek = {S, M, T, W, Th, F, Sa}

Individual instances of a data object Primitive (atomic)

3, 5, a, Z, Composed of instances of another data object

Element: the individual components of an instance of an object good: an instance of String class

g, o, o, d is four elements of good each element is an instance of the data object Letter


Data Structures Definition: Data structure

Data object + Relationships that exist among instances and elements

Relationships among instances of integer 369 < 370 280 + 4 = 284

Relationships among elements that comprise an instance 369 3 is more significant than 6 9 is immediately to the right of 6

The relationships are usually specified by specifying operations on instances

add, subtract, predecessor, multiply

Our primary concern: the representation of data objects the implementation of the operations of interest for the data

objects


Table of Contents

Data Objects and Structures The Linear List Data Structure Array Representation Vector Representation Multiple Lists in a Single Array Performance


Linear List (Ordered List) An ordered collection of elements Instances are of the form

(e0, e1, e2, …, en-1) Where ei denotes a list element i : The index of ei n : The list length or size, n (>= 0) is finite

L = (e0, e1, e2, e3, …, en-1)

Relationships e0 is the zero’th (or front) element en-1 is the last element ei immediately precedes ei+1


Linear List ExamplesStudents in COP3530 = (Jack, Jill, Abe, Henry, Mary, …,

Judy)

Exams in COP3530 = (exam1, exam2, exam3)

Grades in COP3530 = (“Jack A+”, “Jill B-”, “Abe D”, … “Judy F”)

Days of Week = (S, M, T, W, Th, F, Sa)

Months = (Jan, Feb, Mar, Apr, …, Nov, Dec)


LinearList operationsSuppose L = (a, b, c, d, e, f, g)

size() : Determine list size L.size() = 7

get(index) : Get element with given indexget(0) = a get(2) = c get(4) = e get(-1) = error get(9) = error

indexOf(element) : Determine the index of an elementindexOf(d) = 2 indexOf(a) = 0 indexOf(z) = -1

remove(index) : Remove and return element with given index. remove(2) returns c, L becomes (a,b,d,e,f,g), indices of d,e,f and g are decreased by 1 remove(-1) error remove(20) error

add(index, element) : Add an element so that the new element has a specified index.

add(0,h) L = (h,a,b,c,d,e,f,g) // indices of a,b,c,d,e,f, and g are increased by 1add(2,h) L = (a,b,h,c,d,e,f,g) // indices of c,d,e,f, and g are increased by 1add(10,h) error add(-6,h) error


Data Structure Specification

Abstract Data Type (ADT) Specification of

The instances The operations to be performed

Language independent All representation of the ADT must satisfy the specification A way to validate the representation Hiding the details of implementation

Two ways of ADT specification in Java Interface Abstract class


Abstract Data Type LinearListAbstractDataType LinearList {

instances

ordered finite collections of zero or more elements

operations

isEmpty(): return true iff the list is empty, false otherwise

size(): return the list size (i.e., number of elements in the list)

get(index): return the indexth element of the list

indexOf(x):return the index of the first occurrence of x in the list,

return -1 if x is not in the list

remove(index): remove and return the indexth element,

elements with higher index have their index reduced by 1

add(theIndex, x): insert x as the indexth element, elements

with theIndex >= index have their index increased by 1

output(): output the list elements from left to right

}


Interface in Java A named collection of method definitions

Does not provide any implementation (no nonabstract methods)

A class implements an interface A class that implements the interface agrees to implement all of

the methods defined in the interface

Useful for Capturing similarities between unrelated classes Declaring methods that one or more classes are expected to

implement Revealing an object's programming interface without revealing its

class


Abstract class in Java Two types of classes in java

Abstract and Nonabstract Default type is Nonabstract

Abstract class Contains zero or more abstract methods

Abstract method: implementation is not provided Can also contain nonabstract methods You cannot create an instance of an abstract class A class extends an abstract class (as usual classes)


Abstract class vs. Interface Abstract class or interface ?

An abstract class can define nonconstant data members and nonabstract methods

If only constants and abstract methods are needed interface will do A class can implement many interfaces but can extend at most one class

Only single inheritance among classes Multiple inheritance is simulated using interfaces

Data Structures in this Text Use interfaces to specify ADTs throughout this lecture Exception is Graph in Chapter 17 (The abstract class Graph) Java specifies all of its data structures as interfaces

Ex) java.util.Map, java.util.Set


The Java Interface: LinearList

public interface LinearList{ public boolean isEmpty();

public int size();public Object get(int index);public int indexOf(Object elem);public Object remove(int index);public void add(int index, Object obj);public String toString();

}

public class ArrayLinearList implements LinearList{ // code for all LinearList methods must be provided here by

the user}


The Java Abstract Class: LinearListAsAbstractClass

public abstract class LinearListAsAbstractClass{ public abstract boolean isEmpty(); public abstract int size(); public abstract Object get(int index); public abstract int indexOf(Object theElement); public abstract Object remove(int index); public abstract void add(int index, Object theElement); public abstract String toString();}

public class ArrayLinearList extends LinearListAsAbstractClass{ // code for all abstract classes of LinearListAsAbstractClass must come

here}

ArrayLinearList inherits “implemented nonabstract methods”


Table of Contents

Data Objects and Structures The Linear List Data Structure Array Representation Vector Representation Multiple Lists in a Single Array


The Array Representationpublic class ArrayLinearList implements LinearList {

protected Object[] element; // no array size declaration in Javaprotected int size; // no of elements in array// …

element = new Object[initialCapacity]; // initialization}

Use a one-dimensional array element[]

L = (a, b, c, d, e) Store element i of linear list into element[i] location(i) = i

0 1 2 3 4 5 6

a b c d e


Various mapping strategies

Right to Left mapping location (i) = last - iabcde

Mapping that skips every other position

a b c d e

Wrap around mapping location (i) = (7 + i) % 15

a b cd e

Put element i of list in element[i]

a b c d e

size = 5 Use a variable size to record current number of elements


Add/Remove An Element

a b c d e

a g b c d e

add(1,g)

Add

a g c d e

remove(3)

Remove

size = 5

size = 6

size = 5


Declaring Array in Java Primitive Data Types (declaration and initialization)

int[] anArray; anArray = new int[10]; int anArray[]; anArray = new int[10];

Non-Primitive Data Types (declaration only) Auto[] KoreanCar; KoreanCar = new Auto[10];

Auto KoreanCar[]; KoreanCar = new Auto[10];

** initialization needs a for loop

int[] anArray= new int[10];

int anArray[] = new int[10];

Auto[] KoreanCar = new Auto[10];

Auto KoreanCar[] = new Auto[10];


“element” array of type “Object”

Syntax: Object[] element or Object element[] element[] hold references to elements of any user-defined data

type Data type of element is unknown

Cannot put elements of primitive data types (int, float, double, char)

Instead, Use corresponding Class – Integer, Float, Double, Character, etc.

Array Length Don’t know how many elements will be in list Must pick an initial length Dynamically increase the length as needed by the user


Increasing Array Length Define an array of the new length Copy the n elements from old array to the new array θ(n) Change the references to the new array

// create a new array of proper length and data typeObject[] newArray = new Object[newLength];// copy all elements from old array “element” into new one

“newArray”System.arrayCopy(element, 0, newArray, 0, element.length);// change the referenceelement = newArray;


Space Complexity (1) Increase the array size 1 by 1

element = new char [6] MaxListSize=6

newArray = new char[7]; newLength=7

Space needed during array copying 2 * newLength – 1 = 2 * maxListSize + 1

a b c d e f


Space complexity (2) The array length is normally doubled wherever the array

becomes full.

a b c d e f

newArray = new char[12]; newLength = 12

a b c d e f

maxListSize increased by *2 newLength Space needed = 1.5 * newLength = 3 * maxListSize

element maxListSize = 6


How Big Should The New Array Be? (1)

By doubling the array, the complexity (num of copy) is θ(n)

T(n) = 1 + 2 + 4 + 8 + … + 2k = θ(2k+1 – 1) = θ(2n – 3) = θ(n)Process # of adds Cost■ → ■□ 1 1

■■ → ■■□□ 2 2■■■□ 3 0

■■■■ → ■■■■□□□□ 4 4■■■■■□□□ 5 0■■■■■■□□ 6 0■■■■■■■□ 7 0

■■■■■■■■ →■■■■■■■■□□□□□□□□

8 8

… … …2k → 2k+1 n-1 (= 2k) 2k

n (= 2k+1)

0


How Big Should The New Array Be? (2)

By increasing the length by 1, the complexity of becoming an array with size n is θ(n2)

After n-1 adds, the array size is now n T(n) = 1 + 2 + 3 + … + (n – 1) = θ((n2 – n) / 2) = θ(n2)

Process Cost (No of Copy)■ → ■□ 1

■■ → ■■□ 2... ...

n – 1 → n n – 1


Insert theElement with array doubling

Public void add(int index, Object theElement) { if (index < 0 || index > size) //invalid index throw new IndexOoutOfBoundsException (…); if (size == element.length) { // no space double capacity Object[] newArray = new Object[2*size]; System.arraycopy(element, 0, newArray, 0, size); element = newArray;}

for (int i = size-1; i >=index; i--) element[i+1] = element[i]; // move up the remaining elements

element[index] = theElement;Size++;}


Java’s Linear List ClassesVector

size():intelementAt(index:int):ObjectaddElement(o:Object):voidremoveElement(o:Object):booleanutilutil

javajava

ArrayList

size():intget(index:int):Objectadd(o:Object):booleanremove(o:Object):boolean

LinkedList

size():intget(index:int):Objectadd(o:Object):booleanremove(o:Object):boolean

연산속도는 ArrayList가 조금 빠름

Vector 는 size 에 신경쓸 필요가 없음

내부구현 : Vector vector ArrayList array LinkedList

reference


The Class ArrayLinearList (ALL): program 5.4 — 5.8

public class ArrayLinearList implements LinearList{ protected Object[] element; protected int size; ... public boolean isEmpty() { return (size == 0); } public int size() { return size; } public Object get(int index) { return element[index]; } public int indexOf(Object theElement) { …..} public Object remove(int index) { Object removedElement = element[index]; for (int i = index + 1; i < size; i++) element[i-1] = element[i]; element[--size] = null; return removedElement; } public void add(int index, Object theElement) { …….}}* FastArrayLinearList (FALL) : System.arraycopy() instead of for

loop in remove() and add()


Implementing ArrayLinearList (1)

Constructor With initial capacity With default capacity (say, 10 elements)

Removing an Element Ascertain that the list contains an indexed element (if not,

exception) Shift index+1,…, size-1 elements down (left) one position

Complexity = O(size – index) Reduce the value of size by 1


Implementing ArrayLinearList (2)

Inserting an Element Move index ~ size-1 elements one position up (right)

Complexity = O(size – index + 1) Insert the new element in position index Increment size by 1

Decreasing the Length of element To enable the linear list to free some of the array space

when the list size becomes small slight modification of the method remove

Iterator Navigate elements of linear list


Iterator: Basic Concepts Specifies a unified mechanism to examine the elements in an

object one at a time Related methods are in the interface java.util.Iterator

※With iterator methods we can easily examine ArrayLinearList’s all elements

Iterator ix = x.iterator(); Constructs and initializes an iterator to examine the elements of x constructed iterator is assigned to ix

You must define & implement the method iterator() in the class for x


Iterator: Methods 2 Main Methods

ix.hasNext() Returns true iff x has a next element

ix.next() Throws NoSuchElementException if there is no next element Returns next element otherwise

Optional Method ix.remove()

Removes last element returned by ix.next() Throws UnsupportedMethodException if method not

implemented Throws IllegalStateException if ix.next() not yet called or did

not return an element


Example using an Iterator By iterator (more general)

Iterator ix = x.iterator();

while (ix.hasNext()) examine(ix.next());

vs

By index (only for indexed data structure)

for (int i=0; i<x.size(); i++) examine(get(i));


An Iterator for ArrayLinearList (1/3)

By using a top-level class Implemented as a separate class from “Iterator” interface Iterator class must access ArrayLinearList class data member

class ArrayLinearListIterator implements Iterator {private ArrayLinearList list;private int nextIndex;public ArrayLinearListIterator(ArrayLinearList theList) {

list = theList; nextIndex = 0;

}public boolean hasNext() { return nextIndex < list.size; } // access list’s data member directly// …

}


public class ArrayLinearListWithIterator implements LinearList {public Iterator iterator()

{return new ArrayLinearListIterator();}private class ArrayLinearListIterator implements Iterator {

public boolean hasNext() { return nextIndex < size; }

// …}// … all ArrayLinearList members and operations

}

By using a member class Implemented as a member class (nested class) of list class Can access private data members of enclosing class Can define the iterator in the same file




Using a member class is better than using a top-level class because list and iterator implementation can be separated

ArrayLinearListWithIterator

isEmpty():booleansize():intget(index:int):Objectremove(index:int):Objectiterator():Iterator...

ArrayLinearListIterator

hasNext():booleannext():Objectremove():void

uses


Merits of an Iterator It is often possible to implement the method next() so that its

complexity is less than that of get() Public Object get(int Index) { checkIndex(index); return element[Index]} Public Object next() { if (nextIndex < list.size) return list.element[nextIndex++]; else throw new NoSuchElementException(“No next element”)} TP page 45

Iterators provide a uniform way to sequence through the elements of a data structure regardless of the data structure

Iterators provide left-to-right access vs Get() gives bidirection


Table of Contents



java.util.Vector One of most widely used data structure class in java Can think as array with variable length! Have many operations similar to that of LinearList Operations

boolean add(Object o) boolean add(int index, Object o) Object remove(int index) boolean remove(Object o) int size() boolean isEmpty() int indexOf(Object o) void removeAllElements()


Remember “LinearList” interface

public interface LinearList{ public void add(int index, Object obj); public Object remove(int index); public boolean isEmpty();

public int size();public Object get(int index);public int indexOf(Object elem);public String toString();

}


Array vs. Vector in Java Object[] oa = new Object[3]; //using array

oa[0] = “A”; oa[1] = “B”; oa[2] = “C”; oa[3] = “D”; // size increasing must be done manually

Vector v = new Vector(3); //using vector v.add(“A”) v.add(“B”) v.add(“C”) v.add(“D”) // size is increased automatically (new size is

now 6)


Linear List using Vector

LLAVSPublic class LinearListAsVectorSubclass extends Vector implements LinearList{ // Program 5.13}

LLAVPublic class LinearListAsVector {// Program 5.14: element = new Vector(initialSize)}


Table of Contents



Multiple Lists in a Single Array

Map all of lists into a single array element whose length is the maximum possible

May need shift left or right sub-array when inserting an element in list I

Utilize the allocated array space

1 2 3 4 8 97… …

front[1] last[1] front[2] front[3] last[3]last[2]


Table of Contents



Performance Measurement

operation

class get

insert remove

best-case

average

worst-case

best-case

average

worst-case

ArrayLinearList 5.6ms 26.2ms 70s 140s 6.9ms 71s 142s

FastArrayLinearList 5.6ms 31.2m

s 5.8s 11.8s 8.6ms 5.7s 11.7s

LinearListAsVector 20.8ms 51.2m

s 5.8s 11.8s 18.4ms 5.8s 11.8s

LinearListAsVectorSubclass 18.6ms 48.2m

s 5.8s 11.8s 22.4ms 5.8s 11.8s

(List is constructed with the default initial capacity of 10)

Implement and measure the 4 classes in the textbook ALL in page 162-173 FALL in page 167 LLAV in page 179-180 LLAVS in page 177


Summary Ch.5 ~ Ch.7: Linear List

Ch. 5 – array representation ADT LinearList, Java’s Interface & Abstract Class Array representation: Increasing array size, Iterator Vector representation

Ch. 6 – linked representation Ch. 7 – simulated pointer representation※ In succeeding chapters - matrices, stacks, queues,

dictionaries, priority queues Java’s linear list classes

java.util.ArrayList, java.util.Vector, java.util.LinkedList


JDK class: java.util.ArrayList

public class ArrayList extends AbstractList {

constructors

ArrayList(): Constructs an empty list with initial size 10

ArrayList(int cap): Constructs an empty list with initial size cap

methods

boolean add(Object obj): Adds obj to the end of the list;

Always returns true

Object get(int i): Returns i-th element of the list

boolean isEmpty(): Returns true iff the list is empty, false otherwise

boolean remove(Object obj): Removes obj from the list ;

Returns true iff obj was in the list

}


JDK class: java.util.vector

public class Vector extends AbstractList {

constructors

Vector(): Constructs an empty vector with initial size 10

Vector(int cap): Constructs an empty vector with initial size cap

methods

void addElement(Object obj): Adds obj to the end of the vector

Object elementAt(int i): Returns i-th element of the vector

boolean isEmpty(): Returns true iff the vector is empty, false otherwise

boolean remove(Object obj): Removes obj from the vector;

Returns true iff obj was in the vector

}

snu idb lab. ch5. linear lists – array representation © copyright 2006 snu idb lab

Documents