get method added to redBlackTree

# Conflicts:
#	src/search/RedBlackTree.java
#	src/search/RedBlackTreeTest.java

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>()
+	}
 }

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

src/search/RedBlackTreeTest.java

+/**
+ * 
+ */
+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);
+	}
+
+}