CST230: Applied Data Structures Chia Yuan Chuang "Cha" Adapted from course notes by Clifford A. Shaffer *

Stacks LIFO: Last In, First Out. Restricted form of list: Insert and remove only at front of list. Notation: Insert: PUSH Remove: POP The accessible element is called TOP. * *

Stack ADT public interface Stack<E> { /** Reinitialize the stack. */ public void clear(); /** Push an element onto the top of the stack. @param it Element being pushed onto the stack.*/ public void push(E it); /** Remove and return top element. @return The element at the top of the stack.*/ public E pop(); /** @return A copy of the top element. */ public E topValue(); /** @return Number of elements in the stack. */ public int length(); }; * *

Array-Based Stack Issues: Which end is the top? // Array-based stack implementation private int maxSize; // Max size of stack private int top; // Index for top private E [] listArray; Issues: Which end is the top? Where does “top” point to? What are the costs of the operations? * *

Linked Stack What are the costs of the operations? class LStack<E> implements Stack<E> { private Link<E> top; private int size; What are the costs of the operations? How do space requirements compare to the array-based stack implementation? * *

Expression Evaluation evaluate well-parenthesized expression main idea: Push open parenthesis ( to stack push numbers to stack push operators to different stack when close parenthesis encountered, pop operation, two numbers, and open paren. perform calculation, and push result stack should contain a single result after processing entire expression. Example: (((6+9) / 3) * (6 – 4))

Queues FIFO: First in, First Out Restricted form of list: Insert at one end, remove from the other. Notation: Insert: Enqueue Delete: Dequeue First element: Front Last element: Rear * *

Queue Implementation (1) If we stick to the requirement that the queue elements be at the beginning n elements of the array, then either enqueue or dequeue must be θ(n). Better is to let the elements “drift” within the array. Unfortunately, as items are added and removed, the queue “drifts” toward the end. Eventually, there will be no space to the right of the queue, even though there is space in the array. * *

Queue Implementation (2) By using the mod function, we can easily achieve the effect of a “circular” queue. This leaves one more issue. Where do the front and rear pointers go (point to the item? Or to the space before/after the item)? And, how do we distinguish a full from an empty queue? Given a fixed position for the front element (and its pointer), there are n-1 possible states for the queue (0 through n elements in the queue for an array of size n), but only n possible positions for rear. To solve this dilemma, we must either leave an empty slot in the queue, or use and external variable to determine if the queue is empty or not. * *

Dictionary Often want to insert records, delete records, search for records. Required concepts: Search key: Describe what we are looking for Key comparison Equality: sequential search Relative order: sorting Key: When describing what we are looking for, we don’t want to be required to describe the entire record, only one field of the record. If we already knew everything about the record, we probably wouldn’t need to look for it. * *

Records and Keys Problem: How do we extract the key from a record? Records can have multiple keys. Fundamentally, the key is not a property of the record, but of the context. Solution: We will explicitly store the key with the record. Can’t just compare records to each other. Need to extract the key. How? Could have an explicit key field? No. Explicit key method? No. Records can have multiple keys. Could the key method be type sensitive? No, multiple fields in the record can have the same type. There is a fundamental problem: They key is not a property of the record, it is a property of the context in which the record is being used. Key-Value pair. This is a traditional solution to this problem. Note that the key is overhead. But this becomes less of a problem as the relative size of the record gets large. * *

Dictionary ADT public interface Dictionary<Key, E> { public void clear(); public void insert(Key k, E e); public E remove(Key k); // Null if none public E removeAny(); // Null if none public E find(Key k); // Null if none public int size(); }; * *

Payroll Class // Simple payroll entry: ID, name, address class Payroll { private Integer ID; private String name; private String address; Payroll(int inID, String inname, String inaddr) { ID = inID; name = inname; address = inaddr; } public Integer getID() { return ID; } public String getname() { return name; } public String getaddr() { return address; } * *

Using Dictionary // IDdict organizes Payroll records by ID Dictionary<Integer, Payroll> IDdict = new UALdictionary<Integer, Payroll>(); // namedict organizes Payroll records by name Dictionary<String, Payroll> namedict = new UALdictionary<String, Payroll>(); Payroll foo1 = new Payroll(5, "Joe", "Anytown"); Payroll foo2 = new Payroll(10, "John", "Mytown"); IDdict.insert(foo1.getID(), foo1); IDdict.insert(foo2.getID(), foo2); namedict.insert(foo1.getname(), foo1); namedict.insert(foo2.getname(), foo2); Payroll findfoo1 = IDdict.find(5); Payroll findfoo2 = namedict.find("John"); UALdictionary stands for Unsorted Array-based List (implementation for a) dictionary. * *

Unsorted List Dictionary class UALdictionary<Key, E> implements Dictionary<Key, E> { private static final int defaultSize = 10; private AList<KVpair<Key, E>> list; // Constructors UALdictionary() { this(defaultSize); } UALdictionary(int sz) { list = new AList<KVpair<Key, E>>(sz); } public void clear() { list.clear(); } /** Insert an element: append to list */ public void insert(Key k, E e) { KVpair<Key,E> temp = new KVpair<Key,E>(k, e); list.append(temp); } Example implementation using the dictionary ADT. * *

Sorted vs. Unsorted List Dictionaries If list were sorted Could use binary search to speed search Would need to insert in order, slowing insert Which is better? If lots of searches, sorted list is good If inserts are as likely as searches, then sorting is no benefit. * *