Data StructuresLecture 4

Fang YuDepartment of Management Information SystemsNational Chengchi University

Fall 2010

Abstract List Data Structures

Array Lists, Linked Lists, and Doubly Linked Lists

Array ListThe Array List ADT extends the notion of array

by storing a sequence of arbitrary objects

An element can be accessed, inserted or removed by specifying its index (number of elements preceding it)

An exception is thrown if an incorrect index is given (e.g., a negative index)

Array ListMain methods:get(integer i): returns the element at index i

without removing it set(integer i, object o): replace the element at

index i with o and return the old element add(integer i, object o): insert a new element o to

have index i remove(integer i): removes and returns the

element at index i

Additional methods: size() isEmpty()

Array-based ImplementationUse an array A of size N

A variable n keeps track of the size of the array list (number of elements stored)

Operation get(i) is implemented in O(1) time by returning A[i]

Operation set(i,o) is implemented in O(1) time by performing t = A[i], A[i] = o, and returning t.

Insertion In operation add(i, o), we need to make room for

the new element by shifting forward the n - i elements A[i], …, A[n - 1]

In the worst case (i = 0), this takes O(n) time

A

0 1 2 ni

A

0 1 2 ni

A

0 1 2 noi

Element Removal In operation remove(i), we need to fill the hole

left by the removed element by shifting backward the n - i - 1 elements A[i + 1], …, A[n - 1]

In the worst case (i = 0), this takes O(n) time

A

0 1 2 ni

A

0 1 2 noi

A

0 1 2 ni

Performance In the array based implementation of an array

list: The space used by the data structure is O(n)

size, isEmpty, get and set run in O(1) time add and remove run in O(n) time in worst case

In an add operation, when the array is full, instead of throwing an exception, we can replace the array with a larger one

Growable Array-based Array ListIn an add(o) operation (without an index),

we always add at the end

When the array is full, we replace the array with a larger one

How large should the new array be?Incremental strategy: increase the size by

a constant cDoubling strategy: double the size

Growable Array-based Array List

Algorithm add(o)if t = S.length 1 then

A new array of

size …for i 0 to n-

1 do

A[i] S[i]S A

n n + 1S[n-1] o

//create a new array A (larger than S)

//copy the elements in S to A

//increase the size by 1//add o as the last element

//Replace S with A

Comparison of the StrategiesWe compare the incremental strategy and the

doubling strategy by analyzing the total time T(n) needed to perform a series of n add(o) operations

We assume that we start with an empty stack represented by an array of size 1

We call amortized time of an add operation the average time taken by an add over the series of operations, i.e., T(n)/n

Incremental Strategy We replace the array k = n/c times

The total time T(n) of a series of n add operations is proportional to

n + c + 2c + 3c + 4c + … + kc

Since c is a constant, T(n) is O(n + k2), i.e., O(n2)

The amortized time of an add operation is O(n)

Doubling Strategy We replace the array k = log2 n times

The total time T(n) of a series of n add operations is proportional to

n + 1 + 2 + 4 + 8 + …+ 2k =

3n - 1

T(n) is O(n)

The amortized time of an add operation is O(1)

geometric series

1

2

14

8

Singly Linked ListA concrete data structure

consisting of a sequence of nodes

Each node storeselement link to the next node

next

elem node

A B C D

The Node Class for Singly Linked List public class Node { private Object element; private Node next; public Node() { this(null, null); } public Node(Object e, Node n) { element = e; next = n; } public Object getElement() { return element; } public Node getNext() { return next; } public void setElement(Object

newElem) { element = newElem; } public void setNext(Node

newNext) { next = newNext; }}

// Instance variables

// Creates a node with null // references to its element and next node.

// Creates a node with the given element // and next node.

// Accessor methods

// Modifier methods

Inserting at the Head1. Allocate a new

node

2. Insert new element

3. Have new node point to old head

4. Update head to point to new node

Removing at the Head1. Update head to

point to next node in the list

2. Allow garbage collector to reclaim the former first node

Inserting at the Tail1. Allocate a new

node2. Insert new element3. Have new node

point to null4. Have old last node

point to new node5. Update tail to point

to new node

Removing at the TailRemoving 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

Stack as a Linked List We can implement a stack with a singly linked list

The top element is stored at the first node of the list

The space used is O(n) and each operation of the Stack ADT takes O(1) time

t

nodes

elements

Queue as a Linked List We can implement a queue with a singly linked listThe front element is stored at the first nodeThe rear element is stored at the last node

The space used is O(n) and each operation of the Queue ADT takes O(1) time

21

f

r

nodes

elements

Position ADTThe Position ADT models the notion of place

within a data structure where a single object is stored

It gives a unified view of diverse ways of storing data, such as a cell of an array

a node of a linked list

Just one method: object element(): returns the element stored at

the position

Node List ADTThe Node List ADT models a sequence of positions storing

arbitrary objects

It establishes a before/after relation between positions

• Generic methods:• size(), isEmpty()

• Accessor methods:• first(), last()• prev(p), next(p)

• Update methods:• set(p, e) • addBefore(p, e), addAfter(p, e),• addFirst(e), addLast(e)• remove(p)

Doubly Linked ListA doubly linked list provides a natural

implementation of the Node List ADT

Nodes implement Position and store: element link to the previous node link to the next node

Special trailer and header nodes

prev next

elem node

Doubly Linked List

trailerheader nodes/positions

elements

InsertionWe visualize operation insertAfter(p, X), which returns

position q

A B X C

A B C

A B C

p

X

q

p q

Insertion Algorithm

Algorithm addAfter(p,e):Create a new node vv.setElement(e)v.setPrev(p) //link v to its predecessorv.setNext(p.getNext()) //link v to its successor(p.getNext()).setPrev(v)//link p’s old successor to vp.setNext(v) //link p to its new successor, vreturn v //the position for the element e

DeletionWe visualize remove(p), where p = last()

A B C D

p

A B C

D

p

A B C

Deletion Algorithm

Algorithm remove(p):t = p.element //a temporary variable to hold the return value(p.getPrev()).setNext(p.getNext()) //linking out p(p.getNext()).setPrev(p.getPrev())p.setPrev(null) //invalidating the position pp.setNext(null)return t

HW4 (Due on 10/14)

Maintain an ordered keyword list.

A keyword is a pair [String name, Integer count]

Keep the list in order by its count while adding or deleting elements

For the list structure, you can Use java.util.ArrayList, or java.util.LinkedList, or Develop it by yourself

Given a sequence of operations in a txt file, parse the txt file and execute each operation accordingly

Add and Output

operations description

add(Keyword k) Insert k to the list in order

outputIndex(int i) Output the ith keyword in the list

outputCount(int c) Output all keywords whose count is equal to c

outputHas(string s) Output all keywords whose name contains s

outputName(string s) Output all keywords whose name is equal to s

outputFirstN(int n) Output the first n keywords

outputAll() Output the whole list

Add in order

add Fang 3add Yu 5add NCCU 3add UCSB 2…

Fang, 3

Yu, 5 Fang, 3

Yu, 5 NCCU, 3 Fang, 3

Output operations

Yu, 5 NCCU, 3 Fang, 3 UCSB, 2

…outputCount 3outputName YuoutputHas UoutputIndex 1outputFirstN 2outputAll…

[NCCU, 3] [Fang, 3][Yu, 5][NCCU, 3] [UCSB, 2][Yu, 5][Yu, 5] [NCCU,3][Yu, 5] [NCCU, 3] [Fang, 3] [UCSB, 2]

Delete

operations description

deleteIndex(int i) Delete the ith keyword in the list

deleteCount(int c) Delete all keywords whose count is equal to c

deleteHas(string s) Delete all keywords whose name contains s

deleteName(string s) Delete all keywords whose name is equal to s

deleteFirst(int n) Delete the first n keywords

Delete operations

Yu, 5 NCCU, 3 Fang, 3 UCSB, 2

deleteCount 3deleteName YudeleteHas UdeleteIndex 1deleteFirstN 2deleteAll

An input file

add Fang 3add Yu 5add NCCU 3add UCSB 2add MIS 2add Badminton 4add Food 3add Data 3add Structure 4outputAll deleteCount 3outputCount 2outputName YudeleteName YuoutputHas adeleteHas aoutputIndex 2deleteIndex 4deleteFirstN 1outputFirstN 3 deleteAll

1. You need to read the sequence of operations from a txt file2. The format is firm3. Raise an exception if the input does not match the format