14. Stacks and Queues
|
|
|
- Amos Thomas
- 5 years ago
- Views:
Transcription
1 1
2 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues Section 4.3
3 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman implementation Linked lists Implementations
4 Data types and data structures Data types Set of values. Set of operations on those values. Some are built in Java: int, double, String,... Most are not: Complex, Picture, Charge,... Data structures Represent data. Represent relationships among data. Some are built in Java: 1D arrays, 2D arrays,... Most are not: linked list, circular list, tree,... Design challenge f every data type: Which data structure use? Resource 1: How much memy is needed? Resource 2: How much time do data-type methods use? 4
5 Stack and Queue APIs A collection is an ADT whose values are a multiset of items, all of the same type. Two fundamental collection ADTs differ in just a detail of the specification of their operations. Add the ginning Stack operations Add an item the collection. Remove and return the item most recently added (LIFO). Test if the collection is empty. Return the size of the collection. Take from the ginning Last In First Out Queue operations Add an item the collection. Remove and return the item least recently added (FIFO). Test if the collection is empty. Return the size of the collection. Take from the ginning First In First Out Stacks and queues both arise naturally in countless applications. Add the end A key characteristic. No limit on the size of the collection. 5
6 Example of stack operations push the ginning pop from the ginning Push. Add an item the collection. Pop. Remove and return the item most recently added. push the ginning pop from the ginning Last In First Out push not that is pop not that stack contents after operation not not not not not that is 6
7 Example of queue operations dequeue from the ginning Enqueue. Add an item the collection. Dequeue. Remove and return the item least recently added. First In First Out enqueue at the end enqueue not that is dequeue queue contents after operation dequeue from the ginning enqueue at the end not not not not not not not that not that that that that is 7
8 Parameterized data types Goal. Simple, safe, and clear client code f collections of any type of data. Java approach: Parameterized data types (generics) Use placeholder type name in definition. Substitute concrete type f placeholder in clients. stay tuned f examples Stack API public class Stack<Item> Stack<Item>() create a stack of objects, all of type Item void push(item item) add item stack Item pop() remove and return the item most recently pushed boolean isempty() is the stack empty? int size() # of objects on the stack Queue API public class Queue<Item> Queue<Item>() create a queue of objects, all of type Item void enqueue(item item) add item queue Item dequeue() remove and return the item least recently enqueued boolean isempty() is the queue empty? int size() # of objects on the queue 8
9 Perfmance specifications Challenge. Provide guarantees on perfmance. Goal. Simple, safe, clear, and efficient client code. Typically required f client code scalable Perfmance specifications All operations are constant-time. Memy use is proptional the size of the collection, when it is nonempty. No limits within the code on the collection size. Java. Any implementation of the API implements the stack/queue abstractions. RS+KW. Implementations that do not meet perfmance specs do not implement the abstractions. 9
10 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman implementation Linked lists Implementations
11 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman implementation Linked lists Implementations
12 Stack and queue applications Queues First-come-first-served resource allocation. Asynchronous data transfer (StdIn, StdOut). Dispensing requests on a shared resource (printer, process). Simulations of the real wld (guitar string, traffic analysis,...) Stacks Last-come-first-served processes (browser, ). Function calls in programming languages. Basic mechanism in interpreters, compilers
13 Queue client example: Read all strings from StdIn in an array Challenge Can t sre strings in array fe creating the array. Can t create the array without knowing how many strings are in the input stream. Can t know how many strings are in the input stream without reading them all. Solution: Use a Queue<String>. public class QEx Note: StdIn has this functionality public static String[] readallstrings() // See next slide. public static void main(string[] args) String[] wds = readallstrings(); f (int i = 0; i < wds.length; i++) StdOut.println(wds[i]); % me moby.txt moby dick herman melville call me ishmael some years ago never mind how long precisely having little no money... % java QEx < moby.txt moby dick herman melville call me ishmael some years... 13
14 Queue client example: Read all strings from StdIn in an array Solution: Use a Queue<String>. Sre strings in the queue. Get the size when all have en read from StdIn. Create an array of that size. Copy the strings in the array. public class QEx public static String[] readallstrings() Queue<String> q = new Queue<String>(); while (!StdIn.isEmpty()) q.enqueue(stdin.readstring()); int N = q.size(); String[] wds = new String[N]; f (int i = 0; i < N; i++) wds[i] = q.dequeue(); return wds; public static void main(string[] args) String[] wds = readallstrings(); f (int i = 0; i < wds.length; i++) StdOut.println(wds[i]); 14
15 Stack example: "Back" butn in a browser Typical scenario Visit a page. Click a link another page. Click a link another page. Click a link another page. Click "back" butn. Click "back" butn. Click "back" butn
16 Auboxing Challenge. Use a primitive type in a parameterized ADT. Wrapper types Each primitive type has a wrapper reference type. Wrapper type has larger set of operations than primitive type. Example: Integer.parseInt(). Values of wrapper types are objects. Wrapper type can used in a parameterized ADT. primitive type int long double boolean wrapper type Integer Long Double Boolean Auboxing. Aumatic cast from primitive type wrapper type. Au-unboxing. Aumatic cast from wrapper type primitive type. Simple client code (no casts) Stack<Integer> stack = new Stack<Integer>(); stack.push(17); // Aubox (int -> Integer) int a = stack.pop(); // Au-unbox (Integer -> int) 16
17 Stack client example: Postfix expression evaluation Infix. Standard way of writing arithmetic expressions, using parentheses f precedence. Example. (1+((2+3)*(4*5))) = (1+(5*20)) = 101 Postfix. Write operar after operands (instead of in tween them). Example * * + Remarkable fact. No parentheses are needed! also called "reverse Polish" notation (RPN) Jan Łukasiewicz * * + There is only one way parenthesize a postfix expression. 1 (2+3)4 5 * * + 1 ((2+3)*(4*5))+ (1+((2+3)*(4*5))) find first operar, convert infix, enclose in () iterate, treating suxpressions in parentheses as amic HP-35 (1972) First handheld calcular. "Enter" means "push". No parentheses. Next. With a stack, postfix expressions are easy evaluate. Made slide rule obsolete (!) 17
18 Postfix arithmetic expression evaluation Algithm While input stream is nonempty, read a ken. Value: Push on the stack. Operar: Pop operand(s), apply operar, push the result * * * * + = 5 = 20= 100 =
19 Stack client example: Postfix expression evaluation public class Postfix public static void main(string[] args) Stack<Double> stack = new Stack<Double>(); while (!StdIn.isEmpty()) String ken = StdIn.readString(); if (ken.equals("*")) stack.push(stack.pop() * stack.pop()); else if (ken.equals("+")) stack.push(stack.pop() + stack.pop()); else if (ken.equals("-")) stack.push(- stack.pop() + stack.pop()); else if (ken.equals("/")) stack.push((1.0/stack.pop()) * stack.pop()); else if (ken.equals("sqrt")) stack.push(math.sqrt(stack.pop())); else stack.push(double.parsedouble(ken)); StdOut.println(stack.pop()); % java Postfix * * % java Postfix 1 5 sqrt + 2 / Perspective Easy add operars of all sts. Can do infix with two stacks (see text). Could output TOY program. Indicative of how Java compiler wks. 19
20 Real-wld stack application: PostScript PostScript (Warnock-Geschke, 1980s): A turtle with a stack. Postfix program code (push literals; functions pop arguments). Add commands drive virtual graphics machine. Add loops, conditionals, functions, types, fonts, strings... push(100) PostScript code stroke move line line line call "move" (takes args from stack) define a path draw the path A simple virtual machine, but not a y Easy specify published page. Easy implement on various specific printers. Revolutionized wld of publishing. Another stack machine: The JVM ( Java Virtual Machine)! 20
21 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman implementation Linked lists Implementations
22 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman implementation Linked lists Implementations
23 Strawman ADT f pushdown stacks Warmup: simplify the ADT Implement only f items of type String. Have client provide a stack capacity in the construcr. values public class StrawStack Strawman API StrawStack(int max) void push(string item) String pop() create a stack of capacity max add item stack return the string most recently pushed boolean isempty() is the stack empty? int size() numr of strings on the stack Rationale. Allows us represent the collection with an array of strings. 23
24 Strawman implementation: Instance variables and construcr Data structure choice. Use an array hold the collection. instance variables construcr methods public class StrawStack private String[] a; private int N = 0; a[0] a[1] a[2] items on stack test client... public StrawStack(int max) a = new String[max];... N "upside down" representation of 24
25 Strawman stack implementation: Test client public static void main(string[] args) int max = Integer.parseInt(args[0]); StrawStack stack = new StrawStack(max); while (!StdIn.isEmpty()) String item = StdIn.readString(); if (item.equals("-")) stack.push(item); else StdOut.print(stack.pop()); StdOut.println(); What we expect, once the implementation is done. instance variables construcrs methods % me.txt not that is % java StrawStack 20 <.txt not that test client 25
26 TEQ 1 on stacks Q. Can we always insert pop() commands make items come out in sted der? Example Example Example
27 TEQ 1 on stacks Q. Can we always insert pop() commands make items come out in sted der? Example Example Example A. No. Example. 5 6 no way f 5 popped fe 6 Note. In a queue, they always come out in the der they came in. 27
28 Strawman implementation: Methods Methods define data-type operations (implement APIs). instance variables construcrs after push() methods public class StrawStack... public boolean isempty() return (N == 0); public void push(object item) a[n++] = item; N test client public String pop() return a[--n]; N after pop() public int size() return N;... all constant-time one-liners! N 28
29 Strawman pushdown stack implementation public class StrawStack private String[] a; private int N = 0; public StrawStack(int max) a = new String[max]; public boolean isempty() return (N == 0); public void push(string item) a[n++] = item; public String pop() return a[--n]; public int size() return N; public static void main(string[] args) int max = Integer.parseInt(args[0]); StrawStack stack = new StrawStack(max); while (!StdIn.isEmpty()) String item = StdIn.readString(); if (item.compareto("-")!= 0) stack.push(item); else StdOut.print(stack.pop()); StdOut.println(); instance variables construcr methods test client % me.txt not that is % java StrawStack 20 <.txt not that 29
30 Trace of strawman stack implementation (array representation) push not that is pop not that a[0] a[1] a[2] a[3] a[4] a[5] N not not not not not not that that that that is that a[6] stack contents after operation a[7] a[8] a[9] a[10] a[11] a[12] a[13] Significant wasted space when stack size is not near the capacity (typical). a[14] a[15] a[16] a[17] a[18] a[19] 30
31 Benchmarking the strawman stack implementation StrawStack implements a fixed-capacity collection that haves like a stack if the data fits. It does not implement the stack API meet the perfmance specifications. Stack API StrawStack wks only f strings public class Stack<Item> Stack<Item>() void push(item item) Item pop() boolean isempty() is the stack empty? StrawStack requires client provide capacity create a stack of objects, all of type Item add item stack remove and return the item most recently pushed int size() # of objects on the stack Perfmance specifications All operations are constant-time. Memy use is proptional the size of the collection, when it is nonempty. No limits within the code on the collection size. Nice try, but need a new data structure. 31
32 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman implementation Linked lists Implementations
33 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman implementation Linked lists Implementations
34 Data structures: sequential vs. linked Sequential data structure Put objects next one another. TOY: consecutive memy cells. Java: array of objects. Fixed size, arbitrary access. i th element Array at C0 addr value C0 "Alice" C1 "Bob" C2 "Carol" Linked list at C4 addr value C0 "Carol" C1 null C2 C3 C3 Linked data structure Associate with each object a link another one. TOY: link is memy address of next object. Java: link is reference next object. Variable size, sequential access. Overlooked by novice programmers. Flexible, widely used method f ganizing data. next element C4 C5 C6 C7 C8 C9 CA CB C4 C5 C6 C7 C8 C9 CA CB "Alice" CA "Bob" C0 34
35 Simplest singly-linked data structure: linked list Linked list A recursive data structure. Def. A linked list is null a reference a node. Def. A node is a data type that contains a reference a node. Unwind recursion: A linked list is a sequence of nodes. private class Node private String item; private Node next; Representation Use a private nested class Node implement the node abstraction. F simplicity, start with nodes having two values: a String and a Node. A linked list first "Alice" "Bob" "Carol" item next null 35
36 Singly-linked data structures Even with just one link ( ) a wide variety of data structures are possible. Tree Linked list (this lecture) Rho Circular list (TSP) General case Multiply linked structures: many me possibilities! From the point of view of a particular object, all of these structures look the same. 36
37 Building a linked list addr value C0 "Carol" Node third = new Node(); third.item = "Carol"; third.next = null; Node second = new Node(); second.item = "Bob"; second.next = third; Node first = new Node(); first.item = "Alice"; first.next = second; third C0 second CA first C4 C1 C2 C3 C4 C5 C6 C7 C8 null "Alice" CA first second third C9 CA "Bob" "Alice" "Bob" "Carol" CB C0 null 37
38 List processing code Standard operations f processing data structured as a singly-linked list Add a node at the ginning. Remove and return the node at the ginning. Add a node at the end (requires a reference the last node). Traverse the list (visit every node, in sequence). An operation that calls f a doubly-linked list (slightly yond our scope) Remove and return the node at the end. 38
39 List processing code: Remove and return the first item Goal. Remove and return the first item in a linked list first. first "Alice" "Bob" "Carol" item = first.item; item "Alice" first "Alice" "Bob" "Carol" first = first.next; return item; item "Alice" item "Alice" first "Alice" "Bob" "Carol" available f garbage collection first "Bob" "Carol" 39
40 List processing code: Add a new node at the ginning Goal. Add item a linked list first. item "Dave" first "Alice" "Bob" "Carol" Node second = first; second first "Alice" "Bob" "Carol" second first = new Node(); first "Alice" "Bob" "Carol" second first.item = item; first.next = second; first "Dave" "Alice" "Bob" "Carol" 40
41 List processing code: Traverse a list Goal. Visit every node on a linked list first. Node x = first; while (x!= null) StdOut.println(x.item); x = x.next; first x "Alice" "Bob" "Carol" StdOut Alice Bob Carol 41
42 TEQ 1 on linked lists Q. What is the effect of the following code (not-so-easy question)?... Node list = null; while (!StdIn.isEmpty()) Node old = list; list = new Node(); list.item = StdIn.readString(); list.next = old; f (Node t = list; t!= null; t = t.next) StdOut.println(t.item);... 42
43 TEQ 1 on linked lists Q. What is the effect of the following code (not-so-easy question)?... Node list = null; while (!StdIn.isEmpty()) Node old = list; list = new Node(); list.item = StdIn.readString(); list.next = old; f (Node t = list; t!= null; t = t.next) StdOut.println(t.item);... list old list not old list not A. Prints the strings from StdIn on StdOut, in reverse der. Note. Better use a stack. 43
44 TEQ 2 on stacks Q. Give code that uses a stack print the strings from StdIn on StdOut, in reverse der. 44
45 TEQ 2 on stacks Q. Give code that uses a stack print the strings from StdIn on StdOut, in reverse der. A. Stack<String> stack = new Stack<String>(); while (!StdIn.isEmpty()) stack.push(stdin.readstring()); while (!stack.isempty()) StdOut.println(stack.pop()); 45
46 TEQ 2 on linked lists Q. What is the effect of the following code (not-so-easy question)?... Node list = new Node(); list.item = StdIn.readString(); Node last = list; while (!StdIn.isEmpty()) last.next = new Node(); last = last.next; last.item = StdIn.readString();... 46
47 TEQ 2 on linked lists Q. What is the effect of the following code (not-so-easy question)?... Node list = new Node(); list.item = StdIn.readString(); Node last = list; while (!StdIn.isEmpty()) last.next = new Node(); last = last.next; last.item = StdIn.readString();... list list list last last not last A. Puts the strings from StdIn on a linked list, in the der they are read (assuming at least one string). Note. Better use a queue, in most applications. In this course, we restrict use of linked lists data-type implementations 47
48 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman implementation Linked lists Implementations
49 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman implementation Linked lists Implementations
50 ADT f pushdown stacks: review A pushdown stack is an idealized model of a LIFO srage mechanism. An ADT allows us write Java programs that use and manipulate pushdown stacks. public class Stack<Item> API Stack<Item>() void push(item item) Item pop() create a stack of objects, all of type Item add item stack remove and return the item most recently pushed boolean isempty() is the stack empty? int size() # of objects on the stack Perfmance specifications All operations are constant-time. Memy use is proptional the size of the collection, when it is nonempty. No limits within the code on the collection size. 50
51 Pushdown stack implementation: Instance variables and construcr Data structure choice. Use a linked list hold the collection. instance variables construcr public class Stack<Item> private Node first = null; private int N = 0; private class Node private Item item; private Node next;... use in place of concrete type first objects on stack methods test client Annoying exception (not a problem here). Can't declare an array of Item objects (don't ask why). Need cast: Item[] a = (Item[]) new Object[N] 51
52 Stack implementation: Test client public static void main(string[] args) Stack<String> stack = new Stack<String>(); while (!StdIn.isEmpty()) String item = StdIn.readString(); if (item.equals("-")) stack.push(item); else System.out.print(stack.pop()); StdOut.println(); instance variables construcrs methods % me.txt not that is % java Stack <.txt not that test client What we expect, once the implementation is done. 52
53 Stack implementation: Methods Methods define data-type operations (implement the API). instance variables construcrs public class Stack<Item>... public boolean isempty() return first == null; public void push(item item) Node second = first; first = new Node(); first.item = item; first.next = second; N++; public Item pop() Item item = first.item; first = first.next; N--; return item; public int size() return N;... add a new node the ginning of the list remove and return first item on list instance variable first first first first second methods test client local variable in push() 53
54 Stack implementation public class Stack<Item> private Node first = null; private int N = 0; private class Node private Item item; private Node next; public boolean isempty() return first == null; public void push(item item) Node second = first; first = new Node(); first.item = item; first.next = second; N++; public Item pop() Item item = first.item; first = first.next; N--; return item; public int size() return N; public static void main(string[] args) // See earlier slide instance variables nested class methods test client % me.txt not that is % java Stack <.txt not that 54
55 Trace of stack implementation (linked list representation) push not that is pop not that Push the ginning not not not not not that is Pop from the ginning 55
56 Benchmarking the stack implementation Stack implements the stack abstraction. It does implement the API and meet the perfmance specifications. Stack API public class Stack<Item> Stack<Item>() void push(item item) Item pop() create a stack of objects, all of type Item add item stack remove and return the item most recently pushed Perfmance specifications boolean isempty() is the stack empty? int size() All operations are constant-time. Memy use is proptional the size of the collection, when it is nonempty. No limits within the code on the collection size. Made possible by linked data structure. # of objects on the stack dequeue(): same code as pop() enqueue(): slightly me complicated, like TEQ 2 Also possible implement the queue abstraction with a singly-linked list (see text). 56
57 Summary Stacks and queues Fundamental collection abstractions. Differ only in der in which items are removed. Perfmance specifications: Constant-time f all operations and space proptional numr of objects. push the ginning stack pop from the ginning Last In First Out queue dequeue from the ginning First In First Out Linked structures Fundamental alternative sequential structures. Enable implementations of the stack/queue abstractions that meet perfmance specifications. enqueue at the end Next: Symbol tables 57
58 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman implementation Linked lists Implementations
59 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues Section 4.3
14. Stacks and Queues
1 COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues Section 4.3 http://introcs.cs.princen.edu COMPUTER SCIENCE S E D G E W I C K / W A Y N E 14. Stacks and Queues APIs Clients Strawman
COMPUTER SCIENCE. Computer Science. 12. Stacks and Queues. Computer Science. An Interdisciplinary Approach. Section 4.3
COMPUTER SCIENCE S E D G E W I C K / W A Y N E PA R T I I : A L G O R I T H M S, T H E O R Y, A N D M A C H I N E S Computer Science Computer Science An Interdisciplinary Approach Section 4.3 ROBERT SEDGEWICK
14. Stacks and Queues
Section 4.3 http://introcs.cs.princen.edu Data types and data structures Data types APIs Clients Strawman implementation Linked lists Implementations http://introcs.cs.princen.edu Set of values. Set of
4.3 Stacks and Queues
4.3 Stacks and Queues Introduction to Programming in Java: An Interdisciplinary Approach Robert Sedgewick and Kevin Wayne Copyright 2002 2010 03/30/12 04:33:08 PM Data Types and Data Structures Data types.
! Set of operations (add, remove, test if empty) on generic data. ! Intent is clear when we insert. ! Which item do we remove? Stack.
Stacks and Queues 4.3 Stacks and Queues Fundamental data types.! Set of operations (add, remove, test if empty) on generic data.! Intent is clear when we insert.! Which item do we remove? Stack.! Remove
4.3 Stacks and Queues. Stacks. Stacks and Queues. Stack API
Stacks and Queues 4.3 Stacks and Queues Fundamental data types. Set of operations (add, remove, test if empty) on generic data. Intent is clear when we insert. Which item do we remove? Stack. Remove the
TSP assignment next lecture
3/18/12 Data Types and Data Structures CS 112 Introduction to Programming Data types. Set of values and operations on those values. Some are built into the Java language: int, double[], String, Most are
4.3 Stacks, Queues, and Linked Lists
4.3 Stacks, Queues, and Linked Lists Introduction to Programming in Java: An Interdisciplinary Approach Robert Sedgewick and Kevin Wayne Copyright 2002 2010 3/21/2013 8:59:11 PM Data Types and Data Structures
Algorithms. Algorithms 1.3 BAGS, QUEUES, AND STACKS. stacks resizing arrays. queue. generics. applications. Stacks and queues
ROBERT SEDGEWICK KEVIN WAYNE Algithms ROBERT SEDGEWICK KEVIN WAYNE Stacks and queues Algithms F O U R T H E D I T I O N http://algs4.cs.princen.edu 1.3 BAGS, QUEUES, AND STACKS stacks resizing arrays queues
Algorithms. Algorithms. Algorithms 1.3 BAGS, QUEUES, AND STACKS. stacks resizing arrays queues generics iterators applications
Algithms Stacks and queues 1.3 BAGS, QUEUES, AND STACKS Fundamental data types. Value: collection of objects. Operations: insert, remove, iterate, test if empty. Intent is clear when we insert. Which item
Stacks and Queues. stacks dynamic resizing queues generics iterators applications. Stacks and queues
Stacks and queues Stacks and Queues stacks dynamic resizing queues generics iterars applications Fundamental data types. Values: sets of objects Operations: insert, remove, test if empty. Intent is clear
Algorithms. Algorithms. Algorithms 1.3 BAGS, QUEUES, AND STACKS. stacks resizing arrays queues generics iterators applications
Algithms ROBERT SEDGEWICK KEVIN WAYNE Stacks and queues 1.3 BAGS, QUEUES, AND STACKS Fundamental data types. Value: collection of objects. Operations: add, remove, iterate, test if empty. Intent is clear
Algorithms. Algorithms 1.3 BAGS, QUEUES, AND STACKS. stacks resizing arrays queues generics iterators applications. Is Polleverywhere working?
Is Polleverywhere wking? Algithms ROBERT SEDGEWICK KEVIN WAYNE 1.3 BAGS, QUEUES, AND STACKS Algithms F O U R T H E D I T I O N ROBERT SEDGEWICK KEVIN WAYNE http://algs4.cs.princen.edu stacks resizing arrays
Basic Data Structures
Basic Data Structures Some Java Preliminaries Generics (aka parametrized types) is a Java mechanism that enables the implementation of collection ADTs that can store any type of data Stack s1
Abstract Data Types and Java Generics. Fundamentals of Computer Science
Abstract Data Types and Java Generics Fundamentals of Computer Science Outline Abstract Data Types (ADTs) A collection of data and operations on that data Data Structure How we choose to implement an ADT
Basic Data Structures 1 / 24
Basic Data Structures 1 / 24 Outline 1 Some Java Preliminaries 2 Linked Lists 3 Bags 4 Queues 5 Stacks 6 Performance Characteristics 2 / 24 Some Java Preliminaries Generics (aka parametrized types) is
2.6 Stacks and Queues
Stacks and Queues 2.6 Stacks and Queues Fundamental data types.! Set of operations (add, remove, test if empty) on generic data.! Intent is clear when we insert.! Which item do we remove? Stack.! Remove
Stacks and Queues. !stacks!dynamic resizing!queues!generics!applications. Stacks and Queues
Stacks and Queues Stacks and Queues!stacks!dynamic resizing!queues!generics!applications Fundamental data types. Values: sets of objects Operations: insert, remove, test if empty. Intent is clear when
Algorithms. Algorithms 1.3 STACKS AND QUEUES. stacks resizing arrays queues generics iterators applications ROBERT SEDGEWICK KEVIN WAYNE.
Algorithms ROBERT SEDGEWICK KEVIN WAYNE 1.3 STACKS AND QUEUES Algorithms F O U R T H E D I T I O N ROBERT SEDGEWICK KEVIN WAYNE http://algs4.cs.princeton.edu stacks resizing arrays queues generics iterators
Implemen'ng abstract data types. CSCI 135: Fundamentals of Computer Science Keith Vertanen
Implemen'ng abstract data types CSCI 135: Fundamentals of Computer Science Keith Vertanen Overview Abstract Data Types (ADTs) A collec7on of data and opera7ons on that data Data structure How we choose
Implemen'ng abstract data types
Implemen'ng abstract data types CSCI 135: Fundamentals of Computer Science I Keith Vertanen Copyright 2012 Overview Abstract Data Types (ADTs) A collec7on of data and opera7ons on that data Data structure
4.3: Linked Structures
Linked vs. Sequential Allocation 4.3: Linked Structures "The name of the song is called 'Haddocks' Eyes.' " "Oh, that's the name of the song, is it?" Alice said, trying to feel interested. "No, you don't
PA3 Design Specification
PA3 Teaching Data Structure 1. System Description The Data Structure Web application is written in JavaScript and HTML5. It has been divided into 9 pages: Singly linked page, Stack page, Postfix expression
The Stack and Queue Types
The Stack and Queue Types Hartmut Kaiser hkaiser@cct.lsu.edu http://www.cct.lsu.edu/ hkaiser/fall_2012/csc1254.html 2 Programming Principle of the Day Do the simplest thing that could possibly work A good
EC8393FUNDAMENTALS OF DATA STRUCTURES IN C Unit 3
UNIT 3 LINEAR DATA STRUCTURES 1. Define Data Structures Data Structures is defined as the way of organizing all data items that consider not only the elements stored but also stores the relationship between
csci 210: Data Structures Stacks and Queues
csci 210: Data Structures Stacks and Queues 1 Summary Topics Stacks and Queues as abstract data types ( ADT) Implementations arrays linked lists Analysis and comparison Applications: searching with stacks
CS W3134: Data Structures in Java
CS W3134: Data Structures in Java Lecture #10: Stacks, queues, linked lists 10/7/04 Janak J Parekh HW#2 questions? Administrivia Finish queues Stack/queue example Agenda 1 Circular queue: miscellany Having
Introduction to Programming Using Java (98-388)
Introduction to Programming Using Java (98-388) Understand Java fundamentals Describe the use of main in a Java application Signature of main, why it is static; how to consume an instance of your own class;
STACKS AND QUEUES. Problem Solving with Computers-II
STACKS AND QUEUES Problem Solving with Computers-II 2 Stacks container class available in the C++ STL Container class that uses the Last In First Out (LIFO) principle Methods i. push() ii. iii. iv. pop()
COMPUTER SCIENCE. 15. Symbol Tables. Section 4.4.
COMPUTER SCIENCE S E D G E W I C K / W A Y N E 15. Symbol Tables Section 4.4 http://introcs.cs.princeton.edu COMPUTER SCIENCE S E D G E W I C K / W A Y N E 15.Symbol Tables APIs and clients A design challenge
Queues Fall 2018 Margaret Reid-Miller
Queues 15-121 Fall 2018 Margaret Reid-Miller Today Exam 2 is next Tuesday, October 30 Writing methods various classes that implement Lists. Methods using Lists and Big-O w/ ArrayList or LinkedLists Prove
Lecture 4 Stack and Queue
Lecture 4 Stack and Queue Bo Tang @ SUSTech, Spring 2018 Our Roadmap Stack Queue Stack vs. Queue 2 Stack A stack is a sequence in which: Items can be added and removed only at one end (the top) You can
Stacks Fall 2018 Margaret Reid-Miller
Stacks 15-121 Fall 2018 Margaret Reid-Miller Today Exam 2 is next Tuesday, October 30 Today: Quiz 5 solutions Recursive add from last week (see SinglyLinkedListR.java) Stacks ADT (Queues on Thursday) ArrayStack
CMSC 132: Object-Oriented Programming II. Stack and Queue
CMSC 132: Object-Oriented Programming II Stack and Queue 1 Stack Allows access to only the last item inserted. An item is inserted or removed from the stack from one end called the top of the stack. This
Cosc 241 Programming and Problem Solving Lecture 9 (26/3/18) Collections and ADTs
1 Cosc 241 Programming and Problem Solving Lecture 9 (26/3/18) Collections and ADTs Michael Albert michael.albert@cs.otago.ac.nz Keywords: abstract data type, collection, generic class type, stack 2 Collections
Linked List. April 2, 2007 Programming and Data Structure 1
Linked List April 2, 2007 Programming and Data Structure 1 Introduction head A linked list is a data structure which can change during execution. Successive elements are connected by pointers. Last element
16-Dec-10. Collections & Data Structures ABSTRACTION VS. IMPLEMENTATION. Abstraction vs. Implementation
Collections & Data Structures Boaz Kantor Introduction to Computer Science IDC Herzliya ABSTRACTION VS. IMPLEMENTATION 2 Abstraction vs. Implementation Data structures provide both abstraction and implementation.
Java generics. h"p:// h"p://
Java generics h"p://www.flickr.com/photos/pdxdiver/4917853457/ h"p://www.flickr.com/photos/paj/4002324674/ CSCI 136: Fundamentals of Computer Science II Keith Vertanen Copyright 2014 Overview Abstract
Lecture P5: Abstract Data Types
Review Lecture P5: Abstract Data Types Data type: Set of values and collection of operations on those values. Example: int Set of values: between -32,767 and 32,767 (minimum limits). Operations: +, -,
Name Section Number. CS210 Exam #2 *** PLEASE TURN OFF ALL CELL PHONES*** Practice
Name Section Number CS210 Exam #2 *** PLEASE TURN OFF ALL CELL PHONES*** Practice All Sections Bob Wilson OPEN BOOK / OPEN NOTES You will have all 90 minutes until the start of the next class period. Spend
Advanced Java Concepts Unit 3: Stacks and Queues
Advanced Java Concepts Unit 3: Stacks and Queues Stacks are linear collections in which access is completely restricted to just one end, called the top. Stacks adhere to a last-in, first-out protocol (LIFO).
MULTIMEDIA COLLEGE JALAN GURNEY KIRI KUALA LUMPUR
STUDENT IDENTIFICATION NO MULTIMEDIA COLLEGE JALAN GURNEY KIRI 54100 KUALA LUMPUR FIFTH SEMESTER FINAL EXAMINATION, 2014/2015 SESSION PSD2023 ALGORITHM & DATA STRUCTURE DSEW-E-F-2/13 25 MAY 2015 9.00 AM
Abstract Data Types. Stack. January 26, 2018 Cinda Heeren / Geoffrey Tien 1
Abstract Data Types Stack January 26, 2018 Cinda Heeren / Geoffrey Tien 1 Abstract data types and data structures An Abstract Data Type (ADT) is: A collection of data Describes what data are stored but
Java generics. CSCI 136: Fundamentals of Computer Science II Keith Vertanen
Java generics h"p://www.flickr.com/photos/pdxdiver/4917853457/ h"p://www.flickr.com/photos/paj/4002324674/ CSCI 136: Fundamentals of Computer Science II Keith Vertanen Overview Abstract Data Types (ADTs)
CSCI 135 Exam #2 Fundamentals of Computer Science I Fall 2013
CSCI 135 Exam #2 Fundamentals of Computer Science I Fall 2013 Name: This exam consists of 6 problems on the following 6 pages. You may use your two-sided hand-written 8 ½ x 11 note sheet during the exam.
Postfix (and prefix) notation
Postfix (and prefix) notation Also called reverse Polish reversed form of notation devised by mathematician named Jan Łukasiewicz (so really lü-kä-sha-vech notation) Infix notation is: operand operator
STACKS. A stack is defined in terms of its behavior. The common operations associated with a stack are as follows:
STACKS A stack is a linear data structure for collection of items, with the restriction that items can be added one at a time and can only be removed in the reverse order in which they were added. The
Lists. CSC212 Lecture 8 D. Thiebaut, Fall 2014
Lists CSC212 Lecture 8 D. Thiebaut, Fall 2014 Review List = Organization of Data in a Linear Fashion, where Order is Important Set of actions that can be carried out efficiently on the data. Typical Actions
MIDTERM EXAMINATION Spring 2010 CS301- Data Structures
MIDTERM EXAMINATION Spring 2010 CS301- Data Structures Question No: 1 Which one of the following statement is NOT correct. In linked list the elements are necessarily to be contiguous In linked list the
! A data type for which: ! In fact, an ADT may be implemented by various. ! Examples:
Ch. 8: ADTs: Stacks and Queues Abstract Data Type A data type for which: CS 8 Fall Jill Seaman - only the properties of the data and the operations to be performed on the data are specific, - not concerned
CSCI 135 Exam #2 Fundamentals of Computer Science I Fall 2013
CSCI 135 Exam #2 Fundamentals of Computer Science I Fall 2013 Name: This exam consists of 6 problems on the following 6 pages. You may use your two-sided hand-written 8 ½ x 11 note sheet during the exam.
Stacks and queues. CSCI 135: Fundamentals of Computer Science Keith Vertanen.
Stacks and queues http://www.flickr.com/photos/mac-ash/4534203626/ http://www.flickr.com/photos/thowi/182298390/ CSCI 135: Fundamentals of Computer Science Keith Vertanen Terminology Overview Abstract
Arrays and Linked Lists
Arrays and Linked Lists Abstract Data Types Stacks Queues Priority Queues and Deques John Edgar 2 And Stacks Reverse Polish Notation (RPN) Also known as postfix notation A mathematical notation Where every
CS.15.A.SymbolTables.API. Alice
15.Symbol Tables APIs and clients A design challenge Binary search trees Implementation Analysis 15. Symbol Tables Section 4.4 http://introcs.cs.princeton.edu CS.15.A.SymbolTables.API FAQs about sorting
CPSC 221: Algorithms and Data Structures Lecture #1: Stacks and Queues
CPSC 221: Algorithms and Data Structures Lecture #1: Stacks and Queues Alan J. Hu (Slides borrowed from Steve Wolfman) Be sure to check course webpage! http://www.ugrad.cs.ubc.ca/~cs221 1 Lab 1 is available.
CSC 222: Computer Programming II. Spring 2005
CSC 222: Computer Programming II Spring 2005 Stacks and recursion stack ADT push, pop, peek, empty, size ArrayList-based implementation, java.util.stack application: parenthesis/delimiter matching postfix
Stacks. Chapter 5. Copyright 2012 by Pearson Education, Inc. All rights reserved
Stacks Chapter 5 Copyright 2012 by Pearson Education, Inc. All rights reserved Contents Specifications of the ADT Stack Using a Stack to Process Algebraic Expressions A Problem Solved: Checking for Balanced
Stacks (5.1) Abstract Data Types (ADTs) CSE 2011 Winter 2011
Stacks (5.1) CSE 2011 Winter 2011 26 January 2011 1 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: Data stored Operations on the data Error
An Introduction to Data Structures
An Introduction to Data Structures Advanced Programming ICOM 4015 Lecture 17 Reading: Java Concepts Chapter 20 Fall 2006 Adapded from Java Concepts Companion Slides 1 Chapter Goals To learn how to use
The Bucharest University of Economic Studies. Data Structures. ADTs-Abstract Data Types Stacks and Queues
The Bucharest University of Economic Studies Data Structures ADTs-Abstract Data Types Stacks and Queues Agenda Definition Graphical representation Internal interpretation Characteristics Operations Implementations
CS 106B Lecture 5: Stacks and Queues
CS 106B Lecture 5: Stacks and Queues Monday, July 3, 2017 Programming Abstractions Summer 2017 Stanford University Computer Science Department Lecturer: Chris Gregg reading: Programming Abstractions in
COMPUTER SCIENCE. Computer Science. 13. Symbol Tables. Computer Science. An Interdisciplinary Approach. Section 4.4.
COMPUTER SCIENCE S E D G E W I C K / W A Y N E PA R T I I : A L G O R I T H M S, T H E O R Y, A N D M A C H I N E S Computer Science Computer Science An Interdisciplinary Approach Section 4.4 ROBERT SEDGEWICK
Programming Abstractions
Programming Abstractions C S 1 0 6 B Cynthia Lee Today s Topics ADTs Stack Example: Reverse-Polish Notation calculator Queue Example: Mouse Events Stacks New ADT: Stack stack.h template
3.3: Encapsulation and ADTs
Abstract Data Types 3.3: Encapsulation and ADTs Data type: set of values and operations on those values. Ex: int, String, Complex, Card, Deck, Wave, Tour,. Abstract data type. Data type whose representation
1.00 Lecture 26. Data Structures: Introduction Stacks. Reading for next time: Big Java: Data Structures
1.00 Lecture 26 Data Structures: Introduction Stacks Reading for next time: Big Java: 19.1-19.3 Data Structures Set of primitives used in algorithms, simulations, operating systems, applications to: Store
Revision Statement while return growth rate asymptotic notation complexity Compare algorithms Linear search Binary search Preconditions: sorted,
[1] Big-O Analysis AVERAGE(n) 1. sum 0 2. i 0. while i < n 4. number input_number(). sum sum + number 6. i i + 1 7. mean sum / n 8. return mean Revision Statement no. of times executed 1 1 2 1 n+1 4 n
infix expressions (review)
Outline infix, prefix, and postfix expressions queues queue interface queue applications queue implementation: array queue queue implementation: linked queue application of queues and stacks: data structure
Stack ADT. ! push(x) puts the element x on top of the stack! pop removes the topmost element from the stack.
STACK Stack ADT 2 A stack is an abstract data type based on the list data model All operations are performed at one end of the list called the top of the stack (TOS) LIFO (for last-in first-out) list is
CPSC 221: Algorithms and Data Structures ADTs, Stacks, and Queues
CPSC 221: Algorithms and Data Structures ADTs, Stacks, and Queues Alan J. Hu (Slides borrowed from Steve Wolfman) Be sure to check course webpage! http://www.ugrad.cs.ubc.ca/~cs221 1 Lab 1 available very
Lists, Stacks, and Queues. (Lists, Stacks, and Queues ) Data Structures and Programming Spring / 50
Lists, Stacks, and Queues (Lists, Stacks, and Queues ) Data Structures and Programming Spring 2016 1 / 50 Abstract Data Types (ADT) Data type a set of objects + a set of operations Example: integer set
Information Science 2
Information Science 2 - Basic Data Structures- Week 02 College of Information Science and Engineering Ritsumeikan University Today s class outline l Basic data structures: Definitions and implementation
Programming Abstractions
Programming Abstractions C S 1 0 6 B Cynthia Lee Today s Topics HW Tips QT Creator dos & don ts ADTs Stack Example: Reverse-Polish Notation calculator Queue Event queues QT Creator A F E W W A R N I N
Week 4 Stacks & Queues
CPSC 319 Week 4 Stacks & Queues Xiaoyang Liu xiaoyali@ucalgary.ca Stacks and Queues Fundamental data types. Value: collection of objects. Operations: insert, remove, iterate, test if empty. Intent is clear
Queues. CITS2200 Data Structures and Algorithms. Topic 5
CITS2200 Data Structures and Algorithms Topic 5 Queues Implementations of the Queue ADT Queue specification Queue interface Block (array) representations of queues Recursive (linked) representations of
First Semester - Question Bank Department of Computer Science Advanced Data Structures and Algorithms...
First Semester - Question Bank Department of Computer Science Advanced Data Structures and Algorithms.... Q1) What are some of the applications for the tree data structure? Q2) There are 8, 15, 13, and
12 Abstract Data Types
12 Abstract Data Types 12.1 Foundations of Computer Science Cengage Learning Objectives After studying this chapter, the student should be able to: Define the concept of an abstract data type (ADT). Define
COS 126 Exam 2 Review Part 1
COS 126 Exam 2 Review Part 1 Programming Exam 2 Part 1 (ADT) Q. Can you implement a simple abstract data type? Example (Fall 2016). Part 1. Implement a data type ColorHSB.java for HSB colors. This time,
UNIT 6A Organizing Data: Lists. Last Two Weeks
UNIT 6A Organizing Data: Lists 1 Last Two Weeks Algorithms: Searching and sorting Problem solving technique: Recursion Asymptotic worst case analysis using the big O notation 2 1 This Week Observe: The
1. Stack Implementation Using 1D Array
Lecture 5 Stacks 1 Lecture Content 1. Stack Implementation Using 1D Array 2. Stack Implementation Using Singly Linked List 3. Applications of Stack 3.1 Infix and Postfix Arithmetic Expressions 3.2 Evaluate
CS24 Week 4 Lecture 2
CS24 Week 4 Lecture 2 Kyle Dewey Overview Linked Lists Stacks Queues Linked Lists Linked Lists Idea: have each chunk (called a node) keep track of both a list element and another chunk Need to keep track
UNIT 3
UNIT 3 Presentation Outline Sequence control with expressions Conditional Statements, Loops Exception Handling Subprogram definition and activation Simple and Recursive Subprogram Subprogram Environment
UNIT 6A Organizing Data: Lists Principles of Computing, Carnegie Mellon University
UNIT 6A Organizing Data: Lists Carnegie Mellon University 1 Data Structure The organization of data is a very important issue for computation. A data structure is a way of storing data in a computer so
Problem with Scanning an Infix Expression
Operator Notation Consider the infix expression (X Y) + (W U), with parentheses added to make the evaluation order perfectly obvious. This is an arithmetic expression written in standard form, called infix
CS 206 Introduction to Computer Science II
CS 206 Introduction to Computer Science II 07 / 26 / 2016 Instructor: Michael Eckmann Today s Topics Comments/Questions? Stacks and Queues Applications of both Priority Queues Michael Eckmann - Skidmore
CS 206 Introduction to Computer Science II
CS 206 Introduction to Computer Science II 03 / 31 / 2017 Instructor: Michael Eckmann Today s Topics Questions? Comments? finish RadixSort implementation some applications of stack Priority Queues Michael
Programming Abstractions
Programming Abstractions C S 1 0 6 X Cynthia Lee Today s Topics ADTs Stack Example: Reverse-Polish Notation calculator Queue Example: Mouse Events Stacks New ADT: Stack stack.h template
Computer Science 210 Data Structures Siena College Fall Topic Notes: Linear Structures
Computer Science 210 Data Structures Siena College Fall 2017 Topic Notes: Linear Structures The structures we ve seen so far, Vectors/ArrayLists and linked lists, allow insertion and deletion of elements
Lecture Data Structure Stack
Lecture Data Structure Stack 1.A stack :-is an abstract Data Type (ADT), commonly used in most programming languages. It is named stack as it behaves like a real-world stack, for example a deck of cards
DATA STRUCUTRES. A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently.
DATA STRUCUTRES A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently. An algorithm, which is a finite sequence of instructions, each of which
CMSC 132, Object-Oriented Programming II Summer Lecture 9:
CMSC 132, Object-Oriented Programming II Summer 2018 Lecturer: Anwar Mamat Lecture 9: Disclaimer: These notes may be distributed outside this class only with the permission of the Instructor. 9.1 QUEUE
Insertions and removals follow the Fist-In First-Out rule: Insertions: at the rear of the queue Removals: at the front of the queue
Queues CSE 2011 Fall 2009 9/28/2009 7:56 AM 1 Queues: FIFO Insertions and removals follow the Fist-In First-Out rule: Insertions: at the rear of the queue Removals: at the front of the queue Applications,
Stack Abstract Data Type
Stacks Chapter 5 Chapter Objectives To learn about the stack data type and how to use its four methods: push, pop, peek, and empty To understand how Java implements a stack To learn how to implement a
#06 More Structures LIFO FIFO. Contents. Queue vs. Stack 3. Stack Operations. Pop. Push. Stack Queue Hash table
Contents #06 More Structures -07 FUNDAMENTAL PROGRAMMING I Stack Queue Hash table DEPARTMENT OF COMPUTER ENGINEERING, PSU v. Queue vs. Stack Stack Operations IN IN OUT Push: add an item to the top Pop:
List, Stack, and Queues
List, Stack, and Queues R. J. Renka Department of Computer Science & Engineering University of North Texas 02/24/2010 3.1 Abstract Data Type An Abstract Data Type (ADT) is a set of objects with a set of
3137 Data Structures and Algorithms in C++
3137 Data Structures and Algorithms in C++ Lecture 3 July 12 2006 Shlomo Hershkop 1 Announcements Homework 2 out tonight Please make sure you complete hw1 asap if you have issues, please contact me will
CSCI 136 Data Structures & Advanced Programming. Lecture 14 Fall 2018 Instructor: Bills
CSCI 136 Data Structures & Advanced Programming Lecture 14 Fall 2018 Instructor: Bills Announcements Mid-Term Review Session Monday (10/15), 7:00-8:00 pm in TPL 203 No prepared remarks, so bring questions!
Object Oriented Programming: In this course we began an introduction to programming from an object-oriented approach.
CMSC 131: Chapter 28 Final Review: What you learned this semester The Big Picture Object Oriented Programming: In this course we began an introduction to programming from an object-oriented approach. Java
Problem with Scanning an Infix Expression
Operator Notation Consider the infix expression (X Y) + (W U), with parentheses added to make the evaluation order perfectly obvious. This is an arithmetic expression written in standard form, called infix
CS6202 - PROGRAMMING & DATA STRUCTURES I Unit IV Part - A 1. Define Stack. A stack is an ordered list in which all insertions and deletions are made at one end, called the top. It is an abstract data type
15. Stacks and Queues
COMP1917 15s2 15. Stacks and Queues 1 COMP1917: Computing 1 15. Stacks and Queues Reading: Moffat, Section 10.1-10.2 Overview Stacks Queues Adding to the Tail of a List Efficiency Issues Queue Structure