Reconstructing broken files

Author: manny-pi

Java/Algorithms/src/searchAlgorithms/BinarySearch.java

@@ -1,30 +1,39 @@
 package searchAlgorithms;
 
 
-public class BinarySearch {
-    public static int binarySearch(Double[] data, Double value) { 
-        int low = 0;
-        int high = data.length - 1; 
-        int mid = (int) (low + high) / 2; 
-        
-        while (low <= high) { 
-            if (data[mid].equals(value)) {
-                return mid;
-            } else { 
-                if (data[mid].compareTo(value) > 0) { 
-                    high = mid - 1; 
-                    mid = (int) (low + high) / 2; 
-                } else if(data[mid].compareTo(value) < 0) { 
-                    low = mid + 1; 
-                    mid = (int) (low + high) / 2; 
-                }
-                return 0; 
-            }
-        }
-        return -1; 
-    }
-    
-    public static void main(String[] args) { 
-
-    }
+public class BinarySearch<T extends Comparable<? super T>> {
+	public int binarySearch(T[] data, T value) { 
+		int low = 0;
+		int high = data.length - 1; 
+		int mid = (int) (low + high) / 2; 
+
+		while (low <= high) { 
+			// Execute if MID = value 
+			if (data[mid].equals(value)) {
+				return mid;
+
+			// Execute if MID > value 
+			} else if (data[mid].compareTo(value) > 0) { 
+				high = mid - 1; 
+				mid = (int) (low + high) / 2; 
+
+			// Execute if MID < value 
+			} else if(data[mid].compareTo(value) < 0) { 
+				low = mid + 1; 
+				mid = (int) (low + high) / 2; 
+
+			}
+		}
+
+		return -1; 
+	}
+
+
+	/* Test algorithm */ 
+	public static void main(String[] args) { 
+		BinarySearch<Integer> bs = new BinarySearch<>(); 
+		Integer[] nums = new Integer[] {1, 2, 3, 4}; 
+
+		System.out.println(bs.binarySearch(nums, 3));
+	}
 }

Java/Algorithms/src/searchAlgorithms/LinearSearch.java

@@ -3,17 +3,19 @@
 import java.util.Random;
 import java.util.Arrays; 
 
-public class LinearSearch {
+public class LinearSearch<T> {
 
-    public static int linearSearch(Object[] data, Object value) { 
+    public int linearSearch(T[] data, Object value) { 
         for (int i = 0; i < data.length; i++) { 
             if (data[i].equals(value)) return i; 
         }
 
         return -1; 
     }
-
+    
+    /* Test algorithm */ 
     public static void main(String[] args) { 
+    	LinearSearch<Double> ls = new LinearSearch<>(); 
         Random random = new Random(); 
         Double[] data = new Double[10]; 
         for (int i = 0; i < 10; i++) { 
@@ -25,8 +27,8 @@ public static void main(String[] args) {
 
         System.out.println("Data: " + Arrays.toString(data)); 
 
-        System.out.printf("val1: %f -> result: %d\n", val1, linearSearch(data, val1)); 
-        System.out.printf("val2: %f -> result: %d\n", val2, linearSearch(data, val2)); 
+        System.out.printf("val1: %f -> result: %d\n", val1, ls.linearSearch(data, val1)); 
+        System.out.printf("val2: %f -> result: %d\n", val2, ls.linearSearch(data, val2)); 
 
     }
 }

Java/Data_Structures/src/lists/LinkedList.java

@@ -45,10 +45,22 @@ public void add(E data) {
 	}
 
 
-	public void remove() {
-		
+	public boolean remove(E data) {
+		if (head.data.equals(data)) { 
+			this.head = this.head.next; 
+		} else { 
+			Node<E> curr = this.head; 
+			while(curr != null) { 
+				if (curr.next.data.equals(data)) { 
+					curr.next = curr.next.next; 
+					
+					return true;
+				}
+			}
+		}
 
-	}
+		return false; 
+	}	
 
 
 	public E get(int index) { 

Java/Data_Structures/src/lists/Queue.java

@@ -20,66 +20,60 @@ public String toString() {
 
 			return data.toString(); 
 		}
+		
+		@Override
+		public boolean equals(Object b) { 
+			if (this == b) { 
+				return true; 
+			} 
+			
+			Node<T> B = null; 
+			if (b instanceof Node) { 
+				B = (Node<T>) b; 
+				
+			} else { 
+				return false; 
+			}
+			
+			if (this.data.equals(B.data)) { 
+				return true; 
+			}
+			
+			return false; 
+		}
 	}
 
-
 	private Node<E> head; 
+	private Node<E> tail; 
 	private int size; 
 
 	public Queue() { 
 		this.head = null; 
+		this.tail = null; 
 	}
 
-
-	public void addToHead(E data) { 
-		
+	/* Adds data to the end of the line */ 
+	public void add(E data) { 
+		this.addToEnd(data);
 	}
 
-	
-	public void addToTail(E data) { 
+	public E next() throws Exception {
 		if (this.head == null) { 
-			this.head = new Node<E>(data); 
-		} else { 
-			Node<E> curr = head; 
-			while(curr.next != null) { 
-				curr = curr.next;
-			}
-			curr.next = new Node<E>(data); 
-		}
-		this.size++; 
-	}
-	
-	
-	public void remove() {
+			throw new Exception("Queue is Empty"); 
+		} 
 
-		
-	}
-	
-	
-	public E get(int index) { 
-		E retval = null; 
-		if (index > this.size - 1 || index < 0) { 
-			throw new IllegalArgumentException("Index out of range"); 
-		}
-		int i = 0; 
-		for(E e: this) { 
-			if (i == index) {
-				retval = e; 
-				break; 
-			}
-			i++; 
-		}
+		E retval = this.head.data; 
+		this.head = this.head.next; 
+		this.size--; 
 
 		return retval; 
 	}
-
-
+	
 	public int size() { 
 
 		return this.size; 
 	}
 
-
 	public Iterator<E> iterator() {
 		return new Iterator<E>() {
 			Node<E> curr = Queue.this.head; 
@@ -100,7 +94,6 @@ public E next() {
 		};
 	}
 
-
 	@Override
 	public String toString() { 
 		Iterator<E> iter = this.iterator(); 
@@ -113,13 +106,44 @@ public String toString() {
 		return retval; 
 	}
 
-
+	
+	/* private methods */ 
+	private void addToEnd(E data) { 
+		if (this.head == null) { 
+			this.head = new Node<>(data); 
+			
+		} else if (this.tail == null) { 
+			this.tail = new Node<>(data); 
+			this.head.next = this.tail; 
+			
+		} else { 
+			Node<E> newTail = new Node<>(data); 
+			this.tail.next = newTail;
+			this.tail = newTail; 
+		}
+		this.size++; 
+	}
+	
+	
+	/* Test Queue */ 
 	public static void main(String[] args) { 
-		LinkedList<Integer> l = new LinkedList<>(); 
+		Queue<Integer> l = new Queue<>(); 
 		for(int i = 0; i < 10; i++) { 
 			Integer k = i; 
 			l.add(k); 
 		}
-		System.out.println(l);
+		
+		System.out.println("l = " + l);
+		System.out.println("Size = " + l.size()); 
+		
+		for(int i = 0; i < 5; i++) { 
+			try { 
+				System.out.println(l.next()); 
+			} catch(Exception e) { 
+				
+			}
+		}
+		System.out.println("l = " + l);
+		System.out.println("New size = " + l.size()); 
 	}
 }