Stacks with Dynamic Memory Class Signature Class Node {public Data data; public Node next; } Class Stack { private Node top; public Stack(); public void push(Data node); public Data pop(); public Data look(); public boolean isEmpty(); public boolean isFull(); } Questions: How would you create a stack of different types? Are dynamic stacks faster or slower than using arrays? Public versus private variables in Node. What error checking would be advisable?

Stack Methods public Stack() {top = null; } push(Data data) { Node newNode = new Node(data); newNode.next = top; top = newNode; } Data pop() throws StackException { Data data = peek(); top = top.next; return data; } Data peek() throws StackException { if (!isEmpty() return top.data; else throw new StackException(); } isEmpty() {return top==null;} isFull() {return false;}

Queues with dynamic memory Class Signature Class Node {public Data data; public Node next; } Class Queue { private Node head; private Node tail; public Queue(); public void add(Data node); public Data remove(); public Data peek(); public boolean isEmpty(); public boolean isFull(); }

Queue Methods Public Queue() {head = tail = null; } add(Data data) { Node newNode = new Node(data) if (isEmpty()) head = tail = newNode; else { tail.next = newNode; tail = newNode; } } Data remove() throws QueueException { Data data = look(); head = head.next; if (isEmpty() tail = null; return data; } Data peek() throws QueueException { if (!isEmpty()) return head.data; else throw new QueueException(); } isEmpty() {return head==null;} isFull() {return false;}

Find in a List See demos/SLL.java

Binary Trees Storage rules: Root node has no parent Leaf nodes have no children. Storage rules: All values in the left subtree are less than the value of the root. All values in the right subtree are greater than or equal to the value of the root. These rules apply recursively to each of the two subtrees. Traversal types (performing an action on all nodes): Preorder: perform the action when you visit the node, then visit the left child, then the right. Inorder: visit the left child, then perform the action, then visit the right. Postorder: visit the left child, then the right, then perform the action.

Binary Trees with dynamic memory Partial Class Signature for a binary tree Class Node {public Comparable<D> data; public Node left; public Node right;} Class Tree {private Node root; public Tree(); public void insert(<D> data); public Node remove(<D> data); public Node find(<D> data); public void traverse(String rule);} How could a tree with nodes that have varying numbers of children be declared?

InOrder Traversal of a Tree The tree illustrated is a BST (Binary Search Tree) public class Tree<D> { private class Node<D> { private D data; private Node left, right; private Node (D d, Node l,r) { data = d; left = l; right = r; }} Node root; public void inOrderTraverse(Node n) { if (n==null) return; inOrderTraverse(n.left); visit(n); inOrderTraverse(n.right); } 50 30 60 20 40 10 90 15 Balance a tree by minimizing the number of levels: Sort values then choose the midpoint of the list as the root. Recursively bisect the sorted list, choosing each midpoint as the root of the next level.

Traversing a maze Base case Recursive step Current location in the array is [x-1,y-1] Recursive step For each direction traverse maze in that direction. Return result if true returned as result of the recursive call Enhancement possibilities – not required in the lab Support multiple paths

Lab 6 Multiple path maze int[][] grid = { {1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1}, {1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1}, {1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0}, {1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1}, {1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1}, {1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1}, {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1} }; Multiple paths are not required in the lab or exam. How to avoid cycles when creating the tree? How could we find the shortest path of the multiple paths?