Data structure lecture

Chapter Objectives Study the Java collection classes, ArrayList and LinkedList  Show how to build collection classes  Study the stack and queue structures  Learn about linked struct

Data Structures

Chapter Contents

Chapter Objectives

12.1 Introductory Example: Counting Internet Addresses

12.2 The ArrayList and LinkedList Classes

12.3 Example: A Stack Application and Class 12.4 Example: A Queue Class

12.5 An Introduction to Trees

Part of the Picture: Data Structures

12.6 Graphical/Internet Java: A

PolygonSketcher Class

Chapter Objectives

 Study the Java collection classes,

ArrayList and LinkedList

 Show how to build collection classes

 Study the stack and queue structures

 Learn about linked structures

 linked lists and binary trees

 Implement and use linked structures

 Discover how collection classes are used in graphical programming

Review Arrays

 An array stores a sequence of values

type [] anArray = new type [ capacity ];

 Drawback:

– capacity of array fixed

– must know max number of values at compile

time

– either the program runs out of space or

wastes space

 Solution: collection classes

– capacity can grow and shrink as program

runs

12.1 Introductory Example:

Counting Internet Addresses

 Internet TCP/IP addresses provide for two names for each computer

– A host name, meaningful to humans

– an IP address, meaningful to computers

 Problem:

– network administrator needs to review

file of IP addresses using a network

gateway

 Solution:

– read file of addresses

– keep track of addresses and how many

times each address shows up in the file

– accessors for address, count

– to-string converter for output

Class GatewayUsageCounter

 Note source code, Figure 12.2

 Purpose

– counts IP addresses using an array list

 Receives name of text file from args[0]

 Action:

– reads IP address from file

– prints listing of IP addresses and access

count for each

 Note use of ArrayList class

– can grow or shrink as needed

12.2 The ArrayList and

LinkedList Classes

 Collection classes provide capability to

grow and shrink as needed

 Categories of collection classes

– Lists: store collection of items, some of

which may be the same

– Sets: store collection of items with no

duplicates

– Maps: store collections of pairs, each

associates a key with an object

 Note List methods, table 12.1

ArrayList Class

 Implements the List using an array

– by using an Object array, can store any

reference type

– cannot directly store primitive types

– can indirectly store such values by using

instances of their wrapper types

 Consider the declaration:

ArrayList addressSequence = newArrayList();

AddressSeqeunce size array

 The system will then …

AddressSeqeunce size array

ArrayList

123.111.345.444, 1

Enlarging the

AddressSequence Array

 When allocated array is full, adding

another element forces replacing array with larger one

– new array of n > m allocated

– values from old array copied into new

array

– old array replaced by new one

AddressSeqeunce size array

2

[0] [1] [2] [n-1]

128.159.4.2011, 1 123.111.222.333, 1

ArrayList Drawback

 Problems arise from using an array

– values can be added only at back of

ArrayList

– to insert a value and "shift" others

after it requires extensive copying of values

– similarly, deleting a value requires

The LinkedList Class

Resulting object shown at left

aList head size tail

3

66

88 77

Linked List Containers

•link to next node

•link to previous node

•link to stored object

•Links to next and previous make it a doubly linked list

Nodes:

•Contain 3 handles

•link to next node

•link to previous node

•link to stored object

•Links to next and previous make it a doubly linked list

Attributes:

•link to first item in the list

•size of the list

•link to last item in the list

Attributes:

•link to first item in the list

•size of the list

•link to last item in the list

Variations on Linked Lists

 Lists can be linked doubly as shown

 Lists can also be linked in one direction only

– attribute would not need link to tail

– node needs forward link and pointer to

data only

– last item in list has link set to null

 Lists can be circularly linked

– last node has link to first node

Using a LinkedList

 Solve the IP address counter to use

LinkedList

 Note source code, Figure 12.3

– receives text file via args[0]

– reads IP addresses from file

– prints listing of distinct IP addresses

and number of times found in file

Using a LinkedList

 Given the command

LinkedList addressSequence = new LinkedList();

 Uses the LinkedList constructor to build an empty list

head size tail



addressSequence

Adding to the Linked List

 Results of command for first add

• create more nodes

and data values

•adjust links

Accessing Values in a Linked List

 Must use the get method

((AddressCounter)

addresssSequence.get(index)).incrementCount();

 A LinkedList has no array with an index to access an element

 get method must …

– begin at head node

– iterate through index nodes to find match– return reference of object in that node

 Command then does cast and incrementCount()

Accessing Values in a Linked List

 To print successive values for the output

for (int i = 0; i < addressSequence.size(); i++)

System.out.println(addressSequence.get(i));

size method determines limit of loop

counter

get(i) starts at first node, iterates

i times to reach desired node

•Note that each get(i) must pass over the

same first i-1 nodes previously accessed

•This is inefficient

Accessing Values in a Linked List

 An alternative, more efficient access

 A ListIterator is an object that iterates

across the values in a list

 The next() method does the following:

1 save handle to current node's object

2 advances iterator to next node using successor attribute

3 returns handle saved in step 1, so object

pointed to can be output

Inserting Nodes Anywhere in a

Linked List

– can add only at end of the list

– linked list has capability to insert

nodes anywhere

addressSequence.add(n, new anAddressCounter);

Which will …

– build a new node

– update head and tail links if required– update node handle links to place new

node to be n th item in the list

– allocates memory for the data item

Choosing the Proper List Algorithm Efficiency

 "Time-efficiency" is not a real-time issue

– rather an issue of how many steps an

Demonstration of Efficiency

 Note sample program ListTimer, Figure 12.4, demonstrates performance

 Observations

– appending to either ArrayList or

LinkedList structures takes negligible

time

– far more time-consuming to access middle

value in a LinkedList than an ArrayList

– far more time consuming to insert values

into an ArrayList than a LinkedList

Conclusions on Efficiency

 If problem involves many accesses to

interior of a sequence

– sequence should be stored in an ArrayList

 If problems involves many insertions,

deletions not at end

– sequence should be stored in LinkedList

 If neither of these is the case

– it doesn't matter which is used

12.3 Example: a Stack

Application and Class

 Consider an algorithm which converts from a base 10 number system to another number

Need for a Stack

 The remainders are generated in the

opposite order that they must be output

 If we were able to …

– generate them

– hold on to them as generated

– access (display) them in the

reverse order

THEN we have used a stack

7 3 1

1 3 7

Stack Container

 A stack is maintained Last-In-First-Out

(not unlike a stack of plates in a

cafeteria)

 Standard operations

– isEmpty(): returns true or false

– top(): returns copy of value at top of

stack (without removing it)

– push(v): adds a value v at the top of the stack

– pop(): removes and returns value at top

Number Base Conversion

Algorithm

1. Create an empty stack to hold numbers

2. Repeat following while number != 0

a) Calculate remainder = number % base

b) Push remainder onto stack of remainders

c) Replace number = number / base

3. Declare result as an empty String

4. While stack not empty do the following:

a) Remove remainder from top of stack

b) Convert remainder to base equivalent

c) Concatenate base equivalent to result

5. Return result

Implementing a Stack Class

 Note use of Stack class in source code,

Figure 12.6, implementation in Figure 12.7

 Implemented with LinkedList attribute

variable to store values

– this is a "has-a" relationship, the Stack

has a LinkedList

– contrast the "is-a" relationship

Java's Stack Class

 Java has a Stack class which extends the Vector class

 Author notes implementation as a subclass

of Vector provides inheritance of methods inappropriate for a Stack

– suggests this violates rule of thumb for

use of the extends

– Vector contains messages not appropriate that should not be used in Stack

12.4 Example: Building a Queue

Class

 In a queue,

– new values are always added at the front

or head of the list

– values are removed from the opposite end

of the list, the rear or tail

 Examples of queues

– checkout at supermarket

– vehicles at toll booth

– ticket line at movies

 Queue exhibits First-In-First-Out behavior

Queues in a Computer System

 When a process (program) requires a certain resource

– printer

– disk access on a network

– characters in a keyboard buffer

 Queue Manipulation Operations

– isEmpty(): returns true or false

– first(): returns copy of value at front

– add(v): adds a new value at rear of queue

– remove(): removes, returns value at front

Implementing a Queue Class

 Implement as a LinkedList attribute value LinkedList

– insertions and deletions from either end

are efficient, occur in constant O(1)

time

– good choice

 Implement as an ArrayList attribute ArrayList

– poor choice

– adding values at one end, removing at

other end require multiple shifts

Implementing a Queue Class

 Build a Queue from scratch

– build a linked structure to store the

queue elements

 Attributes required

– handle for the head node

– handle for tail node

– integer to store number of values in the

queue

– use SinglyLinkedNode class, source code,

Figure 12.8

Queue Class Methods

 Constructor

– set myHead, myTail to null

– set mySize to zero

Queue Class Methods

– save handle to first object

– adjust head to refer to node

– update mySize Note source code for

whole class, Figure 12.9

Note source code for whole class, Figure 12.9

12.5 An Introduction to Trees

 We seek a way to organized a linked

structure so that …

– elements can be searched more quickly

than in a linearly linked structure

– also provide for easy insertion/deletion– permit access in less than O(n) time

 Recall binary search strategy

– look in middle of list

– keep looking in middle of subset above or

below current location in list

– until target value found

Visualize Binary Search

13 28 35 49 62 66 80

Drawn as a binary tree

49 28

66

Tree Terminology

 A tree consists of:

– finite collection of nodes

– non empty tree has a root node

– root node has no incoming links

– every other node in the tree can be reached

from the root by unique sequence of links

49 28

– shows configurations possible in a game

such as the Towers of Hanoi problem

 Parse trees

– used by compiler to check syntax and

meaning of expressions such as 2 * ( 3 +

4 )

Examples of Binary Trees

 Each node has at most two children

 Useful in modeling processes where a test has only two possible outcomes

– true or false

– coin toss, heads or tails

 Each unique path can be described by the sequence of outcomes

 Can be applied to decision trees in expert systems of artificial intelligence

Implementing Binary Trees

 Binary tree represented by multiply linked structure

– each node has two links and a handle to

the data

– one link to left child, other to the

right

Value myValue

myRightChild myLeftChild

Implementing Binary Trees

 Declaration of BinaryTreeNode class

public class BinaryTreeNode

Handle to stored value

Implementing Binary Trees

 BinaryTreeNode is only one of the attributes

private BinaryTreeNode myRoot;

private int mySize;

}

Visualizing a BinaryTree

46

6317

Binary Search Trees

Search Algorithm

1. Initialize a handle currentNode to the

node containing the root

2. Repeatedly do the following:

If target_item < currentNode.myValue

set currentNode = currentNode.leftChild

If target_item > currentNode.myValue

set currentNode = currentNode.rightChild Else

terminate repetition because target_item has been found

Tree Traversals

binary tree, visiting each node

exactly once

– for now order not important

1. Visit the root and process its contents

2. Traverse the left subtree

3. Traverse the right subtree

Tree Traversal is Recursive

If the binary tree is empty then

do nothing

Else

L: Traverse the left subtree

N: Visit the root

R: Traverse the right subtree

The "anchor"

The inductive step

Traversal Order

Three possibilities for inductive step …

 Left subtree, Node, Right subtree

the inorder traversal

 Node, Left subtree, Right subtree

the preorder traversal

 Left subtree, Right subtree, Node

the postorder traversal

Constructing Binary Search

Trees

that is initially empty

insert the item

– Set parentNode = currentNode

– change currentNode to its left or right

child

– if value being inserted is not in the

tree, currentNode will eventually become null and …

– parentNode will indicate the parent of a new node to contain the value

12.6 Graphical/Internet Java:

A PolygonSketcher

 This will illustrate usage of container

class to store graphical data

 The program will use the mouse to draw a closed geometric figure called a polygon

 The program should distinguish between

– mouse clicks: connect current (x,y) to

previous (x,y) with a line segment

– dragging the mouse: "rubber banding" the

line segment

PolygonSketcher

 To support the "repeated undo" feature

– need a LIFO structure, suggests a stack

 To the support the "complete" command

button

– need capability to access first point

where user clicked mouse

– this suggests not a stack

 We create our own PointList class

– gives push() and pop() capabilities

– also allows access to value at other end

 To represent mouse-click points

– int array for x-coordinates

– int array for matching y-coordinates

– total number of points

 Note PointList class declaration, Figure 12.11

 Methods

– pushPoint() // two versions

– popPoint() // returns a point

– accessor methods

The SketchPanel Class

 Class needs listener methods

– MouseListener interface listens for

button events, handles the events

– MouseMotionListener interface listens for mouse movements, handles them

 Our sketcher will override methods …

– mousePressed()

– mouseDragged()

 Other methods we need:

– eraseLastLine() for the Undo button

– eraseAllLines() for the Clear button

– completePolygon() for the Complete

PolygonSketcher Class

 Builds the GUI

– including a central SketchPanel

 Listens for mouse button clicks

 When button click events happen

– actionPerformed() method sends

appropriate messages to the SketchPanel

 Note source code, Figure 12.13

Part of the Picture:

Other Data Structures

 Set interface implemented by HashSet and TreeSet classes

 Map interface implemented by TreeMap and HashTable classes

 Collections class

– variety of utility methods for

manipulating collections