Added Classic Data Structure practice

Author: jimmy17x

bin/ClassicDataStructures/BTreeExercise.class

@@ -0,0 +1,27 @@
+package ClassicDataStructures;
+
+public class BTreeExercise {
+
+
+	public static void main(String[] args) {
+		BinarySearchTree bst = new BinarySearchTree();
+		bst.insert(8);
+		bst.insert(7);
+		bst.insert(13);
+		bst.insert(3);
+		bst.insert(10);
+		bst.insert(6);
+		bst.insert(4);
+		bst.insert(1);
+		bst.insert(14);
+		
+		//bst.inOrder();
+		bst.preOrder();
+		System.out.println();
+		System.out.println(bst.min());
+		System.out.println(bst.max());
+		
+		 
+	}
+
+}

bin/ClassicDataStructures/BinarySearchTree.class

@@ -0,0 +1,76 @@
+package ClassicDataStructures;
+
+public class BinarySearchTree {
+	public NodeBinaryTree root;
+
+	public BinarySearchTree() {
+		root = null;
+	}
+
+	public void insert(int data) {
+		NodeBinaryTree newNode = new NodeBinaryTree();
+		newNode.data = data;
+		if (root == null) {
+			root = newNode;
+		} else {
+			NodeBinaryTree current = root;
+			NodeBinaryTree parent;
+			while (true) {
+				parent = current;
+				if (data < current.data) {
+					current = current.left;
+					if (current == null) {
+						parent.left = newNode;
+						break;
+					}
+				} else {
+					current = current.right;
+					if (current == null){
+						parent.right = newNode;
+					break;
+					}
+				}
+			}
+		}
+
+	}
+
+	public int min()
+	{
+		NodeBinaryTree current = root;
+		while( current.left!= null )
+			current = current.left;
+		return current.getData();
+	}
+	public int max()
+	{
+		NodeBinaryTree current = root;
+		while( current.right!= null )
+			current = current.right;
+		return current.getData();
+	}
+	
+	public void inOrder() {
+		inOrder(root);
+	}
+
+	public void inOrder(NodeBinaryTree root) {
+		if (root != null) {
+			inOrder(root.left);
+			System.out.println(root.getData());
+			inOrder(root.right);
+		}
+	}
+
+	public void preOrder() {
+		preOrder(root);
+	}
+
+	public void preOrder(NodeBinaryTree root) {
+		if (root != null) {
+			System.out.println(root.getData());
+			preOrder(root.left);
+			preOrder(root.right);
+		}
+	}
+}

bin/ClassicDataStructures/ExerciseConvertDecimalToBinary.class

@@ -0,0 +1,30 @@
+package ClassicDataStructures;
+
+import java.util.Stack;
+
+public class ExerciseConvertDecimalToBinary {
+
+	static String binary(int number) {
+		final int base = 2;
+		Stack digits = new Stack();
+		do {
+			digits.push(number % 2);
+			number /= 2;
+		} while (number != 0);
+
+		String bits = "";
+
+		while (!digits.isEmpty()) {
+			bits += digits.pop();
+		}
+		return bits;
+
+	}
+
+	public static void main(String[] args) {
+		int num = 5 ; //101
+		System.out.println(num + " binary  is " + binary(num));
+
+	}
+
+}

bin/ClassicDataStructures/LinkedListNameQueue.class

@@ -0,0 +1,37 @@
+package ClassicDataStructures;
+
+import java.util.LinkedList;
+
+public class LinkedListNameQueue {
+	public static void main(String[] args) {
+		LinkedList<String> names = new LinkedList<String>();
+		names.addLast("Jimmy");
+		names.addLast("Jolly");
+		names.addLast("ozzy");
+		
+		for(String s : names)
+			System.out.println(s);
+		
+		System.out.println();
+		
+		names.removeFirst();
+		for(String s : names)
+			System.out.println(s);
+		
+		System.out.println();
+		names.addLast("aroma");
+		for(String s : names)
+			System.out.println(s);
+		
+		System.out.println("Size of queue :" + names.size());
+		
+		if(!names.isEmpty())
+			names.removeFirst();
+		
+		System.out.println("Size of queue :" + names.size());
+		for(String s : names)
+			System.out.println(s);
+		
+	}
+
+}

bin/ClassicDataStructures/NodeBinaryTree.class

@@ -0,0 +1,24 @@
+package ClassicDataStructures;
+
+public class NodeBinaryTree {
+	int data;
+	NodeBinaryTree left;
+	NodeBinaryTree right;
+
+	public NodeBinaryTree(int data) {
+		this.data = data;
+		left = null;
+		right = null;
+	}
+
+	public NodeBinaryTree() {
+		left = null;
+		right = null;
+	}
+	
+	public int getData()
+	{
+		return data;
+	}
+
+}

bin/ClassicDataStructures/RadixSort.class

@@ -0,0 +1,59 @@
+package ClassicDataStructures;
+
+import java.util.LinkedList;
+
+public class RadixSort {
+	public static void main(String[] args) {
+		final int size = 50;
+		final int numQueues = 10;
+		LinkedList<Integer>[] digits = new LinkedList[numQueues];
+		for (int i = 0; i < numQueues; ++i) {
+			digits[i] = new LinkedList();
+		}
+		int numbers[] = new int[50];
+		for (int i = 0; i < size; ++i) {
+			numbers[i] = (int) (Math.random() * 100);
+		}
+
+		display(numbers);
+		Distribute(numbers, digits, "ones");
+		Collect(digits, numbers);
+		display(numbers);
+
+		Distribute(numbers, digits, "tens");
+		Collect(digits, numbers);
+		display(numbers);
+
+	}
+
+	private static void Collect(LinkedList<Integer>[] digits, int[] numbers) {
+		int m = 0;
+		for (int i = 0; i < 10; ++i) {
+			while (!digits[i].isEmpty())
+				numbers[m++] = (Integer) digits[i].removeFirst();
+		}
+
+	}
+
+	private static void Distribute(int[] numbers, LinkedList<Integer>[] digits,
+			String digitType) {
+		for (int i = 0; i < numbers.length; ++i) {
+			if (digitType.equals("ones"))
+				digits[numbers[i] % 10].addLast(numbers[i]);
+			else
+				digits[numbers[i] / 10].addLast(numbers[i]);
+		}
+	}
+
+	private static void display(int[] numbers) {
+		int i = 0;
+		while (i < numbers.length) {
+			System.out.print(numbers[i] + "  ");
+			if (++i % 10 == 0)
+				System.out.println();
+		}
+		System.out.println();
+
+	}
+
+}

bin/ClassicDataStructures/StackExample.class

@@ -0,0 +1,39 @@
+package ClassicDataStructures;
+
+/*
+ * Stack is an abstract data structure
+ * It stores all elements of data type objects
+ * which is a little inefficient but highly flexible
+ */
+import java.util.Stack;
+
+public class StackExample {
+	public static void main(String[] args) {
+		Stack names = new Stack();
+		names.push("Jimmy");
+		names.push("Jolly");
+		
+		System.out.println("Top of stack is " + names.peek());
+		
+		names.pop();
+		System.out.println("Top of stack is " + names.peek());
+		
+	
+		names.push("ozzy");
+		System.out.println("Top of stack is " + names.peek());
+		
+		if(!names.empty()){
+			System.out.println("Top of stack is " + names.peek());
+			names.pop();
+		}
+		System.out.println("Top of stack is " + names.peek());
+		names.pop();
+		
+
+		if(!names.empty()){
+			System.out.println("Top of stack is " + names.peek());
+		}else
+			System.out.println("Stack empty");
+	}
+
+}

bin/sequentialCollection/AlphaTreeSet.class

@@ -9,6 +9,7 @@ public static void main(String args[]) {
 		names.add("marshal");
 		names.add("jolly");
 		names.add("jimmy");
+		names.add("aroma");
 
 		System.out.println("Number of names: " + names.size());
 

bin/sequentialCollection/NamesHashSet.class

@@ -8,6 +8,10 @@ public static void main (String args[])
 		HashSet<String> names = new HashSet<String>();
 		names.add("jimmy");
 		names.add("jolly");
+		names.add("marshal");
+		names.add("ozzy");
+		names.add("jimmy");
+		names.add("jolly");
 
 		System.out.println("The number of names is " + names.size());
 		for(String s : names)