added head and BST

Author: prakashn27

Binary-Search-Tree/Java/BinarySearchTree.java

@@ -0,0 +1,61 @@
+public class BinarySearchTree<T extends Comparable<T>> {
+	T value;
+	BinarySearchTree<T> left;
+	BinarySearchTree<T> right;
+	public BinarySearchTree(T v) {
+		value = v;
+		left = null;
+		right = null;
+	}
+	
+	/*
+	 * insert into binary search Tree
+	 * @params: datatype T which has to be inserted
+	 * @returns: void 
+	 */
+	public void insert(T data) {
+		if(value == data) {
+			return;
+		}
+		if(data.compareTo(value) < 0) {
+			// left side tree
+			if(left == null) {
+				//create a new Tree
+				left = new BinarySearchTree<T>(data);
+			} else {
+				left.insert(data);
+			}
+		} else {
+			if(right == null) {
+				///create a new Tree
+				right = new BinarySearchTree<T>(data);
+			} else {
+				right.insert(data);
+			}
+		}
+	}
+	
+	/*
+	 * Delete the data
+	 * @params: data T which needs to be deleted
+	 * @return: Boolean if element is found and deleted
+	 */
+	public Boolean delete(T data) {
+		
+		return null;
+		
+	}
+	
+	public static void main(String[] args) {
+		BinarySearchTree<Integer> bst = new BinarySearchTree<Integer>(5);
+		bst.insert(3);
+		bst.insert(7);
+		assert(bst.left.value == 3);
+		assert(bst.right.value == 7);
+		System.out.println("Success..");
+		assert(true);
+	}
+
+}
+
+

Heap/Java/MaxHeap.java

@@ -0,0 +1,91 @@
+package heap;
+
+public class MaxHeap {
+	int[] arr;
+	int N;
+
+	public MaxHeap(int capacity) {
+		arr = new int[capacity + 1];
+		N = 0;
+	}
+	
+	public void insert(int value) {
+		arr[++N] = value;
+		swim(N);
+	}
+	
+	public int deleteMax() {
+		swap(N, 1, arr);
+		
+		int max = arr[N];
+		arr[N] = 0;
+		N--;
+		sink(1);
+		return max;
+	}
+	
+	public boolean isEmpty() {
+		return N == 0;
+	}
+	
+	private int max(int a, int b) {
+		return (a>b) ?a : b;
+	}
+	
+	/*
+	 * swim max to top
+	 */
+	private void swim(int index) {
+		while(arr[index] > arr[index/2] && index != 0 && index/2 != 0) {
+			swap(index, index/2, arr);
+			index = index/2;
+		}
+	}
+	
+	/*
+	 * Sink the element from top to bottom
+	 */
+	private void sink(int index) {
+		while(index < N) {
+			int childIndex = 2 * index;
+			int maxChildIndex = (arr[childIndex] > arr[childIndex + 1])?childIndex :(childIndex + 1);
+			if(arr[index] > arr[maxChildIndex]) {
+				break;
+			}
+			//System.out.println("max child index :" + maxChildIndex);
+			swap(index, maxChildIndex, arr);
+			index = maxChildIndex;
+		}
+	}
+	
+	/*
+	 * swaps entries between two index in arr
+	 */
+	private void swap(int index1, int index2, int[] arr) {
+		int temp = arr[index1];
+		arr[index1] = arr[index2];
+		arr[index2] = temp;
+	}
+	
+	/*
+	 * diplays elements of queue
+	 */
+	public void display() {
+		for(int i = 1; i <= N; i++) {
+			System.out.print(arr[i] + " ");
+		}
+		System.out.println();
+	}
+	
+	public static void main(String[] args) {
+		MaxHeap h = new MaxHeap(20);
+		int[] arr = {1, 23, 12, 9, 30, 2, 50}; 
+		for(int i = 0; i < arr.length; i++) {
+			h.insert(arr[i]);
+		}
+		System.out.println("first highest element is " + h.deleteMax());
+		System.out.println("second highest element is " + h.deleteMax());
+		System.out.println("third highest element is " + h.deleteMax());
+	}
+
+}

Heap/Java/MinHeap.java

@@ -0,0 +1,102 @@
+package heap;
+
+public class MinHeap {
+	int[] arr;
+	int N;
+
+	public MinHeap(int capacity) {
+		arr = new int[capacity + 1];
+		N = 0;
+	}
+	
+	public void insert(int value) {
+		arr[++N] = value;
+		swim(N);
+	}
+	
+	public int deleteMin() {
+		swap(N, 1, arr);
+		int max = arr[N];
+		arr[N] = Integer.MAX_VALUE;
+		N--;
+		sink(1);
+		return max;
+	}
+	
+	public boolean isEmpty() {
+		return N == 0;
+	}
+	
+	/*
+	 * swim max to top
+	 */
+	private void swim(int index) {
+		while(arr[index] < arr[index/2] && index != 0 && index/2 != 0) {
+			swap(index, index/2, arr);
+			index = index/2;
+		}
+	}
+	
+	/*
+	 * Sink the element from top to bottom
+	 */
+	private void sink(int index) {
+		while(index < N) {
+			int childIndex = 2 * index;
+			int minChildIndex = (arr[childIndex] < arr[childIndex + 1])?childIndex :(childIndex + 1);
+			if(arr[index] < arr[minChildIndex]) {
+				break;
+			}
+			//System.out.println("max child index :" + maxChildIndex);
+			swap(index, minChildIndex, arr);
+			index = minChildIndex;
+		}
+	}
+	
+	/*
+	 * swaps entries between two index in arr
+	 */
+	private void swap(int index1, int index2, int[] arr) {
+		int temp = arr[index1];
+		arr[index1] = arr[index2];
+		arr[index2] = temp;
+	}
+	
+	/*
+	 * diplays elements of queue
+	 */
+	public void display() {
+		for(int i = 1; i <= N; i++) {
+			System.out.print(arr[i] + " ");
+		}
+		System.out.println();
+	}
+	
+	public static void main(String[] args) {
+		MinHeap h = new MinHeap(20);
+		h.insert(5);
+		h.display();
+		h.insert(3);
+		h.display();
+		h.insert(2);
+		h.display();
+		h.insert(1);
+		h.display();
+		h.insert(10);
+		h.display();
+		System.out.println("first smallest element is " + h.deleteMin());
+		h.display();
+		System.out.println("second smallest element is " + h.deleteMin());
+		h.display();
+		System.out.println("third smallest element is " + h.deleteMin());
+		
+//		int[] arr = {1, 23, 12, 9, 30, 2, 50}; 
+//		for(int i = 0; i < arr.length; i++) {
+//			h.insert(arr[i]);
+//		}
+//		System.out.println("first smallest element is " + h.deleteMin());
+//		System.out.println("second smallest element is " + h.deleteMin());
+//		System.out.println("third smallest element is " + h.deleteMin());
+	}
+
+}