KING SAUD UNIVERSITYCOLLEGE OF COMPUTER & INFORMATION SCIENCES

Information Technology Department

IT 212: Data Structures with JAVA

ADTSpecification

This document is extracted from the text book:

Data Structures and Abstractions with Java THIRD EDITION

Frank M. Carrano

Prepared by Samira LahmarSecond Semester 1427-1428/2007

Edited by Nadia Al-GhreimilSecond Semester 1430-1431

Edited by Mashael AlDuwaisSecond Semester 1435-1436

This copy belongs to: __________________________________

NO modifications to this document are allowed.

DO NOT write on this document anything other than your Name.

1

Private Class Node

private class Node{ private T data; // entry in the sturucture private Node next; // link to next node

private Node(T dataPortion) { data = dataPortion; next = null; } // end constructor

private Node(T dataPortion, Node linkPortion) { data = dataPortion; next = linkPortion; } // end constructor

private T getData() { return data; } // end getData

private void setData(T newData) { data = newData; } // end setData

private Node getNextNode() { return next; } // end getNextNode

private void setNextNode(Node nextNode) { next = nextNode; } // end setNextNode

} // end Node

2

Bag

BagInterface

/** An interface that describes the operations of a bag of objects.

public interface BagInterface < T > {

/** Gets the current number of entries in this bag. @return the integer number of entries currently in the bag */ public int getCurrentSize ();

/** Sees whether this bag is full. @return true if the bag is full, or false if not */ public boolean isFull ();

/** Sees whether this bag is empty. @return true if the bag is empty, or false if not */ public boolean isEmpty ();

/** Adds a new entry to this bag. @param newEntry the object to be added as a new entry @return true if the addition is successful, or false if not */ public boolean add (T newEntry);

/** Removes one unspecified entry from this bag, if possible. @return either the removed entry, if the removal was successful, or null */ public T remove ();

/** Removes one occurrence of a given entry from this bag, if possible.

@param anEntry the entry to be removed @return true if the removal was successful, or false if not */ public boolean remove (T anEntry);

/** Removes all entries from this bag. */ public void clear ();

/** Counts the number of times a given entry appears in this bag. @param anEntry the entry to be counted @return the number of times anEntry appears in the bag */ public int getFrequencyOf (T anEntry);

/** Tests whether this bag contains a given entry. @param anEntry the entry to locate @return true if the bag contains anEntry, or false otherwise */ public boolean contains (T anEntry);

/** Creates an array of all entries that are in this bag. @return a newly allocated array of all the entries in the bag */ public T [] toArray ();

} // end BagInterface

3

Using Array to implement ADT bag

/** A class of bags whose entries are stored in a fixed-size array. public class ArrayBag < T > implements BagInterface < T > { private final T [] bag; // array of bag entriesprivate static final int DEFAULT_CAPACITY = 25;

// default size of bagprivate int numberOfEntries; //current number of entries in bag

public ArrayBag () { this(DEFAULT_INITIAL_CAPACITY);} // end default constructor

/ Implementations of the public methods declared in BagInterface go here.

// Locates a given entry within the array bag.// Returns the index of the entry, if located,// or -1 otherwise.private int getIndexOf(T anEntry) {//implementation goes here}

// Removes and returns the entry at a given index within the array bag.// If no such entry exists, returns null.private T removeEntry(int givenIndex){//implementation goes here}

} // end of class ArrayBag

A linked implementation of ADT bag

/** A class of bags whose entries are stored in a chain of linked nodes. The bag is never full. public class LinkedBag < T > implements BagInterface < T > { private Node firstNode; // reference to first node private int numberOfEntries; // current number of entries in bag

public LinkedBag () { firstNode = null; numberOfEntries = 0; } // end default constructor / Implementations of the public methods declared in BagInterface go here. private class Node // private inner class { ….} // end Node

} // end of class LinkedBag

4

Stack

StackInterface

/** An interface for the ADT stack.*/

public interface StackInterface<T>{ /** Adds a new entry to the top of this stack. @param newEntry an object to be added to the stack */ public void push(T newEntry); /** Removes and returns this stackÕs top entry. @return either the object at the top of the stack or, if the stack is empty before the operation, null */ public T pop(); /** Retrieves this stackÕs top entry. @return either the object at the top of the stack or null if the stack is empty */ public T peek(); /** Detects whether this stack is empty. @return true if the stack is empty */ public boolean isEmpty(); /** Removes all entries from this stack */ public void clear();} // end StackInterface

Using array to implement ADT Stack

/** A class of stacks whose entries are stored in an array.*/public class ArrayStack<T> implements StackInterface<T>{

private T[] stack; // array of stack entriesprivate int topIndex; // index of top entry

private static final int DEFAULT_INITIAL_CAPACITY = 50;

public ArrayStack(){

this(DEFAULT_INITIAL_CAPACITY); } // end default constructor

public ArrayStack(int initialCapacity){

// the cast is safe because the new array contains null entries @SuppressWarnings("unchecked") T[] tempStack = (T[])new Object[initialCapacity]; stack = tempStack;

topIndex = -1;} // end constructor

// Implementations of public methods go here.

// Doubles the size of the array stack if it is fullprivate void ensureCapacity() {} // end ensureCapacity

} // end ArrayStack

5

A linked implementation of ADT Stack

/** A class of stacks whose entries are stored in a chain of nodes.*/public class LinkedStack<T> implements StackInterface<T>{

private Node topNode; // references the first node in the chain

public LinkedStack(){

topNode = null;} // end default constructor

// Implementations of public methods go here.

private class Node{….} // end Node

} // end LinkedStack

Queue

QueueInterface

/** An interface for the ADT queue.*/

public interface QueueInterface<T>{ /* Adds a new entry to the back of this queue. @param newEntry an object to be added */ public void enqueue(T newEntry); /* Removes and returns the entry at the front of this queue. @return either the object at the front of the queue or, if the queue is empty before the operation, null */ public T dequeue(); /* Retrieves the entry at the front of this queue. @return either the object at the front of the queue or, if the queue is empty, null */ public T getFront(); /* Detects whether this queue is empty. @return true if the queue is empty, or false otherwise */ public boolean isEmpty(); /* Removes all entries from this queue. */ public void clear();} // end QueueInterface

6

Using array to implement ADT Queue

/** A class that implements the ADT queue by using an expandable circular array.*/

public class ArrayQueue<T> implements QueueInterface<T>{ private T[] queue; // circular array of queue entries private int frontIndex; private int backIndex; private int NumberOfEntries; private static final int DEFAULT_INITIAL_CAPACITY = 50;

public ArrayQueue() { this(DEFAULT_INITIAL_CAPACITY); } // end default constructor

public ArrayQueue(int initialCapacity) { T[] tempQueue = (T[]) new Object[initialCapacity + 1]; queue = tempQueue; frontIndex = 0; backIndex = initialCapacity; NumberOfEntries=0; } // end constructor

// Doubles the size of the array queue if it is full private void ensureCapacity() { … } // end ensureCapacity} // end ArrayQueue

A linked implementation of ADT Queue

/** A class that implements the ADT queue by using a chain of nodes that has both head and tail references.*/public class LinkedQueue<T> implements QueueInterface<T>{ private Node firstNode; // references node at front of queue private Node lastNode; // references node at back of queue

public LinkedQueue(){

firstNode = null;lastNode = null;

} // end default constructor

private class Node{…} // end Node

} // end Linkedqueue

7

Deque

DequeInterface

/** An interface for the ADT deque.*/public interface DequeInterface<T>{ public void addToFront(T newEntry); public void addToBack(T newEntry); public T removeFront(); public T removeBack(); public T getFront(); public T getBack(); public boolean isEmpty(); public void clear();} // end DequeInterface

A Doubly linked implementation of Deque

/** A class that implements the ADT deque by using a doubly linked chain of nodes.*/

public class LinkedDeque<T> implements DequeInterface<T>{ private DLNode firstNode; // references node for front of deque private DLNode lastNode; // references node for back of deque

public LinkedDeque(){

firstNode = null;

lastNode = null;} // end default constructorprivate class DLNode{

private T data; // deque entryprivate DLNode next; // link to next nodeprivate DLNode previous; // link to previous node

private DLNode(T dataPortion){

data = dataPortion;next = null;previous = null;

} // end constructor

private DLNode(DLNode previousNode, T dataPortion, DLNode nextNode)

{data = dataPortion;next = nextNode;previous = previousNode;

} // end constructor

private T getData(){

return data;} // end getData

} // end DLNode} // end LinkedDequ

8

PriorityQueue

PriorityQueueInterface

/** An interface for the ADT priority queue.*/public interface PriorityQueueInterface<T extends Comparable<? super T>>{ /** Adds a new entry to this priority queue. @param newEntry an object */ public void add(T newEntry);

/** Removes and returns the item with the highest priority. @return either the object with the highest priority or, if the priority queue is empty before the operation, null */ public T remove();

/** Retrieves the item with the highest priority. @return either the object with the highest priority or, if the priority queue is empty, null */ public T peek();

/** Detects whether this priority queue is empty. @return true if the priority queue is empty, or false otherwise */ public boolean isEmpty();

/** Gets the size of this priority queue. @return the number of entries currently in the priority queue */ public int getSize();

/** Removes all entries from this priority queue */ public void clear();} // end PriorityQueueInterface

9

List

ListInterface/** An interface for the ADT list. Entries in the list have positions that begin with 1.*/public interface ListInterface<T>{ /** Adds a new entry to the end of this list. Entries currently in the list are unaffected. The lists size is increased by 1. @param newEntry the object to be added as a new entry */ public void add(T newEntry); /** Adds a new entry at a specified position within this list. Entries originally at and above the specified position are at the next higher position within the list. The listÕs size is increased by 1. @param newPosition an integer that specifies the desired position of the new entry @param newEntry the object to be added as a new entry @return true if the addition is successful, or false if newPosition < 1, or newPosition > getLength() + 1 */ public boolean add(int newPosition, T newEntry); /** Removes the entry at a given position from this list. Entries originally at positions higher than the given position are at the next lower position within the list, and the list’s size is decreased by 1. @param givenPosition an integer that indicates the position of the entry to be removed @return a reference to the removed entry or null, if either the list was empty, givenPosition < 1, or

givenPosition > getLength() */ public T remove(int givenPosition); /** Removes all entries from this list. */ public void clear(); /** Replaces the entry at a given position in this list. @param givenPosition an integer that indicates the position of the entry to be replaced @param newEntry the object that will replace the entry at the position givenPosition @return true if the replacement occurs, or false if either the list is empty, givenPosition < 1, or givenPosition > getLength() */ public boolean replace(int givenPosition, T newEntry); /** Retrieves the entry at a given position in this list. @param givenPosition an integer that indicates the position of the desired entry @return a reference to the indicated entry or null, if either the list is empty, givenPosition < 1, or givenPosition > getLength() */ public T getEntry(int givenPosition); /** Sees whether this list contains a given entry. @param anEntry the object that is the desired entry @return true if the list contains anEntry, or false if not */ public boolean contains(T anEntry); /** Gets the length of this list. @return the integer number of entries currently in the list */ public int getLength(); /** Sees whether this list is empty. @return true if the list is empty, or false if not */ public boolean isEmpty(); /** Retrieves all entries that are in this list in the order in which

10

they occur in the list. */ public T[] toArray(); } // end ListInterface

11

Using Array to implement ADT list/** A class that implements the ADT list by using an array. The list is never full.*/public class AList<T> implements ListInterface<T>{private T[] list; // array of list entriesprivate int numberOfEntries;private static final int DEFAULT_INITIAL_CAPACITY = 25;

// public methods:public AList(){

this(DEFAULT_INITIAL_CAPACITY);} // end default constructor

public AList(int initialCapacity){ numberOfEntries = 0; // the cast is safe because the new array contains null entries @SuppressWarnings("unchecked") T[] tempList = (T[])new Object[initialCapacity]; list = tempList;} // end constructor

< Implementations of the rest of the public methods. . …..go here. > // Doubles the size of the array list if it is full. private void ensureCapacity() { … } // end ensureCapacity

/* Makes room for a new entry at newPosition. Precondition: 1 <= newPosition <= numberOfEntries + 1; where numberOfEntries is list’s length before addition. */private void makeRoom(int newPosition)

{ … } // end makeRoom// Shifts entries that are beyond the entry to be removed to the // next lower position.// Precondition: 1 <= givenPosition < numberOfEntries;// numberOfEntries is listÕs length before removal. */private void removeGap(int givenPosition){ … } // end removeGap

} // end AList

A linked implementation of ADT list

/** A linked implementation of the ADT list.*/public class LList<T> implements ListInterface<T>{private Node firstNode; // reference to first nodeprivate int numberOfEntries;

public LList(){

clear();} // end default constructor

< Implementations of the rest of the public methods. . …..go here. > // Returns a reference to the node at a given position. // Precondition: List is not empty; // 1 <= givenPosition <= numberOfEntriesprivate Node getNodeAt(int givenPosition){ … } // end getNodeAt

private class Node { … } // end Node

} // end LList

12

13

Sorted List

SortedListInterface/** An interface for the ADT sorted list. Entries in the list have positions that begin with 1. */public interface SortedListInterface <T extends Comparable <? super T>>{ /** Adds a new entry to this sorted list in its proper order. @param newEntry the object to be added as a new entry */ public void add(T newEntry); /** Removes a specified entry from this sorted list. @param anEntry the object to be removed @return true if anEntry was located and removed */ public boolean remove(T anEntry); /** Gets the position of an entry in this sorted list. @param anEntry the object to be found @return the position of the first or only occurrence of anEntry if it occurs in the list; otherwise returns the position where anEntry would occur in the list, but as a negative integer */ public int getPosition(T anEntry); // The following methods are described in 12.7 of Chapter 12 // as part of the ADT list: public T getEntry(int givenPosition); public boolean contains(T anEntry); public T remove(int givenPosition); public void clear(); public int getLength(); public boolean isEmpty(); public T[] toArray();

} // end SortedListInterface

A linked implementation of ADT sorted List/** A class that implements the ADT sorted list by using a chain of linked nodes. Duplicate entries are allowed.*/public class SortedLinkedList <T extends Comparable <? super T>> implements SortedListInterface<T>{ private Node firstNode; // reference to first node of chain private int numberOfEntries;

public SortedLinkedList() { firstNode = null; numberOfEntries = 0; } // end default constructor

< Implementations of the sorted list operations go here. >

/* Finds the node that is before the node that should or does contain a given entry. @param anEntry the object to be located @return either a reference to the node that is before the node that contains or should contain anEntry, or null if no prior node exists (that is, if anEntry belongs at the beginning of the list) */ private Node getNodeBefore(T anEntry) {... } // end getNodeBefore

private Node getNodeAt(int givenPosition) {… } // end getNodeAt

private class Node {… } // end class Node

14

}

15

A sorted List implementation that uses the ADT List

public class SortedList<T extends Comparable<? super T>> implements SortedListInterface<T>{

private ListInterface<T> list; // a list of entries

public SortedList(){

list = new LList<T>; // or: new Alist<T>

} // end default constructor…

}// end SortedLinkedList

Iterator

Iterator Interface

public interface Iterator<T>{/** Task: Detects whether the iterator has completed its traversal and

gone beyond the last entry in the collection of data.@return true if the iterator has another entry to return */public boolean hasNext();

/** Task: Retrieves the next entry in the collection and advances the iterator by one position.

@return a reference to the next entry in the iteration, if one exists@throws NoSuchElementException if the iterator had reached the end

already,ie. if hasNext() is false */public T next();

/** Task: Removes from the collection the last entry that next() returned. A subsequent call to next() will behave as it would have before the removal.

Precondition: next() has been called, and remove() has not been called since then. The collection has not been altered during the iteration except by calls to this method.

@throws IllegalStateException if next() has not been called, or if remove() was called already after the last call to next().

@throws UnsupportedOperationException if this iterator does not permit a remove operation. */

public void remove(); // Optional method

} // end Iterator

16

TreeInterfacepackage TreePackage;/** An interface for the ADT tree.*/public interface TreeInterface<T>{ public T getRootData(); public int getHeight(); public int getNumberOfNodes(); public boolean isEmpty(); public void clear();} // end TreeInterface

TreeIteratorInterface

package TreePackage;import java.util.Iterator;/** An interface of iterators for the ADT tree.*/public interface TreeIteratorInterface<T>{ public Iterator<T> getPreorderIterator(); public Iterator<T> getPostorderIterator(); public Iterator<T> getInorderIterator(); public Iterator<T> getLevelOrderIterator();} // end TreeIteratorInterface

BinaryTreeInterface

package TreePackage;/** An interface for the ADT binary tree.*/public interface BinaryTreeInterface<T> extends TreeInterface<T>, TreeIteratorInterface<T>{ /** Sets an existing binary tree to a new one-node binary tree. @param rootData an object that is the data in the new trees root */ public void setTree(T rootData);

/** Sets an existing binary tree to a new binary tree. @param rootData an object that is the data in the new trees root @param leftTree the left subtree of the new tree @param rightTree the right subtree of the new tree */ public void setTree(T rootData, BinaryTreeInterface<T> leftTree, BinaryTreeInterface<T> rightTree);} // end BinaryTreeInterface

17

BinaryNodeInterface

package TreePackage;/** An interface for a node in a binary tree.*/interface BinaryNodeInterface<T>{ /** Retrieves the data portion of this node. @return the object in the data portion of the node */ public T getData();

/** Sets the data portion of this node. @param newData the data object */ public void setData(T newData);

/** Retrieves the left child of this node. @return the node that is this nodeÕs left child */ public BinaryNodeInterface<T> getLeftChild();

/** Retrieves the right child of this node. @return the node that is this nodeÕs right child */ public BinaryNodeInterface<T> getRightChild();

/** Sets this nodeÕs left child to a given node. @param leftChild a node that will be the left child */ public void setLeftChild(BinaryNodeInterface<T> leftChild);

/** Sets this nodeÕs right child to a given node. @param rightChild a node that will be the right child */ public void setRightChild(BinaryNodeInterface<T> rightChild);

/** Detects whether this node has a left child. @return true if the node has a left child */ public boolean hasLeftChild();

/** Detects whether this node has a right child. @return true if the node has a right child */ public boolean hasRightChild();

/** Detects whether this node is a leaf. @return true if the node is a leaf */ public boolean isLeaf();

/** Counts the nodes in the subtree rooted at this node. @return the number of nodes in the subtree rooted at this node */ public int getNumberOfNodes();

/** Computes the height of the subtree rooted at this node. @return the height of the subtree rooted at this node */ public int getHeight();

/** Copies the subtree rooted at this node. @return the root of a copy of the subtree rooted at this node */ public BinaryNodeInterface<T> copy();} // end BinaryNodeInterface

BinaryNode

package TreePackage;/** A class that represents nodes in a binary tree.*/class BinaryNode<T> implements BinaryNodeInterface<T>, java.io.Serializable{ private T data; private BinaryNode<T> left; private BinaryNode<T> right;

18

…} // end BinaryNode

19

BinaryTree

package TreePackage;import java.util.Iterator;import java.util.NoSuchElementException;import StackAndQueuePackage.*;

/** A class that implements the ADT binary tree.*/public class BinaryTree<T> implements BinaryTreeInterface<T>{ private BinaryNodeInterface<T> root;

public BinaryTree() { root = null; } // end default constructor

public BinaryTree(T rootData){ root = new BinaryNode<T>(rootData);} // end constructor

public BinaryTree(T rootData, BinaryTree<T> leftTree,

BinaryTree<T> rightTree){

privateSetTree(rootData, leftTree, rightTree)} // end constructor

private void privateSetTree(T rootData, BinaryTree<T> leftTree,

BinaryTree<T> rightTree){… } // end privateSetTree

private BinaryNode<T> copyNodes() // not essential{…} // end copyNodes

protected void setRootData(T rootData){… } // end setRootData

protected void setRootNode(BinaryNodeInterface<T> rootNode){… } // end setRootNode

protected BinaryNodeInterface<T> getRootNode(){… } // end getRootNode

< Implementations of the TreeInterface go here. >< Implementations of the TreeIteratorInterface go here. >< Implementations of the BinaryTreeInterface go here. >

private class PreorderIterator implements Iterator<T>{private StackInterface<BinaryNodeInterface<T>> nodeStack;public PreorderIterator(){

nodeStack = new LinkedStack<BinaryNodeInterface<T>>();if (root != null)

nodeStack.push(root);} // end default constructor< Implementations of the IteratorInterface go here. >} // end of PreorderIterator

private class InorderIterator implements Iterator<T>{…} // end InOrderIteratorprivate class PostorderIterator implements Iterator<T>{…} // endPostOrderIteratorprivate class LevelOrderIterator implements Iterator<T>{…} // end LevelOrderIterator

20

} // end BinaryTree

21

SearchTreeInterfacepackage TreePackage;import java.util.Iterator;/** An interface for a search tree. */public interface SearchTreeInterface<T extends Comparable<? super T>> extends TreeInterface<T>{

/** Searches for a specific entry in this tree. @param entry an object to be found @return true if the object was found in the tree */ public boolean contains(T entry);

/** Retrieves a specific entry in this tree. @param entry an object to be found @return either the object that was found in the tree or null if no such object exists */ public T getEntry(T entry);

/** Adds a new entry to this tree. if the entry matches an object that exists in the tree already, replaces the object with the new entry. @param newEntry an object to be added to the tree @return either null if newEntry was not in the tree already, or an existing entry that matched the parameter newEntry and has been replaced in the tree */ public T add(T newEntry);

/** Removes a specific entry from this tree. @param entry an object to be removed @return either the object that was removed from the tree or null if no such object exists */ public T remove(T entry);

/** Creates an iterator that traverses all entries in this tree. @return an iterator that provides sequential and ordered access to the entries in the tree */ public Iterator<T> getInorderIterator();} // end SearchTreeInterface

BinarySearchTree

package TreePackage;import java.util.Iterator;

/** A class that implements the ADT binary search tree by extending BinaryTree - Iterative version.*/public class BinarySearchTreeI<T extends Comparable<? super T>> extends BinaryTree<T> implements SearchTreeInterface<T>{ public BinarySearchTreeI() { super(); } // end default constructor

public BinarySearchTreeI(T rootEntry) { super(); setRootNode(new BinaryNode<T>(rootEntry)); } // end constructor

public void setTree(T rootData) {… } // end setTree

public void setTree(T rootData,

22

BinaryTreeInterface<T> leftTree, BinaryTreeInterface<T> rightTree) {… } // end setTree public T getEntry(T entry) {… } // end getEntry

public boolean contains(T entry){… } // end contains

public T add(T newEntry){… } // end add

private T addEntry(T newEntry){… } // end addEntry

public T remove(T entry){… } // end remove

// Other public methods in SearchTreeInterface are inherited from BinaryTree.

// locate node that contains a match for entryprivate NodePair findNode(T entry){… } // end findNode

// Gets the node that contains the inorder predecessor of currentNode.// Precondition: currentNode has two children private NodePair getNodeToRemove(BinaryNodeInterface<T> currentNode){… } // end getNodeToRemove

// Removes a node having at most one child. private void removeNode(

BinaryNodeInterface<T> nodeToRemove, BinaryNodeInterface<T> parentNode)

{… } // end removeNode

private class NodePair{

private BinaryNodeInterface<T> first, second;

public NodePair(){ first = null; second = null;} // end default constructor

public NodePair(BinaryNodeInterface<T> firstNode, BinaryNodeInterface<T> secondNode){ first = firstNode; second = secondNode;} // end constructor

public BinaryNodeInterface<T> getFirst(){ return first;} // end getFirst

public BinaryNodeInterface<T> getSecond(){ return second;} // end getSecond

} // end NodePair

} // end BinarySearchTreeI

23