# Welcome to CIS 068 ! - PowerPoint PPT Presentation

Loading...

PPT – Welcome to CIS 068 ! PowerPoint presentation | free to download - id: 6912f4-ZGNlZ

The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

## Welcome to CIS 068 !

Description:

### Welcome to CIS 068 ! Lesson 10: Data Structures – PowerPoint PPT presentation

Number of Views:28
Avg rating:3.0/5.0
Slides: 62
Provided by: RolfLak2
Learn more at: http://knight.temple.edu
Category:
Tags:
User Comments (0)
Transcript and Presenter's Notes

Title: Welcome to CIS 068 !

1
Welcome to CIS 068 !
Lesson 10 Data Structures
2
Overview
• Description, Usage and Java-Implementation of
• Collections
• Lists
• Sets
• Hashing

3
Definition
• Data Structures
• Definition (www.nist.gov)
• An organization of information, usually in
memory, for better algorithm efficiency, such as
queue, stack, linked list, heap, dictionary, and
tree, or conceptual unity, such as the name and
address of a person.

4
Efficiency
• An organization of information for better
algorithm efficiency...
• Isnt the efficiency of an algorithm defined by
the order of magnitude O( )?

5
Efficiency
• Yes, but it is dependent on its implementation.

6
Introduction
• Data structures define the structure of a
collection of data types, i.e. primitive data
types or objects
• The structure provides different ways to access
the data
• Different tasks need different ways to access the
data
• Different tasks need different data structures

7
Introduction
• Typical properties of different structures
• fixed length / variable length
• access by index / access by iteration
• duplicate elements allowed / not allowed

8
Examples
• Tasks
• Read 300 integers
• Read an unknown number of integers
• Read 5th element of sorted collection
• Read next element of sorted collection
• Merge element at 5th position into collection
• Check if object is in collection

9
Examples
• Although you can invent any datastructure you
want, there are classic structures, providing
• Coverage of most (classic) problems
• Analysis of efficience
• Basic implementation in modern languages, like
JAVA

10
Data Structures in JAVA
• Lets see what JAVA has to offer

11
The Collection Hierarchy
• Collection top interface, specifying
requirements for all collections

12
Collection Interface
13
Collection Interface
!
14
Iterator Interface
• Purpose
• Sequential access to collection elements
• Note the so far used technique of sequentially
accessing elements by sequentially indexing is
not reasonable in general (why ?) !
• Methods

15
Iterator Interface
• Iterator points between the elements of
collection

1
2
3
4
5
first position, hasNext() true, remove() throws
error
Returned element
Current position (after 2 calls to next()
), remove() deletes element 2
Position after next()
hasNext() false
16
Iterator Interface Usage
Typical usage of iterator
17
Back to Collections
AbstractCollection
18
AbstractCollection
• Facilitates implementation of Collection
interface
• Providing a skeletal implementation
• Implementation of a concrete class
• Provide data structure (e.g. array)
• Provide access to data structure

19
AbstractCollection
• Concrete class must provide implementation of
Iterator
• To maintain abstract character of data in
AbstractClass implemented (non abstract) methods
use Iterator-methods to access data

myCollection
AbstractCollection
implements Iterator int data Iterator
iterator() return this hasNext()
add() Iterator iiterator() Clear() Iterato
r iiterator()
20
Back to Collections
List Interface
21
List Interface
• Extends the Collection Interface
• Adds methods to insert and retrieve objects by
their position (index)
• Note Collection Interface could NOT specify the
position
• A new Iterator, the ListIterator, is introduced
• ListIterator extends Iterator, allowing for
bidirectional traversal (previousIndex()...)

22
List Interface
Incorporates index !
A new Iterator Type (can move forward and backwar
d)
23
Example Selection-Sorting a List
Part 1 call to selection sort Actual
implementation of List does not matter ! Call
to SelectionSort Use only Iterator-properties
of ListIterator (upcasting)
24
Example Selection-Sorting a List
Part 2 Selection sort access at index
fill Inner loop swap
25
Back to Collections
AbstractList ...again the implementation of some
methods... Note Still ABSTRACT !
26
Concrete Lists
ArrayList and Vector at last concrete
implementations !
27
ArrayList and Vector
• Vector
• For compatibility reasons (only)
• Use ArrayList
• ArrayList
• Underlying DataStructure is Array
• List-Properties add advantage over Array
• Size can grow and shrink
• Elements can be inserted and removed in the
middle

28
An Alternative Implementation (1)
29
An Alternative Implementation (2)
30
An Alternative Implementation (3)
31
Collections
• The underlying array-datastructure has
• advantages for index-based access
• disadvantages for insertion / removal of middle
elements (copy), insertion/removal with O(n)
• Alternative linked lists

32
Linked List
• Flexible structure, providing
• Insertion and removal from any place in O(1),
compared to O(n) for array-based list
• Sequential access
• Random access at O(n), compared to O(1) for
array-based list

33
Linked List
• List of dynamically allocated nodes
• Nodes arranged into a linked structure
• Data Structure node must provide
• Data itself (example the bead-body)
• A possible link to another node (ex. the link)

Childrens pop-beads as an example for a linked
list
34
Linked List
Old node
New node
next
next
(null)
35
Connecting Nodes
creating the nodes
connecting
36
Inserting Nodes
r
p.link r r.link q q can be accessed by
p.link.link
37
Removing Nodes
p
q
38
Traversing a List
(null)
39
Double Linked Lists
Single linked list Double linked list
(null)
(null)
data
data
data
(null)
successor
successor
successor
predecessor
predecessor
predecessor
(null)
40
Back to Collections
AbstractSequentialList and LinkedList
41
LinkedList
An implementation example See textbook
42
Sets
Example task Examine, collection contains object
o Solution using a List -gt O(n) operation !
43
Sets
• Comparison to List
• Set is designed to overcome the limitation of
O(n)
• Contains unique elements
• contains() / remove() operate in O(1) or O(log n)
• No get() method, no index-access...
• ...but iterator can (still) be used to traverse
set

44
Back to Collections
Interface Set
45
Hashing
How can method contain() be implemented to be
an O(1) operation ? http//ciips.ee.uwa.edu.au/m
orris/Year2/PLDS210/hash_tables.html
46
Hashing
• How can method contain() be implemented to be
an O(1) operation ?
• Idea
• Retrieving an object of an array can be done in
O(1) if the index is known
• Determine the index to store and retrieve an
object by the object itself !

47
Hashing
• Determine the index ... by the object itself
• Example
• Store Strings Apu, Bob, Daria as Set.
• Define function H String -gt integer
• Take first character, A1, B2,...
• Store names in String array at position H(name)

48
Hashing
Apu first character A H(A)
1 Bob first character B H(B)
2 Daria first character D H(D) 4 ...
Apu
Bob
(unused)
Daria
(unused)

49
Hashing
• The Function H(o) is called the HashCode of the
object o
• Properties of a hashcode function
• If a.equals(b) then H(a) H(b)
• BUT NOT NECESSARILY VICE VERSA
• H(a) H(b) does NOT guarantee a.equals(b) !
• If H() has sufficient variation, then it is
most likely, that different objects have
different hashcodes

50
Hashing
• Additionally an array is needed, that has
sufficient space to contain at least all
elements.
• The hashcode may not address an index outside the
array, this can easily be achieved by
• H1(o) H(o) n
• modulo-function, n array length
• The larger the array, the more variates H1() !

Apu
Bob
(unused)
Daria
(unused)

51
Hashing
Back to the example Insert Abe First
character A H(A) 1 H(Apu) H(Abe), this is
called a Collision
Apu
Bob
(unused)
Daria
(unused)

52
Solving Collisions
Method 1 Dont use array of objects, but arrays
of linked lists !
Apu
Abe
Bob
(unused)
Daria
Array contains (start of) linked lists
(unused)
ARRAY
53
Solving Collisions
• Drawback
• Objects must be wrapped in node structure, to
provide links, introducing a huge overhead

wrap
Apu
Apu
link
Node
54
Solving Collisions
• Method 2
• Iteratively apply different hashcodes H0, H1,
H2,.. to object o, until collision is solved
• As long as the different hashcodes
• are used in the same order, the
• search is guaranteed to be
• consistent

Apu
H0
Bob
Apu
H1
(unused)
H2
Daria
(unused)
ARRAY
55
Solving Collisions
The easiest hashcode-series Hinc H(0) H Hi
Hi-1 i http//ciips.ee.uwa.edu.au/morris/Ye
ar2/PLDS210/hash_tables.html
Apu
H0
H1
Bob
Apu
(unused)
H2
Daria
(unused)
ARRAY
56
add
Example implementation of add(Object o) using
Hinc (assume array A has length n, H as given
above) determine index H(o) n while (
Aindex ! null ) if o.equals(Aindex)
break else index (index 1)
n end add element at position
aindex
57
contains
Example implementation of contains(Object o)
using Hinc (assume array A has length n, H as
given above) determine index H(o)
n found false while ( Aindex ! null
) if o.equals(Aindex) found
true break else index (index
1) n end // found is true if
set contains object o
58
Analysis
• If there is no collision, contains() operates in
O(1)
• If the set contains elements having the same
hashcode, there is a collision. Being dupmax the
maximum value of elements having the same hash
code, contains() operates in O(dupmax)
• If dupmax is near n, there is no increase in
speed, since contains() operates in O(n)

59
A Real Hashcode
• JAVA provides a hashcode for every object
• The implementation for hashCode for e.g. String
is computed by
• S031(n-1) s131(n-2) ... sn-1
• n length of string, si character at
position i

Method hashCode in java.lang.Object
60
Rehashing a table
• What happens if the array is full ?
• Create new array, e.g. double size, and insert
all elements of old table into new table
• Note the elements wont keep their index, since
the modulo-function applied to the hashing has
changed !

61
Hashcode Resume
• Hashtable provides Set-operations add(),
contains() in O(1) if hashcode is chosen properly
and array allows for sufficient variation
• Speed is gained by usage of more memory
• If multiple collisions occur, hashtable might be
slower than list due to overhead (computation of
H,...)
About PowerShow.com