slides created by Marty Stepp and Hélène Martin

Slides:



Advertisements
Similar presentations
CSE 143 Lecture 22: Advanced List Implementation (ADTs; interfaces; abstract classes; inner classes; generics; iterators)
Advertisements

Building Java Programs Chapter 16 Linked Lists. 2 A swap method? Does the following swap method work? Why or why not? public static void main(String[]
Building Java Programs Inner classes, generics, abstract classes reading: 9.6, 15.4,
CSE 143 Lecture 20 Binary Search Trees continued; Tree Sets read slides created by Marty Stepp and Hélène Martin
CSE 143 Lecture 10 Linked List Basics reading: slides created by Marty Stepp
CSE 143 Lecture 24 Advanced collection classes (ADTs; abstract classes; inner classes; generics; iterators) read 11.1, 9.6, , slides.
(c) University of Washington16-1 CSC 143 Java Linked Lists Reading: Ch. 20.
(c) University of Washington16-1 CSC 143 Java Lists via Links Reading: Ch. 23.
Building Java Programs Bonus Slides Hashing. 2 Recall: ADTs (11.1) abstract data type (ADT): A specification of a collection of data and the operations.
slides adapted from Marty Stepp and Hélène Martin
CSE 143 Lecture 3 Implementing ArrayIntList reading: slides created by Marty Stepp and Hélène Martin
Building Java Programs Chapter 16
CSE 143 Lecture 20 Binary Search Trees continued; Tree Sets
LinkedIntList(int n) Write a constructor for LinkedIntList that accepts an int n parameter and makes a list of the number from 0 to n new LinkedIntList(3)
Building Java Programs
Building Java Programs Chapter 16
Programming Abstractions
A tree set Our SearchTree class is essentially a set.
slides created by Marty Stepp
Wednesday Questions How do I debug? We love to teach this at IPL/OH!
Linked node problem 3 What set of statements turns this picture:
CSE 143 Lecture 9 References and Linked Nodes reading: 3.3; 16.1
LinkedIntList(int n) Write a constructor for LinkedIntList that accepts an int n parameter and makes a list of the number from 0 to n new LinkedIntList(3)
CSE 143 Lecture 9 References and Linked Nodes reading: 16.1
slides created by Marty Stepp and Ethan Apter
Building Java Programs
CSE 143 Lecture 6 Interfaces; Complexity (Big-Oh)
Building Java Programs
CSE 143 Lecture 27: Advanced List Implementation
Lecture 26: Advanced List Implementation
A tree set Our SearchTree class is essentially a set.
Building Java Programs
CSE 143 Lecture 6 References and Linked Nodes reading: 16.1
slides created by Marty Stepp and Hélène Martin
CSE 143 Lecture 2 Collections and ArrayIntList
Lecture 7: Linked List Basics reading: 16.2
More Linked Lists and Loops Based on slides by Ethan Apter
slides adapted from Marty Stepp and Hélène Martin
Programming Abstractions
changing a list There are only two ways to change a linked list:
Building Java Programs
slides adapted from Marty Stepp and Hélène Martin
slides created by Marty Stepp and Hélène Martin
Building Java Programs
Building Java Programs
Binary Search Trees continued; Tree Sets
slides created by Marty Stepp
CSE 143 Lecture 5 References and Linked Nodes
Lecture 8: Complex Linked List Code reading: 16.2 – 16.3
Building Java Programs Chapter 16
LinkedIntList(int n) Write a constructor for LinkedIntList that accepts an int n parameter and makes a list of the number from 0 to n new LinkedIntList(3)
CSE 373 Separate chaining; hash codes; hash maps
Building Java Programs
CSC 143 Java Linked Lists.
slides created by Marty Stepp
slides created by Marty Stepp
slides adapted from Marty Stepp
Building Java Programs
slides created by Marty Stepp
slides created by Marty Stepp and Hélène Martin
Lecture 7: Linked List Basics reading: 16.2
CSE 143 Lecture 7 References and Linked Nodes reading: 16.1
slides adapted from Marty Stepp
Wednesday Questions How do I debug? We love to teach this at IPL/OH!
slides created by Marty Stepp
Linked Lists and Loops based on slides by Ethan Apter
CSE 143 Lecture 21 Advanced List Implementation
slides created by Ethan Apter
slides created by Marty Stepp
slides created by Marty Stepp
Presentation transcript:

slides created by Marty Stepp and Hélène Martin CSE 143 Lecture 9 More Linked Lists reading: 16.2 - 16.3 slides created by Marty Stepp and Hélène Martin http://www.cs.washington.edu/143/

Implementing remove // Removes value at given index from list. // Precondition: 0 <= index < size public void remove(int index) { ... } How do we remove any node in general from a list? Does it matter what the list's contents are before the remove?

Removing from a list Before removing element at index 1: After: data next 42 data next -3 front = data next 20 element 0 element 1 element 2 data next 42 data next 20 front = element 0 element 1

Removing from the front Before removing element at index 0: After: data next 42 data next -3 front = data next 20 element 0 element 1 element 2 data next -3 data next 20 front = element 0 element 1

Removing the only element Before: After: We must change the front field to store null instead of a node. Do we need a special case to handle this? data next 20 front = front = element 0

remove solution // Removes value at given index from list. // Precondition: 0 <= index < size() public void remove(int index) { if (index == 0) { // special case: removing first element front = front.next; } else { // removing from elsewhere in the list ListNode current = front; for (int i = 0; i < index - 1; i++) { current = current.next; } current.next = current.next.next;

Exercise: addSorted Write a method addSorted that accepts an integer value as a parameter and adds that value to a sorted list in sorted order. Before addSorted(17) : After addSorted(17) : front = data next -4 data next 8 data next 22 element 0 element 1 element 2 front = data next -4 data next 8 data next 17 data next 22 element 0 element 1 element 2 element 3

The common case Adding to the middle of a list: addSorted(17) Which references must be changed? What sort of loop do we need? When should the loop stop? front = data next -4 data next 8 data next 22 element 0 element 1 element 2 you knew the answer right away, it goes between the 5 and 12 when you see the 5, do you know to stop yet? when do you know to stop? while (current.data < value) { current = current.next; } should it be < or <= ? when would it matter? what if the list had 500 10s? < is more efficient problem: we have gone too far. we want to insert the 10 in *front* of the node we are at. We want to stop 1 before the 12. (James Bond on train car) Key idea: insert BETWEEN 5 and 12. in order to change the link between the 5 and 12, we must be at the node with 5, so we can change its .next link.

First attempt An incorrect loop: What is wrong with this code? ListNode current = front; while (current.data < value) { current = current.next; } What is wrong with this code? The loop stops too late to affect the list in the right way. current front = data next -4 data next 8 data next 22 element 0 element 1 element 2

Key idea: peeking ahead Corrected version of the loop: ListNode current = front; while (current.next.data < value) { current = current.next; } This time the loop stops in the right place. current front = data next -4 data next 8 data next 22 element 0 element 1 element 2

Another case to handle Adding to the end of a list: addSorted(42) Exception in thread "main": java.lang.NullPointerException Why does our code crash? What can we change to fix this case? front = data next -4 data next 8 data next 22 element 0 element 1 element 2

Multiple loop tests A correction to our loop: ListNode current = front; while (current.next != null && current.next.data < value) { current = current.next; } We must check for a next of null before we check its .data. current front = data next -4 data next 8 data next 22 element 0 element 1 element 2

Third case to handle Adding to the front of a list: addSorted(-10) What will our code do in this case? What can we change to fix it? front = data next -4 data next 8 data next 22 element 0 element 1 element 2

Handling the front Another correction to our code: if (value <= front.data) { // insert at front of list front = new ListNode(value, front); } else { // insert in middle of list ListNode current = front; while (current.next != null && current.next.data < value) { current = current.next; } Does our code now handle every possible case?

Fourth case to handle Adding to (the front of) an empty list: addSorted(42) What will our code do in this case? What can we change to fix it? front =

Final version of code // Adds given value to list in sorted order. // Precondition: Existing elements are sorted public void addSorted(int value) { if (front == null || value <= front.data) { // insert at front of list front = new ListNode(value, front); } else { // insert in middle of list ListNode current = front; while (current.next != null && current.next.data < value) { current = current.next; }

Other list features Add the following methods to the LinkedIntList: size isEmpty clear toString indexOf contains Add a size field to the list to return its size more efficiently. Add preconditions and exception tests to appropriate methods.

Abstract data types abstract data type (ADT): A specification of a collection of data and the operations that can be performed on it. Describes what a collection does, not how it does it. Java's collection framework describes several ADTs: Collection, Deque, List, Map, Queue, Set An ADT can be implemented in multiple ways: ArrayList and LinkedList implement List HashSet and TreeSet implement Set LinkedList , ArrayDeque, etc. implement Queue Key idea: You can implement the same external behavior in many different ways internally. Each has its pros and cons.