From 35c796676a59f0715dd0626c8c55b19f31b2f06c Mon Sep 17 00:00:00 2001
From: Haley Glavina <HaleyGlavina@Haleys-MacBook-Pro.local>
Date: Mon, 2 Apr 2018 15:45:51 -0400
Subject: [PATCH] get method added to redBlackTree
# Conflicts:
# src/search/RedBlackTree.java
# src/search/RedBlackTreeTest.java
---
Proposals/.DS_Store | Bin 6148 -> 6148 bytes
src/search/BasicSearchResult.java | 14 ++++
src/search/RedBlackTree.java | 55 +++++++++++-
src/search/RedBlackTreeTest.java | 135 ++++++++++++++++++++++++++++++
4 files changed, 203 insertions(+), 1 deletion(-)
create mode 100644 src/search/RedBlackTreeTest.java
diff --git a/Proposals/.DS_Store b/Proposals/.DS_Store
index f15975d6621e185c2e729fc3672df259aa712fcf..aae2b4c4fc898d3636803e688ef2162efafed52e 100644
GIT binary patch
delta 53
zcmZoMXffE3$i&9M#lgkPH94IrS(by7gEL-0qPp79z)VNM(9oz>N1@u%5Xd&QFxvc_
HNmdj9HlPda
delta 53
zcmZoMXffE3$i&9U$-&9XIXRsvSr){M7m%o~Ha0fVQ7|$$s?|}bwlJ~KQ7|<y-Ta(M
GRulj?N(=M=
diff --git a/src/search/BasicSearchResult.java b/src/search/BasicSearchResult.java
index c325486..68ca06d 100644
--- a/src/search/BasicSearchResult.java
+++ b/src/search/BasicSearchResult.java
@@ -3,12 +3,14 @@ package search;
import java.util.ArrayList;
import data.Record;
+import sort.GeneralRange;
public class BasicSearchResult {
private ArrayList<Record> results;
private final double time;
private BST<Integer, Integer> histogram;
private Integer sum;
+ private
public BasicSearchResult(ArrayList<Record> results, double time) {
this.results = results;
@@ -41,4 +43,16 @@ public class BasicSearchResult {
}
return this.sum;
}
+
+ /**
+ *
+ * @param area
+ */
+ public Iterable<RecordCluster> cluster(double area){
+
+ }
+
+ private ArrayList<GeneralRange> ranges(double lat, double lon, double area){
+ ArrayList<GeneralRange>()
+ }
}
diff --git a/src/search/RedBlackTree.java b/src/search/RedBlackTree.java
index 8d5728e..45bfd91 100644
--- a/src/search/RedBlackTree.java
+++ b/src/search/RedBlackTree.java
@@ -16,9 +16,22 @@ public class RedBlackTree<Key, Value> {
Integer[][] x = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}, {9, 9}};
RedBlackTree<Integer, Integer[]> myTree = new RedBlackTree<Integer, Integer[]>(fld, b1);
- for(int i = 0; i < x.length; i++){
+
+ // Add first 5 nodes, expected get(6) result is null
+ for(int i = 0; i < 4; i++){
myTree.put(x[i]);
}
+ assert(myTree.get((Comparable<Integer>) 6) == null);
+
+ // Add remaining nodes, expected get(6) result is {6, 6}
+ for(int i = 5; i < x.length; i++){
+ //System.out.println(x[i][0]);
+ myTree.put(x[i]);
+ }
+
+ System.out.println("Root: " + myTree.root().key());
+ System.out.println("myTree.get(6).key(): " + (Integer) myTree.get((Comparable<Integer>) 6).key());
+
Node h = myTree.root();
System.out.println(h.key());
while (h.left() != null) {
@@ -26,6 +39,11 @@ public class RedBlackTree<Key, Value> {
h = h.left();
}
}
+<<<<<<< HEAD
+=======
+
+
+>>>>>>> 459508d... get method added to redBlackTree
/**
@@ -38,6 +56,41 @@ public class RedBlackTree<Key, Value> {
field = fld;
}
+ /**
+ * Wrapper method for retrieving the node that matches a desired key
+ * @param key Key pointing to the desired node
+ * @return A node containing who's key matches the input
+ */
+ public Node<Key, Value> get(Comparable<Key> key) {
+ return get(this.root, key);
+ }
+
+ /**
+ * Finds the node in a tree whose key matches a desired key (if the matching node exists)
+ * @param node Root of the subtree being searched
+ * @param key Desired key to be searched for in a tree
+ * @return The node containing the key, returns null if the key is not found
+ */
+ private Node<Key, Value> get(Node<Key, Value> node, Comparable<Key> key) {
+ if (node.key() == key)
+ return node;
+ // If key is greater than current node, look right
+ if (this.compare.compare(node.key(), key) < 0)
+ if (node.right() != null)
+ return get(node.right(), key);
+ else
+ return null;
+ // If key is smaller than current node, look left
+ else if (this.compare.compare(node.key(), key) > 0)
+ if (node.left() != null)
+ return get(node.left(), key);
+ else
+ return null;
+ // If node == null, key does not exist in the tree
+ return null;
+ }
+
+
/**
* Getter method for the root of a tree
* @return The root of a tree object
diff --git a/src/search/RedBlackTreeTest.java b/src/search/RedBlackTreeTest.java
new file mode 100644
index 0000000..f319f0b
--- /dev/null
+++ b/src/search/RedBlackTreeTest.java
@@ -0,0 +1,135 @@
+/**
+ *
+ */
+package search;
+
+import static org.junit.Assert.*;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * @author HaleyGlavina
+ *
+ */
+public class RedBlackTreeTest {
+
+ private GeneralCompare<Integer> b1;
+ private Field<Integer, Integer[]> fld;
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @Before
+ public void setUp() throws Exception {
+ b1 = (a1, a2) -> (Integer) a1 - (Integer) a2;
+ fld = (a1) -> (Integer) a1[0];
+ }
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @After
+ public void tearDown() throws Exception {
+ }
+
+ /**
+ * Test method for {@link search.RedBlackTree#root()}.
+ */
+ @Test
+ public void testRoot() {
+ Integer[][] x = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}, {9, 9}};
+ RedBlackTree<Integer, Integer[]> myTree = new RedBlackTree<Integer, Integer[]>(fld, b1);
+
+ // Add first 5 nodes, expected root is 2
+ for(int i = 0; i < 4; i++){
+ myTree.put(x[i]);
+ }
+ assert((Integer) myTree.root().key() == 2);
+
+ // Add remaining nodes, expected root is 4
+ for(int i = 5; i < x.length; i++){
+ myTree.put(x[i]);
+ }
+ assert((Integer) myTree.root().key() == 4);
+ }
+
+ /**
+ * Test method for {@link search.RedBlackTree#get(Node<Key, Value> node, Comparable<Key> key)}.
+ */
+ @Test
+ public void testGet() {
+ Integer[][] x = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}, {9, 9}};
+ RedBlackTree<Integer, Integer[]> myTree = new RedBlackTree<Integer, Integer[]>(fld, b1);
+
+ // Add first 5 nodes, expected get(6) result is null
+ for(int i = 0; i < 4; i++){
+ myTree.put(x[i]);
+ }
+ assert(myTree.get((Comparable<Integer>) 6) == null);
+
+ // Add remaining nodes, expected get(6) result is {6, 6}
+ for(int i = 5; i < x.length; i++){
+ myTree.put(x[i]);
+ }
+ assert(myTree.get(6).key() == (Comparable<Integer>) 6);
+
+ }
+
+ /**
+ * Test method for {@link search.RedBlackTree#put(java.lang.Object)}.
+ */
+ @Test
+ public void testPut() {
+ Integer[][] x = {{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}, {9, 9}};
+ RedBlackTree<Integer, Integer[]> myTree = new RedBlackTree<Integer, Integer[]>(fld, b1);
+ for(int i = 0; i < x.length; i++){
+ myTree.put(x[i]);
+ }
+ Node h = myTree.root();
+
+ // Check if right-most branch of tree matches what is expected
+ Integer[] expect = {4, 6, 7, 8, 9};
+ for (int i = 0 ; i < expect.length ; i++) {
+ assert(expect[i] == h.key());
+ h = h.right();
+ }
+ }
+
+ /**
+ * Test method for {@link search.RedBlackTree#rotateLeft(search.Node)}.
+ */
+ @Test
+ public void testRotateLeft() {
+ RedBlackTree<Integer, Integer[]> myTree = new RedBlackTree<Integer, Integer[]>(fld, b1);
+ Integer[][] x = {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
+ myTree.put(x[0]);
+ myTree.put(x[1]);
+ assert((Integer) myTree.root().key() == 1);
+
+ // Check if left rotation changes the root of the tree as expected
+ myTree.put(x[2]);
+ myTree.put(x[3]);
+ assert((Integer) myTree.root().key() == 2);
+
+ }
+
+ /**
+ * Test method for {@link search.RedBlackTree#rotateRight(search.Node)}.
+ */
+ @Test
+ public void testRotateRight() {
+ RedBlackTree<Integer, Integer[]> myTree = new RedBlackTree<Integer, Integer[]>(fld, b1);
+ Integer[][] x = {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
+ myTree.put(x[3]);
+ myTree.put(x[2]);
+ assert((Integer) myTree.root().key() == 4);
+
+ // Check if right rotation changes the root of the tree as expected
+ myTree.put(x[1]);
+ myTree.put(x[0]);
+ assert((Integer) myTree.root().key() == 3);
+ }
+
+}
--
GitLab