540 likes | 681 Views
CS1020. Week 8: 13 th March 2014. Contents. Part 1 : : Discussion on Stacks/Queues practice exercises (#28 – 32) Part 2: Discussion on Take-home Lab #4. Part 1. Practice Exercises #28 – 32. Ex #28: Simple Exercise on Stack (1/6). Add 10 5. Top. 5. 10. Add 7 2 12. Top. 12. 2.
E N D
CS1020 Week 8: 13thMarch 2014
Contents • Part 1: : Discussion on Stacks/Queues practice exercises (#28 – 32) • Part 2: Discussion on Take-home Lab #4 Week 8
Part 1 Practice Exercises #28 – 32 Week 8
Ex #28: Simple Exercise on Stack (1/6) Add 10 5 Top 5 10 Add 7 2 12 Top 12 2 7 5 10 Query 2 5 Top 10 Add 11 20 18 4 7 Top 7 4 18 20 11 10 Query 4 18 Top 20 11 10 Add 3 8 9 Top 9 8 3 20 11 10 Query 20 3 Query (3) not met Top Add 17 6 15 Top 15 6 17 Query 15 Top 6 17 Week 8
Ex #28: Simple Exercise on Stack (2/6) • StackLL class (given) uses BasicLinkedList (also given) as its internal data structure, providing all stack operations such as isEmpty(), peek(), pop() and push(). • To complete client program StackExercise.java Week 8
Ex #28: Simple Exercise on Stack (3/6) public class StackExercise { public static void main(String [] args) throws NoSuchElementException { StackLL <Integer> stack = new StackLL <Integer> (); Scanner sc = new Scanner(System.in); String op; while (sc.hasNext()) { op = sc.next(); if (op.equals("Add")) { // Fill in the code } else if (op.equals("Query")) { // Fill in the code } } } // You may write additional method(s) to make your program more modular } Week 8
Ex #28: Simple Exercise on Stack (4/6) if (op.equals("Add")) { // Fill in the code } while(sc.hasNextInt()) { stack.push(sc.nextInt()); } System.out.println("Items added: " + stack); Week 8
Ex #28: Simple Exercise on Stack (5/6) else if(op.equals("Query")) { // Fill in the code } booleansuccess = true; while(sc.hasNextInt()) { if(!found(stack, sc.nextInt())) { success = false; break; } } if(success) System.out.print("Query met: "); else System.out.print("Query not met: "); System.out.println(stack); Week 8
Ex #28: Simple Exercise on Stack (6/6) // To find an item in the stack by repeatedly // popping item to see if it is the item required public static boolean found(StackLL <Integer> stack, inti) { while (!stack.isEmpty()) { if (stack.pop() == i) returntrue; } returnfalse; } Week 8
Ex #29: Simple Exercise on Queue (1/6) Add 10 5 Front 10 5 Add 7 2 12 Front 10 5 7 2 12 Query 5 2 Front 12 Add 11 20 18 4 7 Front 12 11 20 18 4 7 Query 12 20 Front 18 4 7 Add 3 8 9 Front 18 4 7 3 8 9 Query 3 4 Query (4) not met Front Add 17 6 15 Front 17 6 15 Query 17 Front 6 15 Week 8
Ex #29: Simple Exercise on Queue (2/6) • QueueLLclass (given) uses TailedLinkedList(also given) as its internal data structure, providing all queue operations such as isEmpty(), peek(), poll() and offer(). • Note that poll() is often called dequeue(), and offer() is often called enqueue() in the literature. • To complete client program QueueExercise.java Week 8
Ex #29: Simple Exercise on Queue(3/6) public class QueueExercise { public static void main(String [] args) throws NoSuchElementException { QueueLL <Integer> queue= newQueueLL <Integer> (); Scanner sc = new Scanner(System.in); String op; while (sc.hasNext()) { op = sc.next(); if (op.equals("Add")) { // Fill in the code } else if (op.equals("Query")) { // Fill in the code } } } // You may write additional method(s) to make your program more modular } Week 8
Ex #29: Simple Exercise on Queue (4/6) if (op.equals("Add")) { // Fill in the code } while(sc.hasNextInt()) { queue.offer(sc.nextInt()); } System.out.println("Items added: " + queue); Week 8
Ex #29: Simple Exercise on Queue(5/6) else if(op.equals("Query")) { // Fill in the code } booleansuccess = true; while(sc.hasNextInt()) { if(!found(queue, sc.nextInt())) { success = false; break; } } if(success) System.out.print("Query met: "); else System.out.print("Query not met: "); System.out.println(queue); Week 8
Ex #29: Simple Exercise on Queue(6/6) // To find an item in the queue by repeatedly // dequeueingitem in front to see if it is the //item required public static boolean found(QueueLL <Integer> queue, inti) { while(!queue.isEmpty()) { if (queue.poll() == i) returntrue; } returnfalse; } Week 8
Ex #30: QuickEat (1/9) • Problem • Customers order food and are served on a first-come-first-serve basis. • When the dish is ready • Case1: It is given to the first customer in the queue who ordered it. • Case2: It is thrown away if no one ordered it. Week 8
Ex #30: QuickEat (2/9) • Input • Number of food items N > 0 3 Fish n Chips Chicken Chop Grilled salmon • Number of instructions K > 0 4 Order 1 2 1 3 Order 2 1 3 Ready 3 Ready 2 Week 8
Ex #30: QuickEat (3/9) • Input • ‘Order’ instruction: Order + tag number + K ordered dishes + K selected items Examples: Order 1 2 1 3 Order 2 1 3 • ‘Ready’ instruction: Ready + ready dish Examples: Ready 3 Ready 2 Week 8
Ex #30: QuickEat (4/9) • Output: • If the dish is ready, print out: • Case 1: [Dish name] ready to be served to Tag [Tag number]. • Case 2: Throw away [Dish name]. Examples: Grilled salmon ready to be served to Tag 1 Throw away Chicken Chop. Week 8
Ex #30: QuickEat (5/9) • Hint: • Class ListOrder to store all orders of customers. class ListOrder { intnumDishes; // each dish has a queue of customers who // ordered this dish private ArrayList<Queue<Integer>> dishQueues; … } Week 8
Ex #30: QuickEat (6/9) • Hint: • ArrayList of all dishes, each list is a queue: Order 1 2 1 3 Customer 1 ordered 2 dishes: dish 1 and dish 3 Order 2 1 3 Customer 2 ordered 1 dish: dish 3 • Dish 1Dish 2Dish 3 Customer 1 front of queueCustomer 1 Customer 2 Week 8
Ex #30: QuickEat (7/9) • Hint • In Java API, Queue is an interface and thus cannot be instantiated, i.e. Queue<Integer> queue = new Queue<Integer> produces compile-error. • You may implement your own Queue class class Queue<E> { … } • Or … Week 8
Ex #30: QuickEat (8/9) • Hint: • Use LinkedList API which implements Queue Queue<Integer> queue= new LinkedList<Integer> • After that, we can use these methods from the API: queue.offer() queue.peek() queue.poll() Week 8
Ex #30: QuickEat (9/9) • Hint: • Be careful of reading input 4 Order 1 2 1 3 … intnumOfInstructions = sc.nextInt(); sc.nextLine(); // to capture the '\n' character String instruction = sc.next(); Week 8
Ex #31: Web Browser History Ex #31: Web Browser History • This is one of last year’s sit-in lab exercises • Objective • Simulate navigating the web using browsing history • Browsing history stores the list of web pages the user has navigated to in the past • Navigation rules • User can go backwards and forwards along the browsing history to revisit past pages • Once user navigates to a new URL, all pages in front of the new page are cleared from the browsing history so that the new page becomes the current last page. • Print out the browsing history at the end and also the current page the user is on. Week 8
Solution – Linked List Ex #31: Web Browser History • Use a Linked List to store the pages browsed. • Represent the webpages as a String • ListNode<E> ListNode<String> • Variable to track starting node, head ,already given • Need a variable curpageto track node representing the current page user is at. • Initialize – curpage = head = null Week 8
Navigating to a new page (1/3) Ex #31: Web Browser History • Insert a new node (newnode) containing the new page into the Linked List. • LinkedList class given does not have a method to insert a node, so create one • public ListNode<E> addAfter(ListNode <E> current, E item) • Insert new page item after current page currentand return the new node inserted. Week 8
Navigating to a new page (2/3) Ex #31: Web Browser History • Insert new node after curpageand delete all pages/nodes after new node newnode newnode.setNext(null) head null … … curpage curpage.setNext(newnode) Deleted Week 8
Navigating to a new page (3/3) Ex #31: Web Browser History • Point curpage to newnode. • If head == null, head = curpage/* head is never changed after adding the 1st page .. Why?*/ newnode head null … curpage curpage.setNext(newnode) Week 8
Moving Forwards Ex #31: Web Browser History • If curpage.getNext() is not null, point curpageto curpage.getNext() • Otherwise don’t do anything since curpage is at the latest page Week 8
Moving Backwards Ex #31: Web Browser History • If curpage == head, that is curpage is earliest page in the browsing history, don’t do anything • Otherwise use a temporary reference ListNode<String> temp to find the new current page curpage head temp null … Week 8
Moving Backwards Ex #31: Web Browser History • Move temp forwards – temp = temp.getNext() curpage head temp null … Week 8
Moving Backwards Ex #31: Web Browser History • Until temp.getNext() == curpage curpage head temp null … Week 8
Moving Backwards Ex #31: Web Browser History • curpage = temp • /* Can this be made easier using a variant of the linked list? */ curpage head temp null … Week 8
Printing Browsing History Ex #31: Web Browser History • Point temporary variable to head and move forward while printing out the String in node pointed to. Stop when hit null. • Print out String in node that curpage is pointing to. Week 8
Stack implementation - Overview Ex #31: Web Browser History • Use 2 stacks, Backward stack and Forward stack, and a reference curpage to current page being browsed • Algorithm • If browse backward, and Backward stack not empty • Push curpage onto Forward stack • Pop top of Backward stack and point curpage to it. • If browse forward, and Forward stack not empty • Push curpage onto Backward stack • Pop top of Forward stack and point curpage to it. • Navigate to a new page • Push curpage onto Backward stack if curpage is not null • Point curpage to new page • Clear Forward stack Week 8
Stack implementation - Overview Ex #31: Web Browser History • At the end, how do you print out the browsing history from earliest page to latest page? Week 8
Ex #32: Simple Parser Ex #32: Simple Parser • This is one of last year’s sit-in lab exercises • Objective • Implement a simple parser for a markup language • Markup language rules • An empty source file is syntactically correct. • An opening tag must be closed. • There should not be any invalid tags in the source file. • If an opening tag is embedded in the environment of another opening tag, the inner opening tag must be closed before closing the outer opening tag. • Print out whether the given source file is syntactically correct or not. Week 8
How to check given input is correct – Linked List solution Ex #32: Simple Parser • Notice that only need to check 2 things • Input tags are all valid • All open tags are closed properly (encounter their corresponding close tags before the close tags of outer open tags) Week 8
Checking that input tag is valid (1/3) Ex #32: Simple Parser • Need to create a Tag class to represent tags • Member variables • private String tag– stores string representation of tag • private int id– stores id of tag (open and close tag of paired tags have the same id) • private int type– stores type of tag (open,close,other -> use 3 distinct values to distinguish, eg0,1,2) • Constructor • public Tag (String itag, intidentity, intitype) { tag = itag; id = identity; type = itype; } • Other corresponding methods to access and set member variables Week 8
Checking that input tag is valid (2/3) Ex #32: Simple Parser • Create a Tagarray in Parserclass to contain information on all valid tags. private static final Token[] ValidTags= { new Tag("<S>",0,0),new Tag("<P>",1,0), new Tag("<B>",2,0),new Tag("<I>",3,0), new Tag("</S>",0,1),new Tag("</P>",1,1), new Tag("</B>",2,1),new Tag("</I>",3,1) new Tag("<LB>",4,2),new Tag("<PB>",5,2), new Tag("<TEXT>",6,2)}; Note that open and close tags of paired tags have the same id, and all paired tags and non-paired tags have distinct ids. Week 8
Checking that input tag is valid (3/3) Ex #32: Simple Parser • When reading in a tag, check if it is a valid tag by comparing with string representation of each tag in ValidTags. • If it cannot be found in ValidTags, then tag is invalid, and input is not syntactically correct. Week 8
Checking that all open tags are closed properly (Linked List solution) (1/2) Ex #32: Simple Parser • If tag is valid, and it is an open tag (check its type), create a new node and add to front of Linked List. • In the skeleton program, adding to front of Linked List is not given. Need to implement this • public void addFront(E item) Week 8
Adding to front of Linked List Ex #32: Simple Parser Current tag read <S> head null … public void addFront(item E) { head = new ListNode <E> (item, head); num_nodes++; /* increment number of nodes */ } Week 8
Checking that all open tags are closed properly (Linked List solution) (2/2) Ex #32: Simple Parser • If tag is valid, and it is a close tag (check its type), check if node that head is pointing to is corresponding open tag (check that id is the same) • Is not corresponding open tag, then input is not syntactically correct–incorrectly placed close tag. • Is corresponding open tag; remove node that head is pointing to. • Implement remove front node function • public void removeFront() Week 8
Remove front node of Linked List Ex #32: Simple Parser null head null … public void removeFront() { ListNode<E> temp; temp = head; head = head.getNext(); temp.setNext(null); num_nodes--; /* decrement number of nodes */ } Week 8
After reading all input tags Ex #32: Simple Parser • If Linked List still has some nodes (num_nodes > 0), then input is not syntactically correct – some open tags are not closed. Week 8
Stack implementation - Overview Ex #32: Simple Parser • Check if all input tags are valid – as described previously • Put valid open tags into stack • If encounter valid close tag check if top of stack is corresponding open tag. • Pop it off the stack if it is • Input is syntactically incorrect if it is not. • If stack is not empty after reading in all input tags, then input is syntactically incorrect, otherwise it is correct. Week 8
Part 2 Discussion on Take-Home Lab #4 Week 8
Cargo Optimization (1/4) • Problem: • Containers arrives at the terminal in a random order, addressed to different destination ships (A-Z) • They need to be stacked at the terminal • The destination ships arrives at the terminal in a fixed sequence (A-Z) Week 8