What is computer science

int id; String name; String major;

public int silly (int k, int [ ] c, Student s) {

k++; c[1]++; this.setID(k);

if (s != null) s.setID(c[0]);

if (!s.equals(this)) s = this;

return(k);

}

public void setID (int newID) {id = newID;}

int i, j; int[] a, b; Student p, q, r;

i = 5; j = 6; j = i;

a = new int[3]; b = a; b[0] = 5; a[1]++;

p = new Student(8, ”Jo”, ”CS”);

q = new Student(9, ”Lee”, ”C&O”);

r = p;

j = p.silly(i,a,q);

Implementation of List as a partially-filled array

• 
  Uses two instance variables:
  

int numItems; // number of elements in List

Object [] items; // storage for List's elements

or more simply diagrammed as

• 
  Straightforward implementations for size(), isEmpty() and get(index) using
  

private int translate(int position) {

// pre: 1  position  numItems+1

// post: returns position - 1

return position - 1;

}

Updating an array-based List

• 
  simple loop needed to close gap
  

public void remove (int index)throws ListIndexOutOfBoundsException {

// post: If 1 <= index <= size(), the item at position index in the

// list is deleted, and other items are renumbered accordingly;

// throws ListIndexOutOfBoundsException if index < 1 or

// index > size().

if (index >= 1 && index <= numItems) {

for (int pos = index+1; pos <= size(); pos++)

{

items[translate(pos-1)] =

items[translate(pos)];

}

numItems--;

}

else {

throw new ListIndexOutOfBoundsException(

"ListIndexOutOfBoundsException on remove");

}

}

• 
  removeAll () simply requires setting items to a new empty array
  
  
  

Adding elements to an array-based List

• 
  add(index, item) might require array to be enlarged
  
• 
  replacing the array:
  

• 
  allocate a larger array (but how much larger?)
  
• 
  copy all the elements (object references) to the new array
  
• 
  replace (the reference to) the old array by (a reference to) the new one
  

Alternative implementation of List: singly-linked list

• 
  Expands and contracts as needed
  
• 
  Diagrammatic representation
  

Manipulating linked list elements

Node methods: see Carrano & Prichard p 161

Node myNode = new Node(new Integer(5));

myNode.setItem(new Integer(7));

myNode.setNext(new Node(new Integer(9)));

myNode.getNext().setItem(new Integer(2));

Node temp = myNode.getNext();

Node node = new Node(myNode.getItem());

temp.setNext(node);

Implementation of List as a singly-linked list

public class ListReferenceBased implements

ListInterface {

private Node head;

private int numItems;
private Node find(int index) {

// pre: 1  index  numItems

// post: Returns a reference to the node at position index

Node curr = head;

for (int skip = 1; skip < index; skip++) {

curr = curr.getNext();

}

return curr;

}
public void remove(int index)

throws ListIndexOutOfBoundsException {

// post: see previous slide for precondition and postcondition

if (index >= 1 && index <= numItems) {

if (index==1){ head=head.getNext();

} else {

Node prev = find(index-1);

Node curr = prev.getNext();

prev.setNext(curr.getNext());

}

numItems--;

} else {

throw new

ListIndexOutOfBoundsException();

}

}

...

}

Variations on linked lists

• 
  circularly linked lists
  
  
• 
  doubly-linked lists
  
  

• 
  other variants: no counters; more links; “sentinel” element at end
  

ADT Deque

• 
  alternative linear collection
  
• 
  functionality:
  

• 
  add only at either of the two ends
  
• 
  read at ends
  
• 
  test for membership via contains
  
• 
  remove at ends
  

• 
  implementation alternatives:
  

• 
  as linked list (singly-linked, doubly-linked, circular)
  
• 
  as Vector or ArrayList
  

• 
  efficiency trade-offs?
  

Measuring efficiency

• 
  some possible measures:
  

• 
  the amount of time it takes to code
  
• 
  the amount of memory the code uses
  
• 
  the amount of time it takes to run
  
• 
  the amount of memory the data uses
  

• 
  costs to prepare and to maintain software critical aspects of software engineering
  
• 
  principal measures for this course: efficiency of software execution
  
• 
  How can we compare several possible choices of algorithm or several possible implementations of an interface?
  

• 
  run the code (stopwatch approach)
  

• 
  influenced by hardware
  
• 
  influenced by compiler and system software
  
• 
  influenced by simultaneous users’ activity
  
• 
  influenced by selection of data
  

• 
  analyze the code (or pseudo-code)
  

• 
  still influenced by choice of data
  

Comparing implementations

• 
  first approximation: abstraction that ignores low level details
  

• 
  calculate number of method invocations for critical methods used
  
• 
  typically interested in methods that read object’s values or change object’s values
  
• 
  for collections, often interested in
  

• 
  number of data values encountered (e.g., how many calls to getNext())
  
• 
  number of data values moved or modified (e.g., how many calls to setNext() or setItem())
  

• 
  concerned with how algorithm behaves across all possible inputs
  

• 
  worst-case analysis (worst input)
  
• 
  best-case analysis (best input)
  
• 
  average-case analysis (depends on distributions)
  

• 
  usually analysis done with respect to data of a given, but unknown, size
  

• 
  e.g., Considering all collections having N elements (for any fixed value of N), how many times is operation P executed in the worst case?
  

Code analysis: example

Consider possible implementation of a remove by value method for array-based representation of List

public Object removeByValue(Object obj){

// pre: obj is non-null

// post: removes and returns the first object equal to obj from the array;

// returns null if no objects are equal to obj

int index;

for (index = 0; index < numItems; index++){

if (obj.equals(items[index])) break;

}

if (index == numItems) return null;

Object val = items[index];

numItems--;

while (index < numItems) {

items[index] = items[index+1];

index++;

}

items[numItems] = null; // free reference

return val;

}

• 
  How many calls will be made to equals (comparing two data values)?
  

• 
  best case? worst case?
  
• 
  what would influence the average case?
  

• 
  How many elements are moved to a new location in the array?
  

• 
  best case? worst case?
  

ADT Stack

• 
  A linear collection, (s₁, s₂, ..., s_n), of elements accessed from one end only
  

• 
  top: s_n
  

• 
  Sometimes called a LIFO structure (last-in first-out)
  
• 
  Operations:
  

• 
  createStack()
  
• 
  boolean isEmpty()
  
• 
  void popAll()
  
• 
  void push(Object newItem)
  
• 
  Object pop()
  
• 
  Object peek()
  

• 
  Applications:
  

• 
  processing nested elements (e.g., subroutine flow control)
  
• 
  reversing element ordering
  

Using a stack to check that parentheses are balanced

• 
  a(b()cd(e))(f)g is OK, but not (h(i)k or l(m)) or n)(
  

class BalanceChecker implements

StackInterface {

...

public boolean check (String in) {

this.popAll();

for (int i=0; i < in.length(); i++) {

if (in.charAt(i) == ‘(’)

push(new Integer(i));

else if (in.charAt(i) == ‘)’) {

if (isEmpty())

return false;

Integer open =(Integer) pop();

// open.intValue() position has matching (

}

}

if (!isEmpty())

return false;

return true;

}

}

• 
  Why does this algorithm work?
  

Array-based implementation of Stack

Linked-list-based implementation of Stack

Implementing method calls using a stack

• 
  An array-based stack is normally used within generated code
  
• 
  All information needed to support a particular method call is kept in an activation record
  

• 
  space for parameter values
  
• 
  space for local variables
  
• 
  space for location to which control is returned
  

• 
  During execution, maintain the stack of activation records
  

• 
  When method called: activation record created, initialized, and pushed onto the stack
  
• 
  When a method finishes, its activation record is popped
  

ADT Queue

• 
  A linear collection, (q₁, q₂, ..., q_n), of elements accessed in sequence
  

• 
  front: q₁; rear: q_n
  

• 
  Sometimes called a FIFO structure (first-in first-out)
  
• 
  Operations:
  

• 
  createQueue()
  
• 
  boolean isEmpty()
  
• 
  void dequeueAll()
  
• 
  void enqueue(Object newItem)
  
• 
  Object dequeue()
  
• 
  Object peek()
  

• 
  Applications:
  

• 
  communications channel
  
• 
  items waiting to be serviced
  

The use of queues in producer-consumer situations

• 
  General situation: one software package is producing data and another is consuming the same data.
  

• 
  Rate of consumption or production often data-dependent.
  
• 
  Producer can use enqueue to insert and Consumer can use dequeue to take data in insertion order.
  

Queue using a circular linked list





public Object dequeue ( ) {

// pre: queue is not empty

// post: the head of the queue is removed and returned

Object val = tail.getNext().getItem();

count--;

if (count == 0) tail = null;

else tail.setNext(

tail.getNext().getNext());

return val;

}
public void enqueue(Object val) {

// post: val is added to the tail of the queue

Node temp = new Node(val);

if (count == 0) {

tail = temp;

tail.setNext(tail);

}

else {

temp.setNext(tail.getNext());

tail.setNext(temp);

tail = temp;

}

count++;

}

Queue using a “circular” array

• 
  Naïve use of array
  

• 
  dequeue  shuffling values to start of array
  

• 
  Alternative: let queue drift down array
  

• 
  when reaching end of array, wrap around to start
  

• 
  Implementation details . . .
  

see Carrano & Prichard, Chapter 7

Recursive definitions

• 
  common in mathematics
  

Recursive definition defines an object in terms of smaller objects of the same type.

• 
  includes base (degenerate) cases and recursive cases
  
• 
  Example 1: factorial function
  

n! = 1 if n=0 {base case}
n! = n(n-1)! if n>0 {recursive case}

• 
  Example 2: Fibonacci numbers
  

f₀ = f₁ = 1 {base cases}
f_n = f_n-1 + f_n-2 if n2 {recursive case}

• 
  Example 3: balanced strings
  

• 
  base case:
  

A string containing no parentheses is balanced.

• 
  recursive cases:
  

(x) is balanced if x is a balanced string.

xy is balanced if x and y are balanced strings.

Binary Tree

• 
  A binary tree is a finite collection of nodes that is
  

• 
  empty, or
  
• 
  partitioned into 3 sub-collections: a designated node, called the root, together with two binary trees, designated as left and right subtrees
  

• 
  Tree terms for nodes: root and leaf
  
• 
  Familial terms for nodes: parent, child, sibling, ancestor, descendant
  

Binary trees on three nodes

• 
  Note: one-to-one correspondence between nodes in a binary tree and non-empty binary subtrees encompassed by that tree
  

Labelled binary trees

• 
  Typically nodes are labelled.
  
• 
  Examples:
  

• 
  yes-no decision tree
  

• 
  expression tree (for binary operators)
  

• 
  Semantics captured by nesting
  

Recursive structures

public interface Nesting {

public boolean isEmpty();

// post: Returns true iff this is empty

public Object getRootItem() throws

TreeException;

// post: Returns value associated with the root; throws

// TreeException if this is empty

public void setRootItem(Object newItem);

// post: Replaces the item in the root with newItem, if this is

// not empty; otherwise, sets this to consist only of a root node

// whose root item is newItem

public void removeAll();

//post: This is empty

}

ADT Binary Tree

• 
  based on recursive definition of tree
  

public interface BinaryTreeInterface extends

NestingInterface {

public void attachLeftSubtree

(BinaryTreeInterface leftTree)

throws TreeException;

// pre: leftTree is non-null

// post: throws TreeException if this is empty or the left subtree

// is non-empty; otherwise, left subtree of this is tree originally referred

// to by leftTree and leftTree now refers to an empty tree
public BinaryTreeInterface

detachLeftSubtree()throws TreeException;

// post: Throws TreeException if this is empty; otherwise,

// detaches and returns the left subtree of this; this’ left subtree is empty.

...

}

• 
  other methods exist (e.g. analogous methods for right subtrees)
  
• 
  might consider additional methods such as size(), left(), right(), encompasses() or isNested()
  
• 
  Carrano & Prichard extend BinaryTreeBasis instead of Nesting
  

Recursive programs

• 
  Solution defined in terms of solutions for smaller problems of the same type
  

int solve (int n) {. . .

value = solve(n-1) + solve(n/2);

. . .}

• 
  One or more base cases defined
  

. . . if (n < 10) value = 1; . . .

• 
  Some base case is always reached eventually.
  

Example:

static public int fib (int n) {

// pre: n  0

// post: returns the nth Fibonacci number

if (n < 2) return 1;

else return fib(n-1) + fib(n-2);

}

• 
  N.B. structure of code typically parallels structure of definition
  

Tracing recursive programs

• 
  recall: stack of activation records
  

• 
  When method called: activation record created, initialized, and pushed onto the stack
  
• 
  When a method finishes, its activation record is popped
  

• 
  same mechanism for recursive programs
  

Recursive subtree programs

• 
  calculating the size of a subtree
  

public int size() {

// post: returns number of elements in this

if (isEmpty()) return 0;

BinaryTreeInterface left = detachLeftSubtree();

BinaryTreeInterface right = detachRightSubtree();

int subTreeSize = 1 + left.size() + right.size();

attachLeftSubtree(left);

attachRightSubtree(right);

return subTreeSize;

}

• 
  following a path to find a subtree
  

public Object follow(Queue path) {

// pre: path is not null and path objects are all Boolean

// post: returns item at root of subtree identified by path of booleans s.t.

// true  follow left branch, false  right and path is set to

// empty queue; returns null if path invalid, and valid

// prefix of path is dequeued

if (isEmpty()) return null;

if (path.isEmpty()) return this.getRootItem();

if (((Boolean) path.dequeue()).booleanValue()) {

BinaryTreeInterface left = detachLeftSubtree();

Object result = left.follow(path);

attachLeftSubtree(left);

return result;

} else {

BinaryTreeInterface right = detachRightSubtree();

Object result = right.follow(path);

attachRightSubtree(right);

return result;

}

}

Linked implementation

• 
  linked implementation for binary trees uses a TreeNode class:
  
• 
  3 data fields (item, leftChild, rightChild)
  
• 
  representation of an empty binary subtree?
  
• 
  Carrano & Prichard Chapter 10
  
• 
  alternative approaches: no non-recursive wrapper, store count, parent references
  
• 
  
  

Tree traversals

• 
  want to traverse a tree in some orderly manner
  
• 
  we visit each node exactly once (e.g. print its contents or determine if it meets certain criteria)
  
• 
  one option is to visit the nodes level by level:
  

• 
  for each level of the tree

  visit each node at that level

  
  

• 
  traversal: X B S K O I A C L Z E
  

• 
  known as a breadth-first traversal.
  

• 
  can be implemented using a queue
  

Iterators

• 
  Auxiliary types that provide access to the elements of a collection
  

• 
  each element is “visited” once, and only once
  

• 
  Iterator interface from java.util
  

Iterator i = someTree.getLevelOrderIterator();

while (i.hasNext()) {

… i.next(); …

}

• 
  May promise a particular order for visiting the elements
  
• 
  Subclasses may add two more operators:
  

• 
  void reset()
  
• 
  Object value()
  

• 
  remove() will delete the last element returned by an iterator
  
• 
  however, in general, behaviour usually undefined if a collection changes during iteration
  
• 
  Note: several iterators can visit a single structure simultaneously
  

Depth-first traversals

• 
  visit tree’s components (root, left subtree, right subtree) in some order
  
• 
  preorder traversal:
  

• 
  visit the root
  
• 
  visit the left subtree recursively
  
• 
  visit the right subtree recursively
  

• 
  Preorder traversal yields parents before children, but does not completely characterize a tree’s structure.
  

Implementing tree iterators

• 
  In the absence of parent pointers, iterator supporting depth-first traversal requires a stack.
  

• 
  For preorder, stack maintains list of non-empty subtrees remaining to be visited
  

• 
  when visiting a node, push right subtree (if non-empty) and then left subtree (if non-empty) onto stack
  
• 
  peek the top of the stack to find current node
  
• 
  pop the stack to find next node to visit
  
• 
  iterator completes when stack is empty
  

• 
  Alternatively, all the work can be done during construction of the iterator using recursion
  

Inorder traversal

• 
  ordering:
  

• 
  visit the left subtree recursively
  
• 
  visit the root
  
• 
  visit the right subtree recursively
  

• 
  inorder traversal of expression tree gives an infix expression
  

• 
  traversal: 2 * 3 + 5 – 7 – 2 * 3
  
• 
  but need to insert ( before visiting any subtree and ) after visiting any subtree
  

((((2)*((3)+(5)))-(7))-((2)*(3)))

or perhaps (((2*(3+5))-7)-(2*3))

• 
  does not characterize which value labels the root
  

Postorder traversal

• 
  ordering
  

• 
  visit the left subtree recursively
  
• 
  visit the right subtree recursively
  
• 
  visit the root
  

• 
  Postorder traversal yields children before parents.
  
• 
  Postorder traversal of an expression tree gives a postfix expression (used for some calculators)
  

2 3 5 + * 7 – 2 3 * -

• 
  unambiguous without parentheses !
  
• 
  “reverse Polish notation” created in 1920s by logician Jan Lukasiewicz
  

Properties of binary trees

• 
  often expressed recursively (following definition of binary tree)
  
• 
  depth (or level) of a node:
  

• 
  root has level 1
  
• 
  otherwise 1+ level of parent
  

• 
  height of a tree:
  

• 
  if the tree is empty, its height is 0
  
• 
  otherwise, the height is

  1 + max{height T_L, height T_R }, where T_L and T_R designate left and right subtrees