data structures l.
Skip this Video
Loading SlideShow in 5 Seconds..
Data Structures PowerPoint Presentation
Download Presentation
Data Structures

Loading in 2 Seconds...

play fullscreen
1 / 61

Data Structures - PowerPoint PPT Presentation

  • Uploaded on

Data Structures Chapter 12 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

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Data Structures' - Faraday

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
data structures

Data Structures

Chapter 12

chapter contents
Chapter Contents

Chapter Objectives

12.1 Introductory Example: Counting Internet Addresses

12.2 The ArrayListand 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
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
Review Arrays
  • An array stores a sequence of valuestype [] 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
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
class addresscounter
Class AddressCounter
  • Note source code, Figure 12.1
  • Attributes
    • maximum message length
    • address
    • count
  • Methods
    • constructor
    • comparison method, equals()
    • count incrementer
    • accessors for address, count
    • to-string converter for output
class gatewayusagecounter
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
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
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();




adding to addresssequence

Update size attribute of the ArrayList

Allocate the array

[0] [1] [2] . . . [m-1]

Adding to addressSequence
  • The commandaddressSequence.add(anAddressCounter);
    • appends anAddressCounter object to the sequence
  • The system will then …

Make first element point to the AddressCounter





updating addresssequence

Cast it as an AddressCounter object

Gets this object

Increment the count attribute

[0] [1] [2] . . . [m-1], 1, 2

Updating addressSequence
  • Consider the command((AddressCounter) addressSequence.get(index)).incrementCount();// assume index == 1



2, 1

enlarging the addresssequence array, 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



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


123.111.345.444, 1, 1

arraylist drawback
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 shifting
  • We need a slightly different structure to allow simple insertions and deletions
    • the LinkedList class will accomplish this
the linkedlist class
The LinkedList Class
  • GivenLinkedList alist = new LinkedList();. . .aList.add(new(integer(88));aList.add(new(integer(77));aList.add(new(integer(66));




Resulting object shown at left




linked list containers


  • link to first item in the list
  • size of the list
  • link to last item in the 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
Linked List Containers







variations on linked lists
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
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 linkedlist18




Using a LinkedList
  • Given the commandLinkedList addressSequence = new LinkedList();
  • Uses the LinkedList constructor to build an empty list
adding to the linked list




Adding to the Linked List
  • Results of command for first addaddressSequence.add(anAddressCounter);
  • Successive adds
    • create more nodes and data values
    • adjust links

123.111.345.444, 1

accessing values in a linked list
Accessing Values in a Linked List
  • Must use the .get method



  • 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 list21

get(i)starts at first node, iterates i times to reach desired node

sizemethod determines limit of loop counter

Accessing Values in a Linked List
  • To print successive values for the output

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


  • Note that each get(i) must pass over the same first i-1 nodes previously accessed
  • This is inefficient
accessing values in a linked list22
Accessing Values in a Linked List
  • An alternative, more efficient access algorithmListIterator it = addressSequence.listIterator();while (it.hasNext()) System.out.println(;
  • A ListIterator is an object that iterates across the values in a list
  • The next() method does the following:
    • save handle to current node's object
    • advances iterator to next node using successor attribute
    • returns handle saved in step 1, so object pointed to can be output
inserting nodes anywhere in a linked list
Inserting Nodes Anywhere in a Linked List
  • Recall problem with ArrayList
    • can add only at end of the list
    • linked list has capability to insert nodes anywhere
  • We can sayaddressSequence.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 nth item in the list
    • allocates memory for the data item
choosing the proper list algorithm efficiency
Choosing the Proper ListAlgorithm Efficiency
  • "Time-efficiency" is not a real-time issue
    • rather an issue of how many steps an algorithm requires
  • Linear time
    • time proportional to n
    • referred to as O(n), "order n"
  • Constant time
    • expressed as O(1)
demonstration of efficiency
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
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

1 3 7eight

12.3 Example: a Stack Application and Class
  • Consider an algorithm which converts from a base 10 number system to another number system.
  • To convert from 95ten to base eight:Use repeateddivision byeight, takingremaindersin reverseorder
need for a stack
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



1 3 7


stack container
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
Number Base Conversion Algorithm
  • Create an empty stack to hold numbers
  • Repeat following while number != 0
    • Calculate remainder = number % base
    • Push remainder onto stack of remainders
    • Replace number = number / base
  • Declare result as an empty String
  • While stack not empty do the following:
    • Remove remainder from top of stack
    • Convert remainder to base equivalent
    • Concatenate base equivalent to result
  • Return result
implementing a stack class
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 aLinkedList
    • contrast the "is-a" relationship
java s stack class
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
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
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
Implementing a Queue Class
  • Implement as a LinkedList attribute value
    • insertions and deletions from either end are efficient, occur in constant O(1) time
    • good choice
  • Implement as an ArrayList attribute
    • poor choice
    • adding values at one end, removing at other end require multiple shifts
implementing a queue class36
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 structure
Queue Structure




. . .



. . .


queue class methods
Queue Class Methods
  • Constructor
    • set myHead, myTail to null
    • set mySize to zero
  • isEmpty()
    • return results of comparison mySize == 0
  • front()
    • return myHead.getValue()

// unless empty

queue class methods39
Queue Class Methods
  • add()
    • create new node, update attribute variables
    • if queue is empty, must also update myHead
  • remove()
    • must check if class not emptyotherwise …
    • save handle to first object
    • adjust head to refer to node
    • update mySize

Note source code for whole class, Figure 12.9

12 5 an introduction to trees
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

Drawn as a binary tree








Visualize Binary Search

13 28 35 49 62 66 80

tree terminology

Sibling nodes



child nodes

Leaf nodes

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








applications of trees
Applications of Trees
  • Genealogical tree
    • pictures a person's descendants and ancestors
  • Game trees
    • 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
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
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





implementing binary trees46

Pointers to succeeding nodes

Handle to stored value

Implementing Binary Trees
  • Declaration of BinaryTreeNode classpublic class BinaryTreeNode{// … methods go here// Attributesprivate BinaryTreeNode myLeftChild, myRightChild;private Object myValue; }
implementing binary trees47
Implementing Binary Trees
  • BinaryTreeNode is only one of the attributes of a BinaryTree class
  • Also need an attribute that keeps track of the number of nodes in the treepublic class BinaryTree extends Object{// … methodsprivate BinaryTreeNode myRoot;private int mySize;}
visualizing a binarytree
Visualizing a BinaryTree







binary search trees
Binary Search Trees

Search Algorithm

  • Initialize a handle currentNode to the node containing the root
  • Repeatedly do the following:

If target_item < currentNode.myValue set currentNode = currentNode.leftChild

If target_item > currentNode.myValueset currentNode = currentNode.rightChild


terminate repetition because target_item has been found

tree traversals
Tree Traversals
  • A traversal is moving through the binary tree, visiting each node exactly once
    • for now order not important
  • Traverse Algorithm
    • Visit the root and process its contents
    • Traverse the left subtree
      • visit its root, process
      • traverse left sub-sub tree
      • traverse right sub-sub tree
    • Traverse the right subtree
tree traversal is recursive

The "anchor"

The inductive step

Tree Traversal is Recursive

If the binary tree is empty thendo nothing

Else L: Traverse the left subtreeN: Visit the rootR: Traverse the right subtree

traversal order
Traversal Order

Three possibilities for inductive step …

  • Left subtree, Node, Right subtreethe inorder traversal
  • Node, Left subtree, Right subtreethe preorder traversal
  • Left subtree, Right subtree, Nodethe postorder traversal
constructing binary search trees
Constructing Binary Search Trees
  • Repeatedly insert elements into a BST that is initially empty
  • Descend tree, looking for place to 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
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






  • 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
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 button

Note source code in Figure 12.12

polygonsketcher class
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 data structures
Part of the Picture:Data Structures
  • Java provides standard classes
    • ArrayList
    • LinkedList
  • Standard classes used to solve variety of problems
  • Wise use of these data structures simply solutions to many problems
  • Attention should be given to efficiency of structure for particular task at hand
other data structures
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