Chapter 12 Data Structures and Collections. 2 Knowledge Goals Understand the difference between...

Chapter 12

Data Structures

and Collections

Knowledge Goals

• Understand the difference between array and linked implementations of a list

• Know how to a stack works• Know how a queue works• Know how a binary tree works• Know how a hash table works• Understand the concepts behind the java

collections framework

Skill Goals

• Develop a linked data structure• Use the ArrayList and LinkedList classes• Use the HashSet and TreeSet classes• Use the Stack class• Use the LinkedList class to implement a

queue• Choose when to use an array-based versus a

linked implementation of a data structure

Linked Structures

Array-basedlist isfixedsize

Linked Structures

Array-based is

physicallyordered;linked islogicallyordered,

whichmeans …

Linked Structures

Insertionsand

deletionsare

easier

Linked Structure

Linked list

A list in which the order of the components is determined by an explicit link field in each node, rather than by the sequential order of the components in memory

External reference (pointer)

A named variable that references (points to) the first node (head) of a linked list

Yes, but how does it work?

Linked StructureList

A node

Each node containsitem and a link

External pointer

Linked Structures

class Node

Node link = null;

String item;

Node()

{ item = ""; }

Node(String data)

{ item = data; }

null is a keywordmeaning points to

nothing

defaultconstructor

parameterizedconstructor

Linked Structures

Let's create a linked list with three nodes, containing "Adams", "Baker", and "Carter"

We begin by creating two variables

Node current; // Pointer used to keep track // of where we

are in the list

Node list; // External point to the list

Result

Linked Structures

list = new Node("Adams");

current = list;

Result

Linked Structures

current.link = new Node("Baker");

Result

Linked Structures

current = current.link;

Result

Linked Structures

current.link = new Node("Carter");

current = current.link;

Result

Linked Structures

Traversal

Visiting every node in a data structure following an organized pattern of access

current = list; while (current.link != null){ System.out.println(current.item); current = current.link; }

What is the pattern of access?

Linked Structures

Which of thesewill change

with thelinked

version?

Linked Structures

Does the CRC cardfor a class change

with the implementation?

Linked Structures

Observer operations

public boolean isEmtpy()

{ return list == null; }

public boolean contains(String item)

Node current = list;

while (current != null &&

curent.item.compareTo(item) != 0)

curent = current.link;

return current != null

Linked Structures

if (list.contains("Doggett"))…

Searchwhenitemis notin the

Linked Structures

Size in an array-based list just returns numItems; What about in a linked-implementation?

– Can keep a counterincrement with each insertion

decrement with each deletion

– Can count the number of items each time

Which is best (better)?

Linked Structures

public int size(){ Node current = list; int numItems = 0; while (current != null) { numItems++; current = current.link; } return numItems;}

Is this anexample

of atraversal?

Linked Structures

MutatorsAdd– Insert where? To match array-based traversal, new

item must go at the end– How to find end? Search or keep a pointer– Special case(s)? Empty list

Linked Structure

public void add(String newItem) { Node item = new Node(newItem); if (list == null) { list = item; tail = item; } else { tail.link = item; tail = tail.link; }}

Empty listSet list and tail

to item

Not empty listSet item as last nodeSet tail to last node

Linked Structures

Remove– Item not there? Do nothing– What if item is the first? Reset external pointer– What if item is the last? Reset tail pointer– What if item is anywhere else? General case

Linked Structures

Can't be reached;System recaptures it

Linked Structures

What is prior?

Remove "Adams"

Linked StructuresRemove "Carter"

Linked Structures

Remove "Adams" (only node)

public void remove(String item) { Node current = list; Node prior = null; while (current != null && current.item.compareTo(item) != 0)

{ prior = current; current = current.link; } if (current != null) { if (current == tail) tail = prior; if (prior == null) list = list.link; else prior.link = current.link; }}

Search for item

item in last node

item in first node

item in interior node

Linked Structures

Iterator "trio"public void resetList()

{ current = list; }

public boolean hasNext()

{ return current != null; }

public String next(){ String item = current.item; current = current.link; return item;}

What assumptionsmust be in

documentation?

Other Data Structures

What do theseobjects havein common?

A data structure in which insertions and deletions can be made from only one end

Last In First Out

Can you name some additional LIFO structures in every day life?

Firstitem

called"top"

What properties does this illustration exhibit?

A data structure in which insertions are made at one end and deletions are made at the other end

First In First Out

Can you name some additional FIFO structures in every day life?

Owner Jake

Manager Chef Brad Carol

Waitress Waiter Cook Helper Joyce Chris Max Len

Jake's Pizza Shop

What properties does this illustration exhibit?

Owner Jake

ROOT NODE

Owner Jake

LEAF NODES

Owner Jake

LEFT SUBTREE OF ROOT NODE

Owner Jake

RIGHT SUBTREE OF ROOT NODE

Binary tree

A data structure, each of whose nodes refer to left and right child nodes

Binary search tree

A binary tree in which the value in any node is greater than the value in the left child and any of its children and less than the value in its right child and any of its children

Binary search trees provide rapid searches

Searchfor50

Searchfor18

Wherewould18 be

if there?

Inorder(tree)if tree is not NULL

Inorder(Left(tree))Visit Info(tree)Inorder(Right(tree))

PostOrder(tree)if tree is not NULL

Postorder(Left(tree))Postorder(Right(tree))Visit Info(tree)

PreOrder(tree)if tree is not NULL

Visit Info(tree)Preorder(Left(tree))Preorder(Right(tree))alphabetic order

visits leaves first

expression evaluation

Traversals

A data

structure in

which the

nodes can

be arranged

in any pattern

Hashing

A technique to

perform insertions

and access to an

item in constant

time by using the

value to identify

its location in the

structure

values

HandyParts company makes no more than 100 different parts, but theparts all have four digit numbers

index = partNum % 100

Hash function

A function used to manipulate the value to produce an index that identifies its location

Use the hash function

Hash(key) = partNum % 100

to place the element with

part number 5502 in the

values

Next place part number6702 in the array

6702 % 100 = 2

But values[2] is already occupied, causing acollision

values

Empty 2298

One solution

Repeatedly increment indexuntil an empty locationis found for part number 6702

values

Part 6702 can be placed atthe location with index 4

values

Hashing

Part 6702 is placed atthe location with index 4

Where would the part withnumber 4598 be placed usingthis scheme?

values

Hashing

Handling collisions with chaining

Comparison of incrementing index and chaining

Generic Types in Java

Generic types

A type for which the operations are defined but the type of the objects being manipulated is not

How have we handled generics previously?

Generic Types in Java

class Node <ItemType extends Comparable<ItemType>>{ Node<ItemType> link = null; ItemType item;

Node() { } Node(ItemType newItem) { item = newItem; }}

Node<ItemType> list;

Node<ItemType> tail;

In client code

Java Collections Framework

Classes that implement Collection are data structures that hold items in an organized manner

Set is Java's list with no duplicates

Interface

Hierarchy

Classes that implement Map hold values in association with objects called keys

Rest of Interface hierarchy

Let's look at this another way

Collection

List Set

SortedSet

AbstractCollection

AbstractList AbstractSet

AbstractSequentialList

Interfaces

Abstract Classes

implements

extends

AbstractList AbstractSetAbstract

SequentialList

LinkedList ArrayList Vector HashSet TreeSet

Observers inAbstractCollectioncontains containsAllisEmptytoArraytoStringsize

StackLinked

HashSet

Concrete Classes

AbstractCollections implements the Iterable Interface that has one method

iterator that returns an Iterator object

Iterator myIter = myList.iterator();

while (myIter.hasNext()) System.out.println(myIter.next());

Collections class contains static helper methods for use with the classes in the collection

void sort(List)int binarySearch(List, key)void reverse(List)void shuffle(List)void copy(DestinationList, SourceList)Object min(Collection)Object max(Collection)boolean replaceAll(List, OldValueObject, NewValueObject)boolean disjoint(Collection, Collection)

ArrayList is a concrete list class using an array-based implementation with the usual list operations and some array-specific methods as well such as:add(index, item) Inserts the item at the index position

set(index, item) Replaces the item at the index position;

returns replaced object

remove(index) Removes the item at the index position

trimToSize() Trim array to list size

ensureCapacity(limit) Makes sure the underlying array has

limit positions

LinkedList is a concrete list class with a linked implementation with the usual list operations and some additional ones such as:

add(index, item) Inserts item at the index position

getFirst() Returns a reference to the first item

getLast() Returns a reference to the last item

poll() Deletes and returns the first element

removeLast() Deletes and returns last element

remove(index) Deletes and returns the item in the index

position

ArrayList and LinkedList also have methods that take collections as arguments

removeAll(collection) Removes all items from list

that match items in collection

retainAll(collection) Removes all items that do not

match items in the collection

addAll(collection) Adds all the items in the collection

to the end of the list

Do these operations add any new functionality?

Sets (a lists without duplicates) is implemented in two concrete classes: HashSet and TreeSet

– Names give the underlying data structure– Both implement all the regular list

operations– TreeSet is able to return subtrees

(collections) with values less than or greater than a parameter

public static void main(String[] args) throws

IOException{ inFile = new Scanner(new FileReader("list.dat")); outFile = new PrintWriter(new FileWriter("list.out")); ArrayList list = new ArrayList(4); String line; while (inFile.hasNextLine()) { line = inFile.nextLine(); list.add(line); } Iterator iterator = list.iterator(); while (iterator.hasNext()) System.out.println(iterator.next());

What will the output look like?

File:redblueyellowbrownblackpinkgreenorangewhitevioletcrimsonrose

Output:redblueyellowbrownblackpinkgreenorangewhitevioletcrimsonrose

Output from

ArrayListimplementation

Output:greenroseredwhiteorangecrimsonpinkbrownblueyellowvioletblack

HashSet list = new HashSet();

Output fromHashSet

implementation

Output:blackbluebrowncrimsongreenorangepinkredrosevioletwhiteyellow

TreeSet list = new TreeSet();

Output fromTreeSet

implementation

Extras

I designedone of the

best knownsorting

algorithms and wasknighted recently

Who am I

Extras - GUI Track

Handling events with radio buttons requires declaring and instantiating a ButtonGroup

object declaring and instantiating each radio button registering an ActionListener with each

radio button adding each button to ButtonGroup object adding each button to panel parameter to getActionCommand tells which

button was pressed

Extras - GUI Track

Window withthreeradio

buttonsand a label

Chapter 12 Data Structures and Collections. 2 Knowledge Goals Understand the difference between...

Documents

1 Queues What is a Queue? Queue Implementations: –Queue As Array –Queue As Circular Array –Queue As Linked List Some Applications of Queues Priority Queues

High-Throughput Programmable Systolic Array FFT Architecture and FPGA Implementations J. Greg Nash jgregnash@centar.net ICNC 2014

A Energy-Efﬁcient Pipeline Templates for High-Performance ...vlsi.cornell.edu/~rajit/ps/eep.pdf · separate pipeline implementations of an 8x8-bit Booth-encoded array multiplier

Programming Abstraction in C++qiao/courses/cs2so3/slides/linear.pdfProgramming Abstraction in C++ ... Linear structures Stack Queue Vector Goals Different (array and linked list) implementations

CSCI 104 List ADT & Array-based Implementations Queues …ee.usc.edu/~redekopp/cs104/slides/L06b_ArrayList_AmortizedRuntime.pdfList ADT & Array-based Implementations Queues and Stacks

Chapter 3 Array-Based Implementations CS 302 - Data Structures Mehmet H Gunes Modified from authors’ slides

Chapter 15 Lists. Chapter Scope Types of list collections Using lists to solve problems Various list implementations Comparing list implementations Java

Collections - Programming 2 · Parts of the Collections Framework Interfaces - define behavior of the collection types Implementations - abstract & concrete classes Polymorphic Algorithms

High-Throughput Programmable Systolic Array FFT Architecture and FPGA Implementations

CSCI 104 List ADT & Array-based Implementations Queues and ...ee.usc.edu/~redekopp/cs104/slides/L06_ArrayList_QueueStack.pdf · List ADT & Array-based Implementations Queues and Stacks

BBM 202 - ALGORITHMS PRIORITY QUEUES AND HEAPSORTerkut/bbm202.s14/... · ‣Heapsort ‣API ‣Elementary implementations ‣Binary heaps ‣Heapsort!3 Priority queue Collections

Abstract Data Types - 2501ICT/7421ICTNathan · Abstract Data Types – Collections Collection Implementations Linear Collections Decreasing Size Similar to Increasing Frees up wasted

Java Collections Framework - polito.it3 Framework Interfaces (ADT, Abstract Data Types) Implementations (of ADT) Algorithms (sort) Contained in the package java.util Originally using

Optimizing Hash-Array Mapped Tries for Fast and … Hash-Array Mapped Tries for Fast and Lean Immutable JVM Collections Michael J. Steindorfer ... HAMT and looking up elements in the

GEORG JENSEN OFFERS AN ARRAY OF COLLECTIONS FOR THE … · georg jensen offers an array of collections for the home, the essentials and more, targeted to a global audience who appreciates

Array-Based Implementations Chapter 3 Data Structures and Problem Solving with C++: Walls and Mirrors, Carrano and Henry, 2013

Multi-core Implementations of the Concurrent Collections

Subband array implementations for space-time adaptive ...yiminzhang.com/pdf/eurasip05.pdf100 EURASIP Journal on Applied Signal Processing The subband (including frequency-domain) adaptive

5/4/20151 Queues Implementations. 5/4/20152 Outline Queues Basic operations Examples of useImplementations Array-based and linked list-based

Queues and List-Based ADT Implementations1. Queues = first-in first-out (FIFO) collections. 2. Vector implementations of stacks and queues. Efficient vector implementations of queues