CS : Data Structures

Transcription

1 CS : Data Structures Michael Schatz Oct 3, 2016 Lecture 13: More Lists

2 Assignment 4: Due Sunday Oct 10pm Remember: javac Xlint:all & checkstyle *.java & JUnit Solutions should be independently written!

3 Part 1: Inheritence

4 Why Inheritance? Code Reuse Subclass gets to use all methods of the parent class for free Overriding Subclass can have more specific implementation than the parent class Design constraints Subclasses get all of the features of the parent, whether you like them or not! Saying B inherits from A is a very strong relationship: anytime that A could be used, B could be instead

5 Inheritance Types Single Inheritance Multilevel Inheritance Multiple Inheritance B isa A Square isa Rectangle C isa B, B isa A Square isa Rectangle Rectangle isa Shape => Square isa Shape C isa A, C isa B Mike isa CS Prof Mike isa Bio Prof

6 Inheritance versus Encapsulation B isa A Pokemon Trainer Position pos String name String team List<Pokemon> List<Eggs> Backpack pack Position Double lat Double long Double altitude Backpack Int capacity List<Items> items Square isa Rectangle Trainer hasa Position, Trainer hasa Backpack, etc Encapsulation is used to hide the values or state of a structured data object inside a class,

7 Part 2: Lists

8 List Queue insertfront insertback addme. = first; first = addme; last. = addme; addme. = null removefront removeback first = first.;???

9 removelast (Singly Linked List) Queue first null last??? front Oops, just made remove an O(n) operation How might you address this?

10 Deque with Doubly Linked List Deque first null last null Very similar to a singly linked list, except each node has a reference to both the and ious node in the list A little more overhead, but significantly increased flexibility: supports insertfront, insertback, removefront, removeback, insertbefore, removemiddle

11 Dequeue Interface public interface Dequeue<T> { boolean empty(); int length(); T front(); T back(); void insertfront(t t); void insertback(t t); void removefront(); void removeback(); public class MyDeque implements Dequeue<T> { private static class <T>{ T data <T> ; <T> ; private <T> front; private <T> back; T front() { return front.data; T back() { return back.data;... How would you implement a deque with a doubly linked list? How would you implement a general List<T> class?

12 List v1 public interface <T> { void setvalue(t t); T getvalue(); void setnext(<t> n); void setprev(<t> n); void getnext(<t> n); void getprev(<t> n); public interface List<T> { boolean empty(); int length(); Is this a good design? No! We expose that Lists use s for underlying storage. Worse, client programs may incorrectly edit the / references <T> front() throws EmptyException; <T> back() throws EmptyException; void insertfront(<t> t); void insertback(<t> t); void insertbefore(<t> t); void insertafter(<t> t); void removefront() throws EmptyException; void removeback() throws EmptyException; void remove(<t> t);

13 List v2 public class MyList<T> implements List<T> { private static class <T> { T data; <T> ; <T> ; boolean empty() {... int length() {... T front() throws EmptyException {... T back() throws EmptyException {... void insertfront(t t) {... void insertback(t t) {... void insertbefore(???) {... void insertafter(???) {... Some implementations will have public node classes with private / references. However they also have public setnext(), setprev() => poor encapsulation! void removefront() throws EmptyException {... void removeback() throws EmptyException {... void remove(???) {... Is this a good design? Better, the nested class encapsulates the storage medium, but restricts what methods can be implemented to very first/last elements

14 List v3 public class MyList<T> implements List<T> { private static class <T> { T data; <T> ; <T> ; boolean empty() {... int length() {... T front() throws EmptyException {... T back() throws EmptyException {... void insertfront(t t) {... void insertback(t t) {... void insertbefore(int idx) {... void insertafter(int idx) {... void removefront() throws EmptyException {... void removeback() throws EmptyException {... void remove(int idx) {... Is this a good design? Slightly better: More flexible, but now insertbefore and remove() are O(n) operations

15 public interface <T> { void setvalue(t t); T getvalue(); void setnext(<t> n); void setprev(<t> n); List v4 void getnext(<t> n); void getprev(<t> n); public interface List<T> { boolean empty(); int length(); <T> front(); <T> back(); void insertfront(<t> t); void insertback(<t> t); void removefront(); void removeback();

16 List v4 public interface <T> { void setvalue(t t); T getvalue(); void setnext(<t> n); void setprev(<t> n); public interface Position<T> { // empty on purpose public interface List<T> { // simplified interface int length(); void getnext(<t> n); void getprev(<t> n); Position<T> insertfront(t t); Position<T> insertback(t t); void insertbefore(position<t> t); void insertafter(position<t> t); public interface List<T> { boolean empty(); int length(); <T> front(); <T> back(); void insertfront(<t> t); void insertback(<t> t); void removeat(position<t> p); void removefront(); void removeback();

17 List v4 public interface <T> { I am void a position setvalue(t and while t); you can T hold getvalue(); on to me, you can t do anything else with me! void setnext(<t> n); void setprev(<t> n); public interface Position<T> { // empty on purpose public interface List<T> { // simplified interface int length(); void getnext(<t> n); void getprev(<t> n); Inserting at front or back creates the Position objects. public interface List<T> { If you boolean want, empty(); you could keep references int length(); to the Position objects even in the middle of <T> front(); <T> the back(); list Pass void in a insertfront(<t> Position, and it will t); void remove insertback(<t> it from the list t); Position<T> insertfront(t t); Position<T> insertback(t t); void insertbefore(position<t> t); void insertafter(position<t> t); void removeat(position<t> p); void removefront(); void removeback();

18 List v4 public class List<T> implements List<T> private static class <T> implements Position<T> { <T> ; <T> ; T data; List<T> color; // avoid fake positions private <T> front; private <T> back; private int elements; public int length() { return this.elements; public Position<T> insertfront(t t) {... public Position<T> insertback(t t) {... public void remoteat(position<t> p) {... Public Position interface, but nested (private static) Implementation

19 List v4 List l = new List<String>(); Position a = l.insertfront( Mike ); Position b = l.insertback( Peter ); Position c = l.insertfront( Kelly ); l.removeat(a); public interface Position<T> { // empty on purpose public interface List<T> { // simplified interface int length(); Position<T> insertfront(t t); Position<T> insertback(t t); // TODO: void is temporary void removeat(position<t> p); a b c List front Kelly Mike Peter null back null

20 List v4 public String tostring () { String s ="["; <T> n = this.front; while (n!= null) { s += n.data.tostring(); if (n.!= null) { s +=""; n = n.; s +="]"; return s; public static void main(string[] args) { List l = new List(); Position a = l.insertfront("mike"); System.out.println(l); Position b = l.insertback("peter"); System.out.println(l); Position c = l.insertfront("kelly"); System.out.println(l); l.remove(a); System.out.println(l); $ java List [Mike] [Mike, Peter] [Kelly, Mike, Peter] [Kelly, Peter]

21 How to test the code? public class List<T> implements List<T> { private static final class <T> implements Position<T> { <T> ; <T> ; T data; List<T> owner; public T get() { return this.data; public void put(t t) { this.data = t;... public Position<T> front() throws EmptyException { public Position<T> back() throws EmptyException { public Position<T> insertfront(t t) { public Position<T> insertback(t t) { public void removefront() throws EmptyException { public void removeback() throws EmptyException { public Position<T> insertbefore(position<t> p, T t) throws PositionException { public Position<T> insertafter(position<t> p, T t) throws PositionException { public void remove(position<t> p) throws PositionException { public String tostring() {

22 How to test the code? public class List<T> implements List<T> { private static final class <T> implements Position<T> { <T> ; <T> ; T data; The output for every method should be tested, including List<T> owner; any exceptions for invalid inputs public T get() { return this.data; public void put(t t) { this.data = t; Use tostring() method to test the state of private member... variables public Position<T> front() throws EmptyException { public Position<T> back() throws EmptyException { public Position<T> insertfront(t t) { public Position<T> insertback(t t) { public void removefront() throws EmptyException { public void removeback() throws EmptyException { public Position<T> insertbefore(position<t> p, T t) throws PositionException { public Position<T> insertafter(position<t> p, T t) throws PositionException { public void remove(position<t> p) throws PositionException { public String tostring() {

23 TestList.java public void testremoveatfakeposition () { List <String> faker = new List<String>(); Position <String> fake = faker.insertfront("hehehe"); list.insertback("paul"); list.insertback ("Mary"); assertequals("[paul, Mary]", list.tostring ()); assertequals(2, list.length()); list.removeat(fake); Testing code is significantly longer than the implementation J

24 Part 3: Make Lists Useful Again J

25 List v4 List l = new List<String>(); Position a = l.insertfront( Mike ); Position b = l.insertback( Peter ); Position c = l.insertfront( Kelly ); l.removeat(a); public interface Position<T> { // empty on purpose public interface List<T> { // simplified interface int length(); Position<T> insertfront(t t); Position<T> insertback(t t); // TODO: void is temporary void removeat(position<t> p); a b c List front Kelly Mike Peter null back null

26 List v4 List l = new List<String>(); Position a = l.insertfront( Mike ); Position b = l.insertback( Peter ); Position c = l.insertfront( Kelly ); l.removeat(a); public interface Position<T> { // empty on purpose public interface List<T> { // simplified interface int length(); Position<T> insertfront(t t); Position<T> insertback(t t); // TODO: void is temporary void removeat(position<t> p); b a c List front Kelly Mike This interface protects the integrity of the List, but is weird in that we can have references to objects but cant get their value or do anything else with them except remove Peter them null back null

27 List v5 public interface Position<T> { T get(); void put(t t); public interface List<T> { private static class <T> implements Position<T> { <T> ; <T> ; T data; List<T> color; public T get() { return this.data; public void put(t t) { this.data = t;...

28 List v5 public interface Position<T> { T get(); void put(t t); Hooray, now we can get/set the value from a Position public interface List<T> { private static class <T> implements Position<T> { <T> ; <T> ; T data; List<T> color; public T get() { return this.data; public void put(t t) { this.data = t;... Why wouldn t you want to do it this way? What if you wanted a UniqueList<T> that only stored unique items? This would have to be checked in the UniqueList<T> implementation

29 List v5 public void testpositionget() { Position<String> p1 = list.insertback("peter"); Position<String> p2 = list.insertback("paul"); assertequals("[peter Paul]", list.tostring()); assertequals("peter", p1.get()); assertequals("paul", public void testpositionput() { Position<String> p1 = list.insertback("peter"); list.insertback("paul"); assertequals("[peter Paul]", list.tostring()); p1.put("mary"); assertequals("mary", p1.get()); assertequals("[mary Paul]", list.tostring()); What else are we missing?

30 List v6 public interface List<T> {... Position<T> front() throws EmptyListException; Position<T> back() throws EmptyListException; Position<T> (Position<T> p) throws InvalidPositionException; Position<T> ious(position<t> p) throws InvalidPositionException; boolean hasnext(position<t> p) throws InvalidPositionException; boolean hasprevious(position<t> p) throws InvalidPositionException; Why do we put () and () into the list and not Position? boolean valid(position<t> p); For more complex data structures, like trees or graphs, () and () will be more complicated

31 List v6 Iterating // Very C++ like Position<String> current = list.front(); Position<String> last = list.back(); while (current!= last) { // do whatever we need to do at the current position current = list.(current); // More Java-like Position<String> current = list.front(); for (;;) { // do whatever we need to do at the current position if (list.hasnext(current)) { current = list.(current); else { break; // Very Java-like Position<String> current = list.front(); while (list.valid(current)) { // do whatever we need to do at the current position current = list.(current);

32 Iterator Interface public interface Iterator<T> { boolean valid(); void (); // element, not necessarily T get(); // get ok, but put may break invariants public interface List<T> {... Iterator<T> forwarditerator(); Iterator<T> backwarditerator();... Iterator<String> i = list.forwarditerator(); while (i.valid()) { String e = i.get(); // do whatever with the element e i.();

33 Iterator Interface private static class ListIterator<T> implements Iterator<T> { private <T> current; private boolean forward; ListIterator(<T> start, boolean forward) { this.current = start; Ternary operator: this.forward = forward; If (this.forward) { public boolean valid() { this.current = this.current.; return this.current!= else null; { this.current = this.current.; public void () { this.current = this.forward? this.current. : this.current.; public T get() { return this.current.get();

34 Iterator Interface public Iterator<T> forwarditerator() { return new ListIterator<T>(this.front, true); public Iterator<T> backwarditerator() { return new ListIterator<T>(this.back, public void testforwarditerator() { list.insertback("peter"); list.insertback("paul"); list.insertback("mary"); String[] expected = {"Peter", "Paul", "Mary"; int current = 0; Iterator<String> i = list.forwarditerator(); while (i.valid()) { String e = i.get(); assertequals(expected[current], e); i.(); current += 1; assertequals(3, current);

35 Iterator Interface public Iterator<T> forwarditerator() { return new ListIterator<T>(this.front, true); public Iterator<T> backwarditerator() { return new ListIterator<T>(this.back, public void testbackwarditerator() { list.insertback("peter"); list.insertback("paul"); list.insertback("mary"); String[] expected = {"Mary", "Paul", "Peter"; int current = 0; Iterator<String> i = list.backwarditerator(); while (i.valid()) { String e = i.get(); assertequals(expected[current], e); i.(); current += 1; assertequals(3, current);

36 Java Iterators

37 Java Iterators Will become even more important for more complex data structures to simplify certain operations like printing every element in sorted order

38 Java Iterable

39 List v7 public interface List<T> extends Iterable<T> {... private static class ListIterator<T> implements Iterator<T> {... Iterator<String> i = list.iterator(); while (i.hasnext()) { String e = i.(); // do something with element e for (String e: list) { // do something with element e

40 Living in a null world List List front null front Mike null back back null List front Mike Peter null back null

41 Living in a null world public Position <T> insertback(t t) {... if (this.back List!= null) { List this.back. = n; public Position <T> insertfront(t t ) {... if (this.front == null) { Mike null if (this.front!= null) { this.front front = n; null this.front. =n;... if (this.back==null) { this.back null = n; back back... List public void removeat(position<t> p) { Mike Peter null... if (n. front!= null) { n.. = n.; if (n.!= null) { n.. = n.;... null back

42 Doubly Linked List with Sentinels List first f b null last null

43 Doubly Linked List with Sentinels List first f 1 b null last null

44 Doubly Linked List with Sentinels List first f 1 2 b null last null For the cost of a tiny bit of extra memory, the code gets significantly simpler!

45 Part 4: Midterm Review!

46 Next Steps 1. Reflect on the magic and power of stacks, queues, deques! 2. Work on Assignment 4: Due Sunday 3 Oct 10:00 pm 3. Start to review for Midterm on Monday Oct Your notes from class 2. Lecture Notes on Piazza 3. Slides on course webpage 4. Online & printed textbooks 5. Sample Midterm!!!

47 Welcome to CS Questions?