Merge branch 'master' into ReadMeUpdate

Conversions/AnyBaseToAnyBase.java

@@ -0,0 +1,130 @@
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.InputMismatchException;
+import java.util.Scanner;
+
+/**
+ * Class for converting from "any" base to "any" other base, when "any" means from 2-36.
+ * Works by going from base 1 to decimal to base 2. Includes auxiliary method for 
+ * determining whether a number is valid for a given base.
+ * 
+ * @author Michael Rolland
+ * @version 2017.10.10
+ *
+ */
+public class AnyBaseToAnyBase {
+	
+	// Smallest and largest base you want to accept as valid input
+	static final int MINIMUM_BASE = 2;
+	static final int MAXIMUM_BASE = 36;
+	
+	// Driver
+	public static void main(String[] args) {
+		Scanner in = new Scanner(System.in);
+		String n;
+		int b1=0,b2=0;
+		while (true) {
+			try {
+				System.out.print("Enter number: ");
+				n = in.next();
+				System.out.print("Enter beginning base (between "+MINIMUM_BASE+" and "+MAXIMUM_BASE+"): ");
+				b1 = in.nextInt();
+				if (b1 > MAXIMUM_BASE || b1 < MINIMUM_BASE) {
+					System.out.println("Invalid base!");
+					continue;
+				}
+				if (!validForBase(n, b1)) {
+					System.out.println("The number is invalid for this base!");
+					continue;
+				}
+				System.out.print("Enter end base (between "+MINIMUM_BASE+" and "+MAXIMUM_BASE+"): ");
+				b2 = in.nextInt();
+				if (b2 > MAXIMUM_BASE || b2 < MINIMUM_BASE) {
+					System.out.println("Invalid base!");
+					continue;
+				}
+				break;
+			} catch (InputMismatchException e) {
+				System.out.println("Invalid input.");
+				in.next();
+			}
+		}
+		System.out.println(base2base(n, b1, b2));
+	}
+	
+	/**
+	 * Checks if a number (as a String) is valid for a given base.
+	 */
+	public static boolean validForBase(String n, int base) {
+		char[] validDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E',
+				'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+				'W', 'X', 'Y', 'Z'};
+		// digitsForBase contains all the valid digits for the base given
+		char[] digitsForBase = Arrays.copyOfRange(validDigits, 0, base);
+		
+		// Convert character array into set for convenience of contains() method
+		HashSet<Character> digitsList = new HashSet();
+		for (int i=0; i<digitsForBase.length; i++)
+			digitsList.add(digitsForBase[i]);
+		
+		// Check that every digit in n is within the list of valid digits for that base.
+		for (char c : n.toCharArray()) 
+			if (!digitsList.contains(c))
+				return false;
+		
+		return true;
+	}
+	
+	/**
+	 * Method to convert any integer from base b1 to base b2. Works by converting from b1 to decimal,
+	 * then decimal to b2.
+	 * @param n The integer to be converted.
+	 * @param b1 Beginning base.
+	 * @param b2 End base.
+	 * @return n in base b2.
+	 */
+	public static String base2base(String n, int b1, int b2) {
+		// Declare variables: decimal value of n, 
+		// character of base b1, character of base b2,
+		// and the string that will be returned.
+		int decimalValue = 0, charB2;
+		char charB1;
+		String output="";
+		// Go through every character of n
+		for (int i=0; i<n.length(); i++) {
+			// store the character in charB1
+			charB1 = n.charAt(i);
+			// if it is a non-number, convert it to a decimal value >9 and store it in charB2
+			if (charB1 >= 'A' && charB1 <= 'Z') 
+				charB2 = 10 + (charB1 - 'A');
+			// Else, store the integer value in charB2
+			else 
+				charB2 = charB1 - '0';
+			// Convert the digit to decimal and add it to the
+			// decimalValue of n
+			decimalValue = decimalValue * b1 + charB2;
+		}
+		
+		// Converting the decimal value to base b2:
+		// A number is converted from decimal to another base
+		// by continuously dividing by the base and recording 
+		// the remainder until the quotient is zero. The number in the
+		// new base is the remainders, with the last remainder
+		// being the left-most digit.
+		
+		// While the quotient is NOT zero:
+		while (decimalValue != 0) {
+			// If the remainder is a digit < 10, simply add it to
+			// the left side of the new number.
+			if (decimalValue % b2 < 10) 
+				output = Integer.toString(decimalValue % b2) + output;
+			// If the remainder is >= 10, add a character with the
+			// corresponding value to the new number. (A = 10, B = 11, C = 12, ...)
+			else
+				output = (char)((decimalValue % b2)+55) + output;
+			// Divide by the new base again
+			decimalValue /= b2;
+		}
+		return output;
+	}
+}

Dynamic Programming/Fibonacci.java

@@ -11,7 +11,7 @@ import java.util.Map;
 
 public class Fibonacci {
 
-    public static Map<Integer,Integer> map = new HashMap<Integer,Integer>();
+    private static Map<Integer,Integer> map = new HashMap<Integer,Integer>();
 
     public static void main(String[] args) throws Exception {
 
@@ -29,7 +29,7 @@ public class Fibonacci {
      * Outputs the nth fibonacci number
      **/
 
-    public static int fibMemo(int n) {
+    private static int fibMemo(int n) {
         if (map.containsKey(n)) {
             return map.get(n);
         }
@@ -54,7 +54,7 @@ public class Fibonacci {
      * Outputs the nth fibonacci number
      **/
 
-    public static int fibBotUp(int n) {
+    private static int fibBotUp(int n) {
 
         Map<Integer,Integer> fib = new HashMap<Integer,Integer>();
 

Dynamic Programming/Levenshtein_distance.java

@@ -7,7 +7,7 @@
  */
 
 public class Levenshtein_distance{
-	private int minimum(int a, int b, int c){
+	private static int minimum(int a, int b, int c){
 		if(a < b && a < c){
 			return a;
 		}else if(b < a && b < c){
@@ -16,7 +16,7 @@ public class Levenshtein_distance{
 			return c;
 		}
 	}
-	public int calculate_distance(String a, String b){
+	private static int calculate_distance(String a, String b){
 		len_a = a.length() + 1;
 		len_b = b.length() + 1;
 		int [][] distance_mat = new int[len_a][len_b];

Dynamic Programming/LongestCommonSubsequence.java

@@ -0,0 +1,66 @@
+class LongestCommonSubsequence {
+
+	public static String getLCS(String str1, String str2) {
+
+		//At least one string is null
+		if(str1 == null || str2 == null)
+			return null;
+
+		//At least one string is empty
+		if(str1.length() == 0 || str2.length() == 0)
+			return "";
+
+		String[] arr1 = str1.split("");
+		String[] arr2 = str2.split("");
+
+		//lcsMatrix[i][j]  = LCS of first i elements of arr1 and first j characters of arr2
+		int[][] lcsMatrix = new int[arr1.length + 1][arr2.length + 1];
+
+		for(int i = 0; i < arr1.length + 1; i++)
+			lcsMatrix[i][0] = 0;
+		for(int j = 1; j < arr2.length + 1; j++)
+			lcsMatrix[0][j] = 0;
+		for(int i = 1; i < arr1.length + 1; i++) {
+			for(int j = 1; j < arr2.length + 1; j++) {
+				if(arr1[i-1].equals(arr2[j-1])) {
+					lcsMatrix[i][j] = lcsMatrix[i-1][j-1] + 1;
+				} else {
+					lcsMatrix[i][j] = lcsMatrix[i-1][j] > lcsMatrix[i][j-1] ? lcsMatrix[i-1][j] : lcsMatrix[i][j-1];
+				}
+			}
+		}
+		return lcsString(str1, str2, lcsMatrix);
+	}
+
+	public static String lcsString (String str1, String str2, int[][] lcsMatrix) {
+		StringBuilder lcs = new StringBuilder();
+		int i = str1.length(),
+			j = str2.length();
+		while(i > 0  && j > 0) {
+			if(str1.charAt(i-1) == str2.charAt(j-1)) {
+				lcs.append(str1.charAt(i-1));
+				i--;
+				j--;
+			} else if(lcsMatrix[i-1][j] > lcsMatrix[i][j-1]) {
+				i--;
+			} else {
+				j--;
+			}
+		}
+		return lcs.reverse().toString();
+	}
+
+	public static void main(String[] args) {
+		String str1 = "DSGSHSRGSRHTRD";
+		String str2 = "DATRGAGTSHS";
+		String lcs = getLCS(str1, str2);
+		
+		//Print LCS
+		if(lcs != null) {
+			System.out.println("String 1: " + str1);
+			System.out.println("String 2: " + str2);
+			System.out.println("LCS: " + lcs);
+			System.out.println("LCS length: " + lcs.length());
+		}
+	}
+}

Dynamic Programming/LongestIncreasingSubsequence.java

@@ -31,7 +31,7 @@ public class LongestIncreasingSubsequence {
         return r;
     }
 
-    public static int LIS(int[] array) {
+    private static int LIS(int[] array) {
         int N = array.length;
         if (N == 0)
             return 0;

Others/FloydTriangle.java

@@ -1,7 +1,7 @@
 import java.util.Scanner;
 
 
-class FloydTriangle {
+public class FloydTriangle {
     public static void main(String[] args) {
           Scanner sc = new Scanner(System.in);
           System.out.println("Enter the number of rows which you want in your Floyd Triangle: ");

Others/LinearCongruentialGenerator.java

@@ -0,0 +1,57 @@
+/***
+ * A pseudorandom number generator.
+ * 
+ * @author Tobias Carryer
+ * Date: October 10, 2017
+ */
+public class LinearCongruentialGenerator {
+
+    private double a, c, m, previousValue;
+    
+    /***
+     * These parameters are saved and used when nextNumber() is called.
+     * The current timestamp in milliseconds is used as the seed.
+     * 
+     * @param multiplier
+     * @param increment
+     * @param modulo The maximum number that can be generated (exclusive). A common value is 2^32.
+     */
+    public LinearCongruentialGenerator( double multiplier, double increment, double modulo ) {
+        this(System.currentTimeMillis(), multiplier, increment, modulo);
+    }
+    
+    /***
+     * These parameters are saved and used when nextNumber() is called.
+     * 
+     * @param seed
+     * @param multiplier
+     * @param increment
+     * @param modulo The maximum number that can be generated (exclusive). A common value is 2^32.
+     */
+    public LinearCongruentialGenerator( double seed, double multiplier, double increment, double modulo ) {
+        this.previousValue = seed;
+        this.a = multiplier;
+        this.c = increment;
+        this.m = modulo;
+    }
+    
+    /**
+     * The smallest number that can be generated is zero.
+     * The largest number that can be generated is modulo-1. modulo is set in the constructor.
+     * @return a pseudorandom number.
+     */
+    public double nextNumber() {
+        previousValue = (a * previousValue + c) % m;
+        return previousValue;
+    }
+    
+    public static void main( String[] args ) {
+        // Show the LCG in action.
+        // Decisive proof that the LCG works could be made by adding each number
+        // generated to a Set while checking for duplicates.
+        LinearCongruentialGenerator lcg = new LinearCongruentialGenerator(1664525, 1013904223, Math.pow(2.0, 32.0));
+        for( int i = 0; i < 512; i++ ) {
+            System.out.println(lcg.nextNumber());
+        }
+    }
+}

Others/QueueUsingTwoStacks.java

@@ -0,0 +1,123 @@
+import java.util.Stack;
+
+/**
+ * This implements Queue using two Stacks.
+ *
+ * Big O Runtime:
+ *      insert(): O(1)
+ *      remove(): O(1) amortized
+ *      isEmpty(): O(1)
+ *
+ * A queue data structure functions the same as a real world queue.
+ * The elements that are added first are the first to be removed.
+ * New elements are added to the back/rear of the queue.
+ *
+ * @author sahilb2
+ *
+ */
+class QueueWithStack {
+
+    // Stack to keep track of elements inserted into the queue
+    private Stack inStack;
+    // Stack to keep track of elements to be removed next in queue
+    private Stack outStack;
+
+    /**
+	 * Constructor
+	 */
+    public QueueWithStack() {
+        this.inStack = new Stack();
+        this.outStack = new Stack();
+    }
+
+    /**
+     * Inserts an element at the rear of the queue
+     *
+     * @param x element to be added
+     */
+    public void insert(Object x) {
+        // Insert element into inStack
+        this.inStack.push(x);
+    }
+
+    /**
+     * Remove an element from the front of the queue
+     *
+     * @return the new front of the queue
+     */
+    public Object remove() {
+        if(this.outStack.isEmpty()) {
+            // Move all elements from inStack to outStack (preserving the order)
+            while(!this.inStack.isEmpty()) {
+                this.outStack.push( this.inStack.pop() );
+            }
+        }
+        return this.outStack.pop();
+    }
+
+    /**
+     * Returns true if the queue is empty
+     *
+     * @return true if the queue is empty
+     */
+    public boolean isEmpty() {
+        return (this.inStack.isEmpty() && this.outStack.isEmpty());
+    }
+
+}
+
+/**
+ * This class is the example for the Queue class
+ *
+ * @author sahilb2
+ *
+ */
+public class QueueUsingTwoStacks {
+
+    /**
+     * Main method
+     *
+     * @param args Command line arguments
+     */
+    public static void main(String args[]){
+        QueueWithStack myQueue = new QueueWithStack();
+        myQueue.insert(1);
+        // instack: [(top) 1]
+        // outStack: []
+        myQueue.insert(2);
+        // instack: [(top) 2, 1]
+        // outStack: []
+        myQueue.insert(3);
+        // instack: [(top) 3, 2, 1]
+        // outStack: []
+        myQueue.insert(4);
+        // instack: [(top) 4, 3, 2, 1]
+        // outStack: []
+
+        System.out.println(myQueue.isEmpty()); //Will print false
+
+        System.out.println(myQueue.remove()); //Will print 1
+        // instack: []
+        // outStack: [(top) 2, 3, 4]
+
+        myQueue.insert(5);
+        // instack: [(top) 5]
+        // outStack: [(top) 2, 3, 4]
+
+        myQueue.remove();
+        // instack: [(top) 5]
+        // outStack: [(top) 3, 4]
+        myQueue.remove();
+        // instack: [(top) 5]
+        // outStack: [(top) 4]
+        myQueue.remove();
+        // instack: [(top) 5]
+        // outStack: []
+        myQueue.remove();
+        // instack: []
+        // outStack: []
+
+        System.out.println(myQueue.isEmpty()); //Will print true
+
+    }
+}

Others/StackPostfixNotation.java

@@ -0,0 +1,38 @@
+import java.util.*;
+
+public class Postfix {
+    public static void main(String[] args) {
+         Scanner scanner = new Scanner(System.in);
+        String post = scanner.nextLine();   // Takes input with spaces in between eg. "1 21 +"
+        System.out.println(postfixEvaluate(post));
+    }
+
+    // Evaluates the given postfix expression string and returns the result.
+    public static int postfixEvaluate(String exp) {
+	 	Stack<Integer> s = new Stack<Integer> ();
+		Scanner tokens = new Scanner(exp);
+
+		while (tokens.hasNext()) {
+			if (tokens.hasNextInt()) {
+				s.push(tokens.nextInt()); // If int then push to stack
+			} else {    // else pop top two values and perform the operation
+				int num2 = s.pop();
+				int num1 = s.pop();
+				String op = tokens.next();
+
+				if (op.equals("+")) {
+					s.push(num1 + num2);
+				} else if (op.equals("-")) {
+					s.push(num1 - num2);
+				} else if (op.equals("*")) {
+					s.push(num1 * num2);
+				} else {
+					s.push(num1 / num2);
+				}
+
+			//  "+", "-", "*", "/"
+			}
+		}
+		return s.pop();
+    }
+}

README.md

@@ -47,7 +47,17 @@ __Properties__
 
 ###### View the algorithm in [action][merge-toptal]
 
+### Quick
+![alt text][quick-image]
 
+From [Wikipedia][quick-wiki]: Quicksort (sometimes called partition-exchange sort) is an efficient sorting algorithm, serving as a systematic method for placing the elements of an array in order.
+
+__Properties__
+* Worst case performance	O(n^2)
+* Best case performance	O(n log n) or O(n) with three-way partition
+* Average case performance	O(n^2)
+
+###### View the algorithm in [action][quick-toptal]
 
 ### Selection
 ![alt text][selection-image]
@@ -73,6 +83,48 @@ __Properties__
 
 ###### View the algorithm in [action][shell-toptal]
 
+### Time-Compexity Graphs
+
+Comparing the complexity of sorting algorithms (Bubble Sort, Insertion Sort, Selection Sort)
+
+[Complexity Graphs](https://github.com/prateekiiest/Python/blob/master/sorts/sortinggraphs.png)
+
+----------------------------------------------------------------------------------
+
+## Search Algorithms
+
+### Linear
+![alt text][linear-image]
+
+From [Wikipedia][linear-wiki]: linear search or sequential search is a method for finding a target value within a list. It sequentially checks each element of the list for the target value until a match is found or until all the elements have been searched.
+  Linear search runs in at worst linear time and makes at most n comparisons, where n is the length of the list.
+
+__Properties__
+* Worst case performance	O(n)
+* Best case performance	O(1)
+* Average case performance	O(n)
+* Worst case space complexity	O(1) iterative
+
+### Binary
+![alt text][binary-image]
+
+From [Wikipedia][binary-wiki]: Binary search, also known as half-interval search or logarithmic search, is a search algorithm that finds the position of a target value within a sorted array. It compares the target value to the middle element of the array; if they are unequal, the half in which the target cannot lie is eliminated and the search continues on the remaining half until it is successful.
+
+__Properties__
+* Worst case performance	O(log n)
+* Best case performance	O(1)
+* Average case performance	O(log n)
+* Worst case space complexity	O(1) 
+
+From [Wikipedia][shell-wiki]:  Shellsort is a generalization of insertion sort that allows the exchange of items that are far apart.  The idea is to arrange the list of elements so that, starting anywhere, considering every nth element gives a sorted list.  Such a list is said to be h-sorted.  Equivalently, it can be thought of as h interleaved lists, each individually sorted.
+
+__Properties__
+* Worst case performance O(nlog2 2n)
+* Best case performance O(n log n)
+* Average case performance depends on gap sequence
+
+###### View the algorithm in [action][shell-toptal]
+
 [bubble-toptal]: https://www.toptal.com/developers/sorting-algorithms/bubble-sort
 [bubble-wiki]: https://en.wikipedia.org/wiki/Bubble_sort
 [bubble-image]: https://upload.wikimedia.org/wikipedia/commons/thumb/8/83/Bubblesort-edited-color.svg/220px-Bubblesort-edited-color.svg.png "Bubble Sort"
@@ -104,4 +156,3 @@ __Properties__
 [binary-image]: https://upload.wikimedia.org/wikipedia/commons/f/f7/Binary_search_into_array.png
 
 
-[caesar]: https://upload.wikimedia.org/wikipedia/commons/4/4a/Caesar_cipher_left_shift_of_3.svg

Searches/TernarySearch.java

@@ -0,0 +1,74 @@
+import java.util.Scanner;
+
+public class TernarySearch{
+
+    /**
+     * @param arr The **Sorted** array in which we will search the element.
+     * @param value The value that we want to search for.
+     * @return The index of the element if found.
+     * Else returns -1.
+     */
+    public static int ternarySearch(int[] arr, int value){
+        return ternarySearch(arr, value, 0, arr.length - 1);
+    }
+
+    /**
+     * @param arr The **Sorted** array in which we will search the element.
+     * @param key The value that we want to search for.
+     * @param start The starting index from which we will start Searching.
+     * @param end The ending index till which we will Search.
+     * @return Returns the index of the Element if found.
+     * Else returns -1.
+     */
+    public static int ternarySearch(int[] arr, int key, int start, int end) {
+        if (start > end){
+            return -1;
+        }
+        /* First boundary: add 1/3 of length to start */
+        int mid1 = start + (end - start) / 3;
+        /* Second boundary: add 2/3 of length to start */
+        int mid2 = start + 2 * (end - start) / 3;
+        if (arr[mid1] == key) {
+            return mid1;
+        }
+        else if (arr[mid2] == key) {
+            return mid2;
+        }
+
+        /* Search the first (1/3) rd part of the array.*/
+
+        else if (key < arr[mid1]) {
+            return ternarySearch(arr, key, start, mid1 - 1);
+        }
+        /* Search 3rd (1/3)rd part of the array */
+
+        else if (key > arr[mid2]) {
+            return ternarySearch(arr, key, mid2 + 1, end);
+        }
+        /* Search middle (1/3)rd part of the array */
+
+        else {
+            return ternarySearch(arr, key, mid1, mid2);
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner s = new Scanner(System.in);
+        System.out.println("Enter number of elements in the array");
+        int n = s.nextInt();
+        int arr[] = new int[n];
+        System.out.println("Enter the elements of the Sorted array");
+        for (int i= 0; i < n; i++){
+            arr[i] = s.nextInt();
+        }
+        System.out.println("Enter element to search for : ");
+        int k = s.nextInt();
+        int ans = ternarySearch(arr, k);
+        if (ans == -1) {
+            System.out.println(" The element is not present in the array.");
+        }
+        else {
+            System.out.println("The element is present at the position " + (ans+1));
+        }
+    }
+}

Sorts/CocktailShakerSort.java

@@ -0,0 +1,86 @@
+
+/**
+ *
+ * @author Mateus Bizzo (https://github.com/MattBizzo)
+ *
+ */
+
+class CocktailShakerSort {
+	/**
+	 * This method implements the Generic Cocktail Shaker Sort
+	 *
+	 * @param array
+	 *            The array to be sorted
+	 * @param last
+	 *            The count of total number of elements in array Sorts the array in
+	 *            increasing order
+	 **/
+
+	public static <T extends Comparable<T>> void CS(T array[], int last) {
+		
+		// Sorting
+		boolean swap;
+		do {
+			swap = false;
+			
+			//front
+			for (int count = 0; count <= last - 2; count++) {
+				int comp = array[count].compareTo(array[count + 1]);
+				if (comp > 0) {
+					T aux = array[count];
+					array[count] = array[count + 1];
+					array[count + 1] = aux;
+					swap = true;
+				}
+			}
+			//break if no swap occurred
+			if (!swap) {
+				break;
+			}
+			swap = false;
+			
+			//back
+			for (int count = last - 2; count >= 0; count--) {
+				int comp = array[count].compareTo(array[count + 1]);
+				if (comp > 0) {
+					T aux = array[count];
+					array[count] = array[count + 1];
+					array[count + 1] = aux;
+					swap = true;
+				}
+			}
+			last--;
+		//end
+		} while (swap);
+	}
+
+	// Driver Program
+	public static void main(String[] args) {
+		// Integer Input
+		int[] arr1 = { 4, 23, 6, 78, 1, 54, 231, 9, 12 };
+		int last = arr1.length;
+		Integer[] array = new Integer[last];
+		for (int i = 0; i < last; i++) {
+			array[i] = arr1[i];
+		}
+
+		CS(array, last);
+
+		// Output => 1 4 6 9 12 23 54 78 231
+		for (int i = 0; i < last; i++) {
+			System.out.print(array[i] + "\t");
+		}
+		System.out.println();
+
+		// String Input
+		String[] array1 = { "c", "a", "e", "b", "d" };
+		last = array1.length;
+
+		CS(array1, last);
+
+		// Output => a b c d e
+		for (int i = 0; i < last; i++) {
+			System.out.print(array1[i] + "\t");
+		}
+	}
+}

Sorts/CountSort.java

@@ -0,0 +1,47 @@
+public class CountingSort
+{
+    public static void sort(char arr[])
+    {
+        int n = arr.length;
+ 
+        // The output character array that will have sorted arr
+        char output[] = new char[n];
+ 
+        // Create a count array to store count of inidividul
+        // characters and initialize count array as 0
+        int count[] = new int[256];
+        for (int i = 0; i < 256; ++i)
+            count[i] = 0;
+ 
+        // store count of each character
+        for (int i=0; i<n; ++i)
+            ++count[arr[i]];
+ 
+        // Change count[i] so that count[i] now contains actual
+        // position of this character in output array
+        for (int i = 1; i <= 255; ++i)
+            count[i] += count[i-1];
+ 
+        // Build the output character array
+        for (int i = 0; i < n; ++i)
+        {
+            output[count[arr[i]] - 1] = arr[i];
+            --count[arr[i]];
+        }
+ 
+        // Copy the output array to arr, so that arr now
+        // contains sorted characters
+        for (int i = 0; i<n; ++i)
+            arr[i] = output[i];
+    }
+ 
+    public static void main(String args[])
+    {
+        char arr[] = {'h','a','c','k','t','o','b','e','r','f','e','s','t'};
+        
+        sort(arr);
+        System.out.print("Sorted character array is ");
+        for (int i=0; i<arr.length; ++i)
+            System.out.print(arr[i]);
+    }
+}

Sorts/CountingSort.java

@@ -0,0 +1,90 @@
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.TreeMap;
+
+/**
+ *
+ * @author Youssef Ali (https://github.com/youssefAli11997)
+ *
+ */
+
+class CountingSort {
+
+    /**
+     * This method implements the Generic Counting Sort
+     *
+     * @param array The array to be sorted 
+     * @param last The count of total number of elements in array
+     * Sorts the array in increasing order
+     * It uses array elements as keys in the frequency map
+     **/
+	    
+    public static <T extends Comparable<T>> void CS(T[] array, int last) {
+    
+    	Map<T, Integer> frequency = new TreeMap<T, Integer>();
+    	// The final output array
+    	ArrayList<T> sortedArray = new ArrayList<T>();
+    	
+    	// Counting the frequency of @param array elements
+    	for(T t : array) {
+    		try{
+    			frequency.put(t, frequency.get(t)+1);
+    		}catch(Exception e){ // new entry
+    			frequency.put(t, 1);
+    		}
+        }
+    	
+    	// Filling the sortedArray
+    	for(Map.Entry<T, Integer> element : frequency.entrySet()) {
+            for(int j=0; j<element.getValue(); j++)
+                sortedArray.add(element.getKey());
+        }
+    	
+    	for(int i=0; i<array.length; i++){
+    		array[i] = sortedArray.get(i);
+    	}
+    }
+
+    // Driver Program
+    public static void main(String[] args) {
+        // Integer Input
+        Integer[] arr1 = {4,23,6,78,1,54,231,9,12};
+        int last = arr1.length;
+        
+        System.out.println("Before Sorting:");
+        for (int i=0;i<arr1.length;i++) {
+            System.out.print(arr1[i] + " ");
+        }
+        System.out.println();
+
+        CS(arr1, last);
+
+        // Output => 1 4 6 9 12 23 54 78 231
+        System.out.println("After Sorting:");
+        for (int i=0;i<arr1.length;i++) {
+            System.out.print(arr1[i] + " ");
+        }
+        System.out.println();
+        
+        System.out.println("------------------------------");
+        
+        // String Input
+        String[] array1 = {"c", "a", "e", "b","d"};
+        last = array1.length;
+        
+        System.out.println("Before Sorting:");
+        for (int i=0;i<array1.length;i++) {
+            System.out.print(array1[i] + " ");
+        }
+        System.out.println();
+
+        CS(array1, last);
+
+        //Output => a	  b	 c	d	e
+        System.out.println("After Sorting:");
+        for(int i=0; i<last; i++) {
+            System.out.print(array1[i]+" ");
+		}
+		
+    }
+}

Sorts/CountingSortIntegers.java

@@ -0,0 +1,66 @@
+/**
+ *
+ * @author Youssef Ali (https://github.com/youssefAli11997)
+ *
+ */
+
+class CountingSortIntegers {
+
+    /**
+     * This method implements the Counting Sort for integers
+     *
+     * @param array The array to be sorted 
+     * @param last The count of total number of elements in array
+     * Sorts the array in increasing order
+     * It sorts only integer arrays especially positive integers
+     * It uses array elements as indexes in the frequency array
+     * It can accept only array elements within the range [0:10^8]
+     **/
+
+    public static void CSI(int array[], int last) {
+    
+    	// The frequency array. It's initialized with zeros
+    	int[] frequency = new int[100000001];
+    	// The final output array
+    	int[] sortedArray = new int[array.length];
+    	int index = 0;
+    	
+    	// Counting the frequency of @param array elements
+    	for(int i=0; i<last; i++){
+    		frequency[array[i]]++;
+    	}
+    	
+    	// Filling the sortedArray
+    	for(int i=0; i<frequency.length; i++){
+    		for(int j=0; j<frequency[i]; j++)
+    			sortedArray[index++] = i;
+    	}
+    	
+    	for(int i=0; i<array.length; i++){
+    		array[i] = sortedArray[i];
+    	}
+    }
+
+    // Driver Program
+    public static void main(String[] args) {
+        // Integer Input
+        int[] arr1 = {4,23,6,78,1,54,231,9,12};
+        int last = arr1.length;
+        
+        System.out.println("Before Sorting:");
+        for (int i=0;i<arr1.length;i++) {
+            System.out.print(arr1[i] + " ");
+        }
+        System.out.println();
+
+        CSI(arr1, last);
+
+        // Output => 1 4 6 9 12 23 54 78 231
+        System.out.println("After Sorting:");
+        for (int i=0;i<arr1.length;i++) {
+            System.out.print(arr1[i] + " ");
+        }
+        System.out.println();
+
+    }
+}

Sorts/InsertionSortInteger.java

@@ -1,61 +0,0 @@
-/**
- * This is my implementation of an insertion sort.
- * 
- * I decided to do this when i didn't feel comfortable enough about implementing 
- * different types of sorts, so this is my trial and error to try and get myself to implement
- * the various sorts correctly. 
- * 
- * @author Kody C. Kendall
- *
- */
-public class InsertionSortInteger {
-
-	
-	/**
-	 * This method implements insertion sort by integer
-	 * 
-	 * @param initialArray array to be sorted
-	 * @return sorted array
-	 */
-	public int[] insertionIntArraySort(int[] initialArray){
-		
-		int[] sortedArray = new int[initialArray.length];
-		
-		//Marking first element as sorted. 
-		sortedArray[0] = initialArray[0];
-				
-		//For each element in the initialArray
-		for (int index = 1; index < initialArray.length; index++){	
-			
-			//Finding the last index that was sorted
-			int lastSortedIndex = index;
-			
-			//Extracting the next element to be compared w/ other sorted elements from initial array
-			int extractedElement = initialArray[index];
-			
-			//Compare the values of the sorted index to the current extractedElement
-			for (lastSortedIndex = index; lastSortedIndex > 0; lastSortedIndex--){
-				
-				//If our extracted element is smaller than element to the right, switch them. 
-				if (sortedArray[lastSortedIndex-1] > extractedElement){
-					//move the element to the left of extractedElement to the right in sortedArray
-					sortedArray[lastSortedIndex] = sortedArray[lastSortedIndex-1];
-					//And move the current extractedElement to the left one (since it's smaller). 
-					sortedArray[lastSortedIndex-1] = extractedElement;
-				}
-				else{
-					//insert element where it is.
-					sortedArray[lastSortedIndex] = extractedElement;
-					//Terminating loop since element is in the right spot. 
-					break;  
-				}
-				
-			}
-			
-		}
-		
-		return sortedArray;
-		
-	}
-
-}

ciphers/ColumnarTranspositionCipher.java

@@ -0,0 +1,169 @@
+/**
+ * Columnar Transposition Cipher Encryption and Decryption.
+ * @author <a href="https://github.com/freitzzz">freitzzz</a>
+ */
+public class ColumnarTranspositionCipher {
+    private static String keyword;
+    private static Object[][] table;
+    private static String abecedarium;
+    public static final String ABECEDARIUM="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789,.;:-@";
+    private static final String ENCRYPTION_FIELD="≈";
+    private static final char ENCRYPTION_FIELD_CHAR='≈';
+    /**
+     * Encrypts a certain String with the Columnar Transposition Cipher Rule
+     * @param word Word being encrypted
+     * @param keyword String with keyword being used
+     * @return a String with the word encrypted by the Columnar Transposition Cipher Rule
+     */
+    public static String encrpyter(String word,String keyword){
+        ColumnarTranspositionCipher.keyword=keyword;
+        abecedariumBuilder(500);
+        table=tableBuilder(word);
+        Object[][] sortedTable=sortTable(table);
+        String wordEncrypted="";
+        for(int i=0;i<sortedTable[0].length;i++){
+            for(int j=1;j<sortedTable.length;j++){
+                wordEncrypted+=sortedTable[j][i];
+            }
+        }
+        return wordEncrypted;
+    }
+
+    /**
+     * Encrypts a certain String with the Columnar Transposition Cipher Rule
+     * @param word Word being encrypted
+     * @param keyword String with keyword being used
+     * @param abecedarium String with the abecedarium being used. null for default one
+     * @return a String with the word encrypted by the Columnar Transposition Cipher Rule
+     */
+    public static String encrpyter(String word,String keyword,String abecedarium){
+        ColumnarTranspositionCipher.keyword=keyword;
+        if(abecedarium!=null){
+            ColumnarTranspositionCipher.abecedarium=abecedarium;
+        }else{
+            ColumnarTranspositionCipher.abecedarium=ABECEDARIUM;
+        }
+        table=tableBuilder(word);
+        Object[][] sortedTable=sortTable(table);
+        String wordEncrypted="";
+        for(int i=0;i<sortedTable[0].length;i++){
+            for(int j=1;j<sortedTable.length;j++){
+                wordEncrypted+=sortedTable[j][i];
+            }
+        }
+        return wordEncrypted;
+    }
+    /**
+     * Decryps a certain encrypted String with the Columnar Transposition Cipher Rule
+     * @return a String decrypted with the word ecrypted by the Columnar Transpositiion Cipher Rule
+     */
+    public static String decrypter(){
+        String wordDecrypted="";
+        for(int i=1;i<table.length;i++){
+            for(int j=0;j<table[i].length;j++){
+                wordDecrypted+=table[i][j];
+            }
+        }
+        return wordDecrypted.replaceAll(ENCRYPTION_FIELD,"");
+    }
+    /**
+     * Builds a table with the word to be encrpyted in rows by the Columnar Transposition Cipher Rule
+     * @return An Object[][] with the word to be encrypted filled in rows and columns
+     */
+    private static Object[][] tableBuilder(String word){
+        Object[][] table=new Object[rows(word)+1][keyword.length()];
+        char[] wordInChards=word.toCharArray();
+        //Fils in the respective numbers
+        table[0]=findElements();
+        int charElement=0;
+        for(int i=1;i<table.length;i++){
+            for(int j=0;j<table[i].length;j++){
+                if(charElement<wordInChards.length){
+                    table[i][j]=(char)wordInChards[charElement];
+                    charElement++;
+                }else{
+                    table[i][j]=ENCRYPTION_FIELD_CHAR;
+                }
+            }
+        }
+        return table;
+    }
+    /**
+     * Determines the number of rows the table should have regarding the Columnar Transposition Cipher Rule
+     * @return an int with the number of rows that the table should have in order to respect the Columnar Transposition Cipher Rule.
+     */
+    private static int rows(String word){
+        if((double)word.length()/keyword.length()>word.length()/keyword.length()){
+            return (word.length()/keyword.length())+1;
+        }else{
+            return word.length()/keyword.length();
+        }
+    }
+    private static Object[] findElements(){
+        Object[] charValues=new Object[keyword.length()];
+        for(int i=0;i<charValues.length;i++){
+            for(int j=0;j<abecedarium.length();j++){
+                if(keyword.charAt(i)==abecedarium.charAt(j))charValues[i]=j;
+            }
+        }
+        return charValues;
+    }
+    private static Object[][] sortTable(Object[][] table){
+        Object[][] tableSorted=new Object[table.length][table[0].length];
+        for(int i=0;i<tableSorted.length;i++){
+            for(int j=0;j<tableSorted[i].length;j++){
+                tableSorted[i][j]=table[i][j];
+            }
+        }
+        for(int i=0;i<tableSorted[0].length;i++){
+            for(int j=i+1;j<tableSorted[0].length;j++){
+                if((int)tableSorted[0][i]>(int)table[0][j]){
+                    Object[] column=getColumn(tableSorted,tableSorted.length,i);
+                    switchColumns(tableSorted,j,i,column);
+                }
+            }
+        }
+        return tableSorted;
+    }
+    private static Object[] getColumn(Object[][] table,int rows,int column){
+        Object[] columnArray=new Object[rows];
+        for(int i=0;i<rows;i++){
+            columnArray[i]=table[i][column];
+        }
+        return columnArray;
+    }
+    private static void switchColumns(Object[][] table, int firstColumnIndex,int secondColumnIndex,Object[] columnToSwitch){
+        for(int i=0;i<table.length;i++){
+            table[i][secondColumnIndex]=table[i][firstColumnIndex];
+            table[i][firstColumnIndex]=columnToSwitch[i];
+        }
+    }
+    /**
+     * Creates an abecedarium with a specified ascii inded
+     * @param value Number of characters being used based on the ASCII Table
+     */
+    private static void abecedariumBuilder(int value){
+        abecedarium="";
+        for(int i=0;i<value;i++){
+            abecedarium+=(char)i;
+        }
+    }
+    private static void showTable(){
+        for(int i=0;i<table.length;i++){
+            for(int j=0;j<table[i].length;j++){
+                System.out.print(table[i][j]+" ");
+            }
+            System.out.println();
+        }
+    }
+    public static void main(String[] args){
+        String keywordForExample="asd215";
+        String wordBeingEncrypted="This is a test of the Columnar Transposition Cipher";
+        System.out.println("### Example of Columnar Transposition Cipher ###\n");
+        System.out.println("Word being encryped ->>> "+wordBeingEncrypted);
+        System.out.println("Word encrypted ->>> "+ColumnarTranspositionCipher.encrpyter(wordBeingEncrypted,keywordForExample));
+        System.out.println("Word decryped ->>> "+ColumnarTranspositionCipher.decrypter());
+        System.out.println("\n### Encrypted Table ###");
+        showTable();
+    }
+}

ciphers/RSA.java

@@ -0,0 +1,62 @@
+package ciphers;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+
+/**
+ * Created by Nguyen Duy Tiep on 23-Oct-17.
+ */
+public class RSA {
+    private BigInteger modulus, privateKey, publicKey;
+
+    public RSA(int bits) {
+        generateKeys(bits);
+    }
+
+    public synchronized String encrypt(String message) {
+        return (new BigInteger(message.getBytes())).modPow(publicKey, modulus).toString();
+    }
+
+    public synchronized BigInteger encrypt(BigInteger message) {
+        return message.modPow(publicKey, modulus);
+    }
+
+    public synchronized String decrypt(String message) {
+        return new String((new BigInteger(message)).modPow(privateKey, modulus).toByteArray());
+    }
+
+    public synchronized BigInteger decrypt(BigInteger message) {
+        return message.modPow(privateKey, modulus);
+    }
+
+    /** Generate a new public and private key set. */
+    public synchronized void generateKeys(int bits) {
+        SecureRandom r = new SecureRandom();
+        BigInteger p = new BigInteger(bits / 2, 100, r);
+        BigInteger q = new BigInteger(bits / 2, 100, r);
+        modulus = p.multiply(q);
+
+        BigInteger m = (p.subtract(BigInteger.ONE)).multiply(q.subtract(BigInteger.ONE));
+
+        publicKey = new BigInteger("3");
+
+        while (m.gcd(publicKey).intValue() > 1) {
+            publicKey = publicKey.add(new BigInteger("2"));
+        }
+
+        privateKey = publicKey.modInverse(m);
+    }
+
+    /** Trivial test program. */
+    public static void main(String[] args) {
+        RSA rsa = new RSA(1024);
+
+        String text1 = "This is a message";
+        System.out.println("Plaintext: " + text1);
+
+        String ciphertext = rsa.encrypt(text1);
+        System.out.println("Ciphertext: " + ciphertext);
+
+        System.out.println("Plaintext: " + rsa.decrypt(ciphertext));
+    }
+}

data_structures/Graphs/Kruskal's Algorithm.java

@@ -0,0 +1,174 @@
+// Java program for Kruskal's algorithm to find Minimum Spanning Tree
+// of a given connected, undirected and weighted graph
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+ 
+class Graph
+{
+    // A class to represent a graph edge
+    class Edge implements Comparable<Edge>
+    {
+        int src, dest, weight;
+ 
+        // Comparator function used for sorting edges based on
+        // their weight
+        public int compareTo(Edge compareEdge)
+        {
+            return this.weight-compareEdge.weight;
+        }
+    };
+ 
+    // A class to represent a subset for union-find
+    class subset
+    {
+        int parent, rank;
+    };
+ 
+    int V, E;    // V-> no. of vertices & E->no.of edges
+    Edge edge[]; // collection of all edges
+ 
+    // Creates a graph with V vertices and E edges
+    Graph(int v, int e)
+    {
+        V = v;
+        E = e;
+        edge = new Edge[E];
+        for (int i=0; i<e; ++i)
+            edge[i] = new Edge();
+    }
+ 
+    // A utility function to find set of an element i
+    // (uses path compression technique)
+    int find(subset subsets[], int i)
+    {
+        // find root and make root as parent of i (path compression)
+        if (subsets[i].parent != i)
+            subsets[i].parent = find(subsets, subsets[i].parent);
+ 
+        return subsets[i].parent;
+    }
+ 
+    // A function that does union of two sets of x and y
+    // (uses union by rank)
+    void Union(subset subsets[], int x, int y)
+    {
+        int xroot = find(subsets, x);
+        int yroot = find(subsets, y);
+ 
+        // Attach smaller rank tree under root of high rank tree
+        // (Union by Rank)
+        if (subsets[xroot].rank < subsets[yroot].rank)
+            subsets[xroot].parent = yroot;
+        else if (subsets[xroot].rank > subsets[yroot].rank)
+            subsets[yroot].parent = xroot;
+ 
+        // If ranks are same, then make one as root and increment
+        // its rank by one
+        else
+        {
+            subsets[yroot].parent = xroot;
+            subsets[xroot].rank++;
+        }
+    }
+ 
+    // The main function to construct MST using Kruskal's algorithm
+    void KruskalMST()
+    {
+        Edge result[] = new Edge[V];  // Tnis will store the resultant MST
+        int e = 0;  // An index variable, used for result[]
+        int i = 0;  // An index variable, used for sorted edges
+        for (i=0; i<V; ++i)
+            result[i] = new Edge();
+ 
+        // Step 1:  Sort all the edges in non-decreasing order of their
+        // weight.  If we are not allowed to change the given graph, we
+        // can create a copy of array of edges
+        Arrays.sort(edge);
+ 
+        // Allocate memory for creating V ssubsets
+        subset subsets[] = new subset[V];
+        for(i=0; i<V; ++i)
+            subsets[i]=new subset();
+ 
+        // Create V subsets with single elements
+        for (int v = 0; v < V; ++v)
+        {
+            subsets[v].parent = v;
+            subsets[v].rank = 0;
+        }
+ 
+        i = 0;  // Index used to pick next edge
+ 
+        // Number of edges to be taken is equal to V-1
+        while (e < V - 1)
+        {
+            // Step 2: Pick the smallest edge. And increment the index
+            // for next iteration
+            Edge next_edge = new Edge();
+            next_edge = edge[i++];
+ 
+            int x = find(subsets, next_edge.src);
+            int y = find(subsets, next_edge.dest);
+ 
+            // If including this edge does't cause cycle, include it
+            // in result and increment the index of result for next edge
+            if (x != y)
+            {
+                result[e++] = next_edge;
+                Union(subsets, x, y);
+            }
+            // Else discard the next_edge
+        }
+ 
+        // print the contents of result[] to display the built MST
+        System.out.println("Following are the edges in the constructed MST");
+        for (i = 0; i < e; ++i)
+            System.out.println(result[i].src+" -- "+result[i].dest+" == "+
+                               result[i].weight);
+    }
+ 
+    // Driver Program
+    public static void main (String[] args)
+    {
+ 
+        /* Let us create following weighted graph
+                 10
+            0--------1
+            |  \     |
+           6|   5\   |15
+            |      \ |
+            2--------3
+                4       */
+        int V = 4;  // Number of vertices in graph
+        int E = 5;  // Number of edges in graph
+        Graph graph = new Graph(V, E);
+ 
+        // add edge 0-1
+        graph.edge[0].src = 0;
+        graph.edge[0].dest = 1;
+        graph.edge[0].weight = 10;
+ 
+        // add edge 0-2
+        graph.edge[1].src = 0;
+        graph.edge[1].dest = 2;
+        graph.edge[1].weight = 6;
+ 
+        // add edge 0-3
+        graph.edge[2].src = 0;
+        graph.edge[2].dest = 3;
+        graph.edge[2].weight = 5;
+ 
+        // add edge 1-3
+        graph.edge[3].src = 1;
+        graph.edge[3].dest = 3;
+        graph.edge[3].weight = 15;
+ 
+        // add edge 2-3
+        graph.edge[4].src = 2;
+        graph.edge[4].dest = 3;
+        graph.edge[4].weight = 4;
+ 
+        graph.KruskalMST();
+    }
+}

data_structures/Graphs/PrimMST.java

@@ -0,0 +1,116 @@
+// A Java program for Prim's Minimum Spanning Tree (MST) algorithm.
+//adjacency matrix representation of the graph
+ 
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+ 
+class PrimMST
+{
+    // Number of vertices in the graph
+    private static final int V=5;
+ 
+    // A utility function to find the vertex with minimum key
+    // value, from the set of vertices not yet included in MST
+    int minKey(int key[], Boolean mstSet[])
+    {
+        // Initialize min value
+        int min = Integer.MAX_VALUE, min_index=-1;
+ 
+        for (int v = 0; v < V; v++)
+            if (mstSet[v] == false && key[v] < min)
+            {
+                min = key[v];
+                min_index = v;
+            }
+ 
+        return min_index;
+    }
+ 
+    // A utility function to print the constructed MST stored in
+    // parent[]
+    void printMST(int parent[], int n, int graph[][])
+    {
+        System.out.println("Edge   Weight");
+        for (int i = 1; i < V; i++)
+            System.out.println(parent[i]+" - "+ i+"    "+
+                               graph[i][parent[i]]);
+    }
+ 
+    // Function to construct and print MST for a graph represented
+    //  using adjacency matrix representation
+    void primMST(int graph[][])
+    {
+        // Array to store constructed MST
+        int parent[] = new int[V];
+ 
+        // Key values used to pick minimum weight edge in cut
+        int key[] = new int [V];
+ 
+        // To represent set of vertices not yet included in MST
+        Boolean mstSet[] = new Boolean[V];
+ 
+        // Initialize all keys as INFINITE
+        for (int i = 0; i < V; i++)
+        {
+            key[i] = Integer.MAX_VALUE;
+            mstSet[i] = false;
+        }
+ 
+        // Always include first 1st vertex in MST.
+        key[0] = 0;     // Make key 0 so that this vertex is
+                        // picked as first vertex
+        parent[0] = -1; // First node is always root of MST
+ 
+        // The MST will have V vertices
+        for (int count = 0; count < V-1; count++)
+        {
+            // Pick thd minimum key vertex from the set of vertices
+            // not yet included in MST
+            int u = minKey(key, mstSet);
+ 
+            // Add the picked vertex to the MST Set
+            mstSet[u] = true;
+ 
+            // Update key value and parent index of the adjacent
+            // vertices of the picked vertex. Consider only those
+            // vertices which are not yet included in MST
+            for (int v = 0; v < V; v++)
+ 
+                // graph[u][v] is non zero only for adjacent vertices of m
+                // mstSet[v] is false for vertices not yet included in MST
+                // Update the key only if graph[u][v] is smaller than key[v]
+                if (graph[u][v]!=0 && mstSet[v] == false &&
+                    graph[u][v] <  key[v])
+                {
+                    parent[v]  = u;
+                    key[v] = graph[u][v];
+                }
+        }
+ 
+        // print the constructed MST
+        printMST(parent, V, graph);
+    }
+ 
+    public static void main (String[] args)
+    {
+        /* Let us create the following graph
+           2    3
+        (0)--(1)--(2)
+        |    / \   |
+        6| 8/   \5 |7
+        | /      \ |
+        (3)-------(4)
+             9          */
+        MST t = new MST();
+        int graph[][] = new int[][] {{0, 2, 0, 6, 0},
+                                    {2, 0, 3, 8, 5},
+                                    {0, 3, 0, 0, 7},
+                                    {6, 8, 0, 0, 9},
+                                    {0, 5, 7, 9, 0},
+                                   };
+ 
+        // Print the solution
+        t.primMST(graph);
+    }
+}

data_structures/Stacks/StackOfLinkedList.java

@@ -0,0 +1,98 @@
+/**
+ *
+ * @author Varun Upadhyay (https://github.com/varunu28)
+ *
+ */
+
+// An implementation of a Stack using a Linked List
+
+class StackOfLinkedList {
+
+    public static void main(String[] args) {
+
+        LinkedListStack stack = new LinkedListStack();
+        stack.push(1);
+        stack.push(2);
+        stack.push(3);
+        stack.push(4);
+
+        stack.printStack();
+
+        System.out.println("Size of stack currently is: " + stack.getSize());
+
+        stack.pop();
+        stack.pop();
+
+    }
+
+}
+
+// A node class
+
+class Node {
+    public int data;
+    public Node next;
+
+    public Node(int data) {
+        this.data = data;
+        this.next = null;
+    }
+}
+
+/**
+ * A class which implements a stack using a linked list
+ *
+ * Contains all the stack methods : push, pop, printStack, isEmpty
+ **/
+
+class LinkedListStack {
+
+    Node head = null;
+    int size = 0;
+
+    public void push(int x) {
+        Node n = new Node(x);
+        if (getSize() == 0) {
+            head = n;
+        }
+        else {
+            Node temp = head;
+            n.next = temp;
+            head = n;
+        }
+        size++;
+    }
+
+    public void pop() {
+        if (getSize() == 0) {
+            System.out.println("Empty stack. Nothing to pop");
+        }
+
+        Node temp = head;
+        head = head.next;
+        size--;
+
+        System.out.println("Popped element is: " + temp.data);
+    }
+
+    public void printStack() {
+
+        Node temp = head;
+        System.out.println("Stack is printed as below: ");
+        while (temp != null) {
+            System.out.print(temp.data + " ");
+            temp = temp.next;
+        }
+        System.out.println();
+
+    }
+
+    public boolean isEmpty() {
+        return getSize() == 0;
+    }
+
+    public int getSize() {
+        return size;
+    }
+    
+}

data_structures/Trees/FindHeightOfTree.java

@@ -0,0 +1,100 @@
+/**
+ *
+ * @author Varun Upadhyay (https://github.com/varunu28)
+ *
+ */
+import java.util.LinkedList;
+
+public class FindHeightOfTree {
+
+    // Driver Program
+    public static void main(String[] args) {
+        Node tree = new Node(5);
+        tree.insert(3);
+        tree.insert(7);
+        tree.insert(1);
+        tree.insert(-1);
+        tree.insert(29);
+        tree.insert(93);
+        tree.insert(6);
+        tree.insert(0);
+        tree.insert(-5);
+        tree.insert(-6);
+        tree.insert(-8);
+        tree.insert(-1);
+
+        // A level order representation of the tree
+        tree.printLevelOrder();
+        System.out.println();
+
+        System.out.println("Height of the tree is: " + tree.findHeight());
+    }
+}
+
+/**
+ * The Node class which initializes a Node of a tree
+ * printLevelOrder: ROOT -> ROOT's CHILDREN -> ROOT's CHILDREN's CHILDREN -> etc
+ * findHeight: Returns the height of the tree i.e. the number of links between root and farthest leaf
+ */
+class Node {
+    Node left, right;
+    int data;
+
+    public Node(int data) {
+        this.data = data;
+    }
+
+    public void insert (int value) {
+        if (value < data) {
+            if (left == null) {
+                left = new Node(value);
+            }
+            else {
+                left.insert(value);
+            }
+        }
+        else {
+            if (right == null) {
+                right = new Node(value);
+            }
+            else {
+                right.insert(value);
+            }
+        }
+    }
+
+    public void printLevelOrder() {
+        LinkedList<Node> queue = new LinkedList<>();
+        queue.add(this);
+        while(!queue.isEmpty()) {
+            Node n = queue.poll();
+            System.out.print(n.data + " ");
+            if (n.left != null) {
+                queue.add(n.left);
+            }
+            if (n.right != null) {
+                queue.add(n.right);
+            }
+        }
+    }
+
+    public int findHeight() {
+        return findHeight(this);
+    }
+
+    private int findHeight(Node root) {
+        if (root.left == null && root.right == null) {
+            return 0;
+        }
+        else if (root.left != null && root.right != null) {
+            return 1 + Math.max(findHeight(root.left), findHeight(root.right));
+        }
+        else if (root.left == null && root.right != null) {
+            return 1 + findHeight(root.right);
+        }
+        else {
+            return 1 + findHeight(root.left);
+        }
+    }
+}
+

data_structures/Trees/Level Order Traversal(using Queue).java

@@ -0,0 +1,62 @@
+import java.util.Queue;
+import java.util.LinkedList;
+ 
+/* Class to represent Tree node */
+class Node {
+    int data;
+    Node left, right;
+ 
+    public Node(int item) {
+        data = item;
+        left = null;
+        right = null;
+    }
+}
+ 
+/* Class to print Level Order Traversal */
+class BinaryTree {
+ 
+    Node root;
+ 
+    /* Given a binary tree. Print its nodes in level order
+     using array for implementing queue  */
+    void printLevelOrder() 
+    {
+        Queue<Node> queue = new LinkedList<Node>();
+        queue.add(root);
+        while (!queue.isEmpty()) 
+        {
+ 
+            /* poll() removes the present head.
+            For more information on poll() visit 
+            http://www.tutorialspoint.com/java/util/linkedlist_poll.htm */
+            Node tempNode = queue.poll();
+            System.out.print(tempNode.data + " ");
+ 
+            /*Enqueue left child */
+            if (tempNode.left != null) {
+                queue.add(tempNode.left);
+            }
+ 
+            /*Enqueue right child */
+            if (tempNode.right != null) {
+                queue.add(tempNode.right);
+            }
+        }
+    }
+ 
+    public static void main(String args[]) 
+    {
+        /* creating a binary tree and entering 
+         the nodes */
+        BinaryTree tree_level = new BinaryTree();
+        tree_level.root = new Node(1);
+        tree_level.root.left = new Node(2);
+        tree_level.root.right = new Node(3);
+        tree_level.root.left.left = new Node(4);
+        tree_level.root.left.right = new Node(5);
+ 
+        System.out.println("Level order traversal of binary tree is - ");
+        tree_level.printLevelOrder();
+    }
+}

data_structures/Trees/Level Order Traversal.java

@@ -0,0 +1,78 @@
+class Node
+{
+    int data;
+    Node left, right;
+    public Node(int item)
+    {
+        data = item;
+        left = right = null;
+    }
+}
+ 
+class BinaryTree
+{
+    // Root of the Binary Tree
+    Node root;
+ 
+    public BinaryTree()
+    {
+        root = null;
+    }
+ 
+    /* function to print level order traversal of tree*/
+    void printLevelOrder()
+    {
+        int h = height(root);
+        int i;
+        for (i=1; i<=h; i++)
+            printGivenLevel(root, i);
+    }
+ 
+    /* Compute the "height" of a tree -- the number of
+    nodes along the longest path from the root node
+    down to the farthest leaf node.*/
+    int height(Node root)
+    {
+        if (root == null)
+           return 0;
+        else
+        {
+            /* compute  height of each subtree */
+            int lheight = height(root.left);
+            int rheight = height(root.right);
+             
+            /* use the larger one */
+            if (lheight > rheight)
+                return(lheight+1);
+            else return(rheight+1); 
+        }
+    }
+ 
+    /* Print nodes at the given level */
+    void printGivenLevel (Node root ,int level)
+    {
+        if (root == null)
+            return;
+        if (level == 1)
+            System.out.print(root.data + " ");
+        else if (level > 1)
+        {
+            printGivenLevel(root.left, level-1);
+            printGivenLevel(root.right, level-1);
+        }
+    }
+     
+    /* Driver program to test above functions */
+    public static void main(String args[])
+    {
+       BinaryTree tree = new BinaryTree();
+       tree.root= new Node(1);
+       tree.root.left= new Node(2);
+       tree.root.right= new Node(3);
+       tree.root.left.left= new Node(4);
+       tree.root.left.right= new Node(5);
+        
+       System.out.println("Level order traversal of binary tree is ");
+       tree.printLevelOrder();
+    }
+}

data_structures/Trees/Print Top View of Tree.java

@@ -0,0 +1,105 @@
+// Java program to print top view of Binary tree
+import java.util.*;
+ 
+// Class for a tree node
+class TreeNode
+{
+    // Members
+    int key;
+    TreeNode left, right;
+ 
+    // Constructor
+    public TreeNode(int key)
+    {
+        this.key = key;
+        left = right = null;
+    }
+}
+ 
+// A class to represent a queue item. The queue is used to do Level
+// order traversal. Every Queue item contains node and horizontal
+// distance of node from root
+class QItem
+{
+   TreeNode node;
+   int hd;
+   public QItem(TreeNode n, int h)
+   {
+        node = n;
+        hd = h;
+   }
+}
+ 
+// Class for a Binary Tree
+class Tree
+{
+    TreeNode root;
+ 
+    // Constructors
+    public Tree()  { root = null; }
+    public Tree(TreeNode n) { root = n; }
+ 
+    // This method prints nodes in top view of binary tree
+    public void printTopView()
+    {
+        // base case
+        if (root == null) {  return;  }
+ 
+        // Creates an empty hashset
+        HashSet<Integer> set = new HashSet<>();
+ 
+        // Create a queue and add root to it
+        Queue<QItem> Q = new LinkedList<QItem>();
+        Q.add(new QItem(root, 0)); // Horizontal distance of root is 0
+ 
+        // Standard BFS or level order traversal loop
+        while (!Q.isEmpty())
+        {
+            // Remove the front item and get its details
+            QItem qi = Q.remove();
+            int hd = qi.hd;
+            TreeNode n = qi.node;
+ 
+            // If this is the first node at its horizontal distance,
+            // then this node is in top view
+            if (!set.contains(hd))
+            {
+                set.add(hd);
+                System.out.print(n.key + " ");
+            }
+ 
+            // Enqueue left and right children of current node
+            if (n.left != null)
+                Q.add(new QItem(n.left, hd-1));
+            if (n.right != null)
+                Q.add(new QItem(n.right, hd+1));
+        }
+    }
+}
+ 
+// Driver class to test above methods
+public class Main
+{
+    public static void main(String[] args)
+    {
+        /* Create following Binary Tree
+             1
+           /  \
+          2    3
+           \
+            4
+             \
+              5
+               \
+                6*/
+        TreeNode root = new TreeNode(1);
+        root.left = new TreeNode(2);
+        root.right = new TreeNode(3);
+        root.left.right = new TreeNode(4);
+        root.left.right.right = new TreeNode(5);
+        root.left.right.right.right = new TreeNode(6);
+        Tree t = new Tree(root);
+        System.out.println("Following are nodes in top view of Binary Tree");
+        t.printTopView();
+    }
+}

data_structures/Trees/TreeTraversal.java

@@ -1,37 +1,50 @@
+import java.util.LinkedList;
+
 /**
- *
+*
- * @author Varun Upadhyay (https://github.com/varunu28)
+* @author Varun Upadhyay (https://github.com/varunu28)
- *
+*
- */
+*/
+
 
 // Driver Program
 public class TreeTraversal {
     public static void main(String[] args) {
         Node tree = new Node(5);
         tree.insert(3);
+        tree.insert(2);
         tree.insert(7);
+        tree.insert(4);
+        tree.insert(6);
+        tree.insert(8);
 
-        // Prints 3 5 7
+        // Prints 5 3 2 4 7 6 8
-        tree.printInOrder();
+        System.out.println("Pre order traversal:");
-        System.out.println();
-
-        // Prints 5 3 7
         tree.printPreOrder();
         System.out.println();
-
+        // Prints 2 3 4 5 6 7 8
-        // Prints 3 7 5
+        System.out.println("In order traversal:");
+        tree.printInOrder();
+        System.out.println();
+        // Prints 2 4 3 6 8 7 5
+        System.out.println("Post order traversal:");
         tree.printPostOrder();
         System.out.println();
+        // Prints 5 3 7 2 4 6 8
+        System.out.println("Level order traversal:");
+        tree.printLevelOrder();
+        System.out.println();
     }
 }
 
 /**
- * The Node class which initializes a Node of a tree
+* The Node class which initializes a Node of a tree
- * Consists of all 3 traversal methods: printInOrder, printPostOrder & printPreOrder
+* Consists of all 3 traversal methods: printInOrder, printPostOrder & printPreOrder
- * printInOrder: LEFT -> ROOT -> RIGHT
+* printInOrder: LEFT -> ROOT -> RIGHT
- * printPreOrder: ROOT -> LEFT -> RIGHT
+* printPreOrder: ROOT -> LEFT -> RIGHT
- * printPostOrder: LEFT -> RIGHT -> ROOT
+* printPostOrder: LEFT -> RIGHT -> ROOT
- */
+* printLevelOrder: Prints by level (starting at root), from left to right.
+*/
 class Node {
     Node left, right;
     int data;
@@ -88,5 +101,24 @@ class Node {
         }
         System.out.print(data + " ");
     }
-}
 
+    /**
+    * O(n) time algorithm.
+    * Uses O(n) space to store nodes in a queue to aid in traversal.
+    */
+    public void printLevelOrder() {
+        LinkedList<Node> queue = new LinkedList<>();
+        queue.add(this);
+        while (queue.size() > 0) {
+            Node head = queue.remove();
+            System.out.print(head.data + " ");
+            // Add children of recently-printed node to queue, if they exist.
+            if (head.left != null) {
+                queue.add(head.left);
+            }
+            if (head.right != null) {
+                queue.add(head.right);
+            }
+        }
+    }
+}

data_structures/Trees/Valid BST or not.java

@@ -0,0 +1,62 @@
+class Node
+{
+    int data;
+    Node left, right;
+ 
+    public Node(int item)
+    {
+        data = item;
+        left = right = null;
+    }
+}
+ 
+public class BinaryTree
+{
+    //Root of the Binary Tree
+    Node root;
+ 
+    /* can give min and max value according to your code or
+    can write a function to find min and max value of tree. */
+ 
+    /* returns true if given search tree is binary
+     search tree (efficient version) */
+    boolean isBST()  {
+        return isBSTUtil(root, Integer.MIN_VALUE,
+                               Integer.MAX_VALUE);
+    }
+ 
+    /* Returns true if the given tree is a BST and its
+      values are >= min and <= max. */
+    boolean isBSTUtil(Node node, int min, int max)
+    {
+        /* an empty tree is BST */
+        if (node == null)
+            return true;
+ 
+        /* false if this node violates the min/max constraints */
+        if (node.data < min || node.data > max)
+            return false;
+ 
+        /* otherwise check the subtrees recursively
+        tightening the min/max constraints */
+        // Allow only distinct values
+        return (isBSTUtil(node.left, min, node.data-1) &&
+                isBSTUtil(node.right, node.data+1, max));
+    }
+ 
+    /* Driver program to test above functions */
+    public static void main(String args[])
+    {
+        BinaryTree tree = new BinaryTree();
+        tree.root = new Node(4);
+        tree.root.left = new Node(2);
+        tree.root.right = new Node(5);
+        tree.root.left.left = new Node(1);
+        tree.root.left.right = new Node(3);
+ 
+        if (tree.isBST())
+            System.out.println("IS BST");
+        else
+            System.out.println("Not a BST");
+    }
+}