CSE 143 Lecture 17
description
Transcript of CSE 143 Lecture 17
![Page 1: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/1.jpg)
CSE 143Lecture 17
Binary Search Treesand
Comparable
slides created by Ethan Apterhttp://www.cs.washington.edu/143/
![Page 2: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/2.jpg)
2
Binary Search Tree (BST)
• Binary search tree: a binary tree on which you can perform binary search
• For every subtree in a binary search tree, the following property holds:
• Remember: this property holds for every subtree, not just for the overall root
x
values <= x values > x
This is sometimes called the “binary search tree property”
![Page 3: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/3.jpg)
3
Duplicate Values
• We must handle duplicates somehow
• We’re going to handle duplicates by putting them in the left subtree (as shown on the previous slide)
• But there are also other options:– we could choose to not allow duplicates in our tree– we could choose to put the duplicates in the right subtree
• It doesn’t really matter which one we choose, so long as we’re consistent
![Page 4: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/4.jpg)
4
BST of Names
• Let’s create a BST of names (Strings)
• How will we compare one name to another?
• One name is less than another when the former comes before the latter alphabetically– so “A” < “B”
• One name is greater than another when the former comes after the latter alphabetically– so “B” > “A”
![Page 5: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/5.jpg)
5
BST of Names
• Let’s start with an empty tree and add the following names in the given order:– Peter, Michael, Kim, Morgan, Baron, and Toby
Peter
![Page 6: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/6.jpg)
6
BST of Names
• Let’s start with an empty tree and add the following names in the given order:– Peter, Michael, Kim, Morgan, Baron, and Toby
Peter
Michael
![Page 7: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/7.jpg)
7
BST of Names
• Let’s start with an empty tree and add the following names in the given order:– Peter, Michael, Kim, Morgan, Baron, and Toby
Peter
Michael
Kim
![Page 8: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/8.jpg)
8
BST of Names
• Let’s start with an empty tree and add the following names in the given order:– Peter, Michael, Kim, Morgan, Baron, and Toby
Peter
Michael
Kim Morgan
![Page 9: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/9.jpg)
9
BST of Names
• Let’s start with an empty tree and add the following names in the given order:– Peter, Michael, Kim, Morgan, Baron, and Toby
Peter
Michael
Kim Morgan
Baron
![Page 10: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/10.jpg)
10
BST of Names
• Let’s start with an empty tree and add the following names in the given order:– Peter, Michael, Kim, Morgan, Baron, and Toby
Peter
Michael
Kim Morgan
Baron
Toby
![Page 11: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/11.jpg)
11
BST of Names
• What’s the in-order traversal of this tree?– Baron, Kim, Michael, Morgan, Peter, Toby– notice that this is also sorted order!
• Why does this happen?
• in-order traversal– left subtree, current node, right subtree
• in-order traversal in a BST– values <= current value, current value, values > current
valueleft subtree right subtree
current node
![Page 12: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/12.jpg)
12
add
• Let’s write an add method that will preserve the binary search tree property
public void add(int value) {
...
}
• Like most recursive tree methods, we’ll need a private helper method to keep track of our current node
• We also know to use “x = change(x)” because we’re modifying the tree
![Page 13: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/13.jpg)
13
add
• Here’s our updated add method
public void add(int value) {
overallRoot = add(overallRoot, value);
}
private IntTreeNode add(IntTreeNode root, int value) {
...
}
• Now we have to write the rest of the code
![Page 14: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/14.jpg)
14
add
• What’s the simplest tree we could add a node to?– the empty tree– this is our base case
• For the empty tree, we’ll just return a new node
• What about our recursive case(s)?– if the value to add is less than or equal to the value of the
current node•...add a new node to the left subtree
– if the value to add is greater than the value of the current node•...add a new node to the right subtree
![Page 15: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/15.jpg)
15
add
• Here’s our completed add method
public void add(int value) {
overallRoot = add(overallRoot, value);
}
private IntTreeNode add(IntTreeNode root, int value) {
if (root == null)
root = new IntTreeNode(value);
else if (value <= root.data)
root.left = add(root.left, value);
else
root.right = add(root.right, value);
return root;
}
![Page 16: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/16.jpg)
16
BST Wrap-up
• We’ve seen that BSTs can handle different kinds of objects– Strings are sorted alphabetically– ints are sorted by non-decreasing value
•Strings can be compared to other Strings
•ints can be compared to other ints
• So we could even define our own class to put in a BST, so long as we can compare different instances of this class– you’ll have to write a class like this on your final
![Page 17: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/17.jpg)
17
PerceivedTemperature
• Let’s write a simple class called PerceivedTemperature that keeps track of both the perceived temperature and actual temperature.
• Constructor code public class PerceivedTemperature {
private int pTemp;
private int aTemp;
public class PerceivedTemperature(int pt, int at) {
pTemp = pt;
aTemp = at;
}
}
![Page 18: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/18.jpg)
18
PerceivedTemperature
• Let’s also give it a few more simple methods
public int getPerceivedTemperature() {
return pTemp;
}
public int getActualTemperature() {
return aTemp;
}
public String toString() {
return pTemp + “ (“ + aTemp + “) “ + degrees;
}
• It’s still a simple class, but now it has some functionality
![Page 19: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/19.jpg)
19
Some Client Code
• Let’s also make some simple client code import java.util.*;
public class PerceivedTemperatureMain {
public static void main(String[] args) {
List<PerceivedTemperature> temps =
new ArrayList<PerceivedTemperature>();
temps.add(new PerceivedTemperature(104, 103));
temps.add(new PerceivedTemperature(104, 101));
temps.add(new PerceivedTemperature(88, 90));
System.out.println(temps);
}
}
• Which produces the following output: [104 (103) degrees, 104 (101) degrees, 88 (90) degrees]
![Page 20: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/20.jpg)
20
Some Client Code
• But what if we wanted to sort our list before printing?
• There’s a static method in the Java library called Collections.sort that takes a list as a parameter
• But if we add the following line to our client code: Collections.sort(temps);
• We get a compiler error– we haven’t told Java how to sort PerceivedTemperatures!
![Page 21: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/21.jpg)
21
Comparable<T>
• If we want our class to be compatible with tools like Arrays.sort and Collections.sort, we need to tell Java how our class is ordered
• Java provides the Comparable<T> interface: public interface Comparable<T> {
public int compareTo(T other);
}
•compareTo is not a method in Object because some things aren’t comparable– when is one Scanner greater than another Scanner?– when is one Map less than another Map?
![Page 22: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/22.jpg)
22
compareTo
• What does compareTo return?
• Java’s convention is:– if compareTo returns a negative number, it means “less”– if compareTo returns a zero, it means “equal”– if compareTo returns a positive number, it means
“greater”
• Some examples:– if x.compareTo(y) returns -7, then x < y– if x.compareTo(y) returns 0, then x == y– if x.compareTo(y) returns 37, then x > y
![Page 23: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/23.jpg)
23
compareTo
• For the PerceivedTemperature class, the single most important piece of data is the perceived temperature
• We’ll use this to write an attempt of compareTo: public int compareTo(PerceivedTemperature other) {
return pTemp - other.pTemp;
}
• Notice that the above version works correctly– e.g. if pTemp < other.pTemp, it returns a negative number
• But what if the perceived temperatures are equal?– in this case, let’s break ties by the actual temperatures
![Page 24: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/24.jpg)
24
compareTo
• Final version of compareTo:
public int compareTo(PerceivedTemperature other) {
if (pTemp == other.pTemp)
return aTemp - other.aTemp;
else
return pTemp - other.pTemp;
}
• Now if we try to compile our client code...
• ...we still get a compiler error! But why? We wrote a correct compareTo!– we forgot to implement the Comparable interface
![Page 25: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/25.jpg)
25
Implementing Comparable
• We need to have PerceivedTemperature implement the Comparable interface:
public class PerceivedTemperature implements
Comparable<PerceivedTemperature> {
...
}
• Remember: by implementing the interface we’re promising Java that we’ve written a compareTo method. Only after we make this promise will Java let us use Collections.sort
Notice we have to say what it is comparable to (namely, other PerceivedTemperature objects)
![Page 26: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/26.jpg)
26
Updated Client Code
• Here’s our updated our client code: import java.util.*;
public class PerceivedTemperatureMain {
public static void main(String[] args) {
List<PerceivedTemperature> temps =
new ArrayList<PerceivedTemperature>();
temps.add(new PerceivedTemperature(104, 103));
temps.add(new PerceivedTemperature(104, 101));
temps.add(new PerceivedTemperature(88, 90));
Collections.sort(temps);
System.out.println(temps);
}
}
• Which now produces the following output: [88 (90) degrees, 104 (101) degrees, 104 (103) degrees]
![Page 27: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/27.jpg)
27
compareTo and doubles
• Suppose PerceivedTemperature had stored its temperatures as doubles instead of as ints.
• How would this affect compareTo?– compareTo is supposed to return an int, but now our
subtraction operations return doubles
• An attempt at fixing compareTo by casting to ints public int compareTo(PerceivedTemperature other) {
if (pTemp == other.pTemp)
return (int)(aTemp - other.aTemp);
else
return (int)(pTemp - other.pTemp);
}
This doesn’t always work!
![Page 28: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/28.jpg)
28
compareTo and doubles
• Simple casting will return the wrong answer if the difference between the two temperatures is both non-zero and less than one– any difference strictly between -1.0 and 1.0 is converted
to 0
• We need to check if the difference between the temperatures is non-zero
• The easiest way to do this is with > and <– e.g. if (pTemp > other.pTemp)
![Page 29: CSE 143 Lecture 17](https://reader035.fdocuments.us/reader035/viewer/2022070405/56813e66550346895da87256/html5/thumbnails/29.jpg)
29
compareTo and doubles
• One solution (assuming temperatures are doubles): public int compareTo(PerceivedTemperature other) {
if (pTemp == other.pTemp)
return compareDoubles(aTemp, other.aTemp);
else
return compareDoubles(pTemp, other.pTemp);
}
private int compareDoubles(double d1, double d2) {
if (d1 < d2)
return -1;
else if (d1 > d2)
return 1;
else
return 0;
}