diff --git a/Conversions/AnyBaseToAnyBase.java b/Conversions/AnyBaseToAnyBase.java new file mode 100644 index 00000000..33c77975 --- /dev/null +++ b/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 digitsList = new HashSet(); + for (int i=0; i9 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; + } +} diff --git a/Dynamic Programming/Fibonacci.java b/Dynamic Programming/Fibonacci.java index 17c11d8d..b2524b4d 100644 --- a/Dynamic Programming/Fibonacci.java +++ b/Dynamic Programming/Fibonacci.java @@ -11,7 +11,7 @@ import java.util.Map; public class Fibonacci { - public static Map map = new HashMap(); + private static Map map = new HashMap(); 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 fib = new HashMap(); diff --git a/Dynamic Programming/Levenshtein_distance.java b/Dynamic Programming/Levenshtein_distance.java index 5bff389f..49f39902 100644 --- a/Dynamic Programming/Levenshtein_distance.java +++ b/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]; diff --git a/Dynamic Programming/LongestCommonSubsequence.java b/Dynamic Programming/LongestCommonSubsequence.java new file mode 100644 index 00000000..9e828056 --- /dev/null +++ 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()); + } + } +} \ No newline at end of file diff --git a/Dynamic Programming/LongestIncreasingSubsequence.java b/Dynamic Programming/LongestIncreasingSubsequence.java index 1616c246..eaa574a4 100644 --- a/Dynamic Programming/LongestIncreasingSubsequence.java +++ b/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; diff --git a/Misc/Abecedarian.java b/Others/Abecedarian.java similarity index 100% rename from Misc/Abecedarian.java rename to Others/Abecedarian.java diff --git a/Misc/CountChar.java b/Others/CountChar.java similarity index 100% rename from Misc/CountChar.java rename to Others/CountChar.java diff --git a/Misc/Dijkshtra.java b/Others/Dijkshtra.java similarity index 100% rename from Misc/Dijkshtra.java rename to Others/Dijkshtra.java diff --git a/Misc/Factorial.java b/Others/Factorial.java similarity index 100% rename from Misc/Factorial.java rename to Others/Factorial.java diff --git a/Misc/FibToN.java b/Others/FibToN.java similarity index 100% rename from Misc/FibToN.java rename to Others/FibToN.java diff --git a/Misc/FindingPrimes.java b/Others/FindingPrimes.java similarity index 100% rename from Misc/FindingPrimes.java rename to Others/FindingPrimes.java diff --git a/Misc/ft.java b/Others/FloydTriangle.java similarity index 94% rename from Misc/ft.java rename to Others/FloydTriangle.java index 815dbd29..243a4b1a 100644 --- a/Misc/ft.java +++ b/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: "); diff --git a/Misc/GCD.java b/Others/GCD.java similarity index 100% rename from Misc/GCD.java rename to Others/GCD.java diff --git a/Huffman.java b/Others/Huffman.java similarity index 100% rename from Huffman.java rename to Others/Huffman.java diff --git a/Misc/KMP.java b/Others/KMP.java similarity index 100% rename from Misc/KMP.java rename to Others/KMP.java diff --git a/Others/LinearCongruentialGenerator.java b/Others/LinearCongruentialGenerator.java new file mode 100644 index 00000000..b03c10da --- /dev/null +++ b/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()); + } + } +} diff --git a/Misc/LowestBasePalindrome.java b/Others/LowestBasePalindrome.java similarity index 100% rename from Misc/LowestBasePalindrome.java rename to Others/LowestBasePalindrome.java diff --git a/Misc/Node.java b/Others/Node.java similarity index 100% rename from Misc/Node.java rename to Others/Node.java diff --git a/Misc/Palindrome.java b/Others/Palindrome.java similarity index 100% rename from Misc/Palindrome.java rename to Others/Palindrome.java diff --git a/Others/QueueUsingTwoStacks.java b/Others/QueueUsingTwoStacks.java new file mode 100644 index 00000000..19550df8 --- /dev/null +++ b/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 + + } +} diff --git a/Misc/ReturnSubsequence.java b/Others/ReturnSubsequence.java similarity index 100% rename from Misc/ReturnSubsequence.java rename to Others/ReturnSubsequence.java diff --git a/Misc/ReverseStackUsingRecursion.java b/Others/ReverseStackUsingRecursion.java similarity index 100% rename from Misc/ReverseStackUsingRecursion.java rename to Others/ReverseStackUsingRecursion.java diff --git a/Misc/ReverseString.java b/Others/ReverseString.java similarity index 100% rename from Misc/ReverseString.java rename to Others/ReverseString.java diff --git a/Others/StackPostfixNotation.java b/Others/StackPostfixNotation.java new file mode 100644 index 00000000..c04b0ac6 --- /dev/null +++ b/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 s = new Stack (); + 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(); + } +} diff --git a/Misc/TowerOfHanoiUsingRecursion.java b/Others/TowerOfHanoiUsingRecursion.java similarity index 100% rename from Misc/TowerOfHanoiUsingRecursion.java rename to Others/TowerOfHanoiUsingRecursion.java diff --git a/Misc/countwords.java b/Others/countwords.java similarity index 100% rename from Misc/countwords.java rename to Others/countwords.java diff --git a/Misc/crc32.java b/Others/crc32.java similarity index 100% rename from Misc/crc32.java rename to Others/crc32.java diff --git a/insert_delete_in_array.java b/Others/insert_delete_in_array.java similarity index 100% rename from insert_delete_in_array.java rename to Others/insert_delete_in_array.java diff --git a/Misc/krishnamurthy.java b/Others/krishnamurthy.java similarity index 100% rename from Misc/krishnamurthy.java rename to Others/krishnamurthy.java diff --git a/Misc/removeDuplicateFromString.java b/Others/removeDuplicateFromString.java similarity index 100% rename from Misc/removeDuplicateFromString.java rename to Others/removeDuplicateFromString.java diff --git a/Misc/root_precision.java b/Others/root_precision.java similarity index 100% rename from Misc/root_precision.java rename to Others/root_precision.java diff --git a/README.md b/README.md index 3b98906a..04cedb5e 100644 --- a/README.md +++ b/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 diff --git a/Searches/TernarySearch.java b/Searches/TernarySearch.java new file mode 100644 index 00000000..06b0be56 --- /dev/null +++ b/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)); + } + } +} \ No newline at end of file diff --git a/Sorts/CocktailShakerSort.java b/Sorts/CocktailShakerSort.java new file mode 100644 index 00000000..4db840d9 --- /dev/null +++ b/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 > 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"); + } + } +} diff --git a/Sorts/CountSort.java b/Sorts/CountSort.java new file mode 100644 index 00000000..232df591 --- /dev/null +++ b/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> void CS(T[] array, int last) { + + Map frequency = new TreeMap(); + // The final output array + ArrayList sortedArray = new ArrayList(); + + // 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 element : frequency.entrySet()) { + for(int j=0; j 1 4 6 9 12 23 54 78 231 + System.out.println("After Sorting:"); + for (int i=0;i a b c d e + System.out.println("After Sorting:"); + for(int i=0; i 1 4 6 9 12 23 54 78 231 + System.out.println("After Sorting:"); + for (int i=0;i 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; - - } - -} diff --git a/ciphers/ColumnarTranspositionCipher.java b/ciphers/ColumnarTranspositionCipher.java new file mode 100644 index 00000000..b1274371 --- /dev/null +++ b/ciphers/ColumnarTranspositionCipher.java @@ -0,0 +1,169 @@ +/** + * Columnar Transposition Cipher Encryption and Decryption. + * @author freitzzz + */ +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;iword.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(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>> "+wordBeingEncrypted); + System.out.println("Word encrypted ->>> "+ColumnarTranspositionCipher.encrpyter(wordBeingEncrypted,keywordForExample)); + System.out.println("Word decryped ->>> "+ColumnarTranspositionCipher.decrypter()); + System.out.println("\n### Encrypted Table ###"); + showTable(); + } +} diff --git a/ciphers/RSA.java b/ciphers/RSA.java new file mode 100644 index 00000000..5baa61b0 --- /dev/null +++ b/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)); + } +} diff --git a/data_structures/Graphs/Kruskal's Algorithm.java b/data_structures/Graphs/Kruskal's Algorithm.java new file mode 100644 index 00000000..6fc8412c --- /dev/null +++ b/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 + { + 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 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 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 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); + } + } +} + diff --git a/data_structures/Trees/Level Order Traversal(using Queue).java b/data_structures/Trees/Level Order Traversal(using Queue).java new file mode 100644 index 00000000..4f263c95 --- /dev/null +++ b/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 queue = new LinkedList(); + 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(); + } +} \ No newline at end of file diff --git a/data_structures/Trees/Level Order Traversal.java b/data_structures/Trees/Level Order Traversal.java new file mode 100644 index 00000000..845ab376 --- /dev/null +++ b/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(); + } +} \ No newline at end of file diff --git a/data_structures/Trees/Print Top View of Tree.java b/data_structures/Trees/Print Top View of Tree.java new file mode 100644 index 00000000..a429f8a6 --- /dev/null +++ b/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 set = new HashSet<>(); + + // Create a queue and add root to it + Queue Q = new LinkedList(); + 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(); + } +} \ No newline at end of file diff --git a/data_structures/Trees/TreeTraversal.java b/data_structures/Trees/TreeTraversal.java index c4ff92d0..bd0f2f7f 100644 --- a/data_structures/Trees/TreeTraversal.java +++ b/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 - tree.printInOrder(); - System.out.println(); - - // Prints 5 3 7 + // Prints 5 3 2 4 7 6 8 + System.out.println("Pre order traversal:"); tree.printPreOrder(); System.out.println(); - - // Prints 3 7 5 + // Prints 2 3 4 5 6 7 8 + 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 - * Consists of all 3 traversal methods: printInOrder, printPostOrder & printPreOrder - * printInOrder: LEFT -> ROOT -> RIGHT - * printPreOrder: ROOT -> LEFT -> RIGHT - * printPostOrder: LEFT -> RIGHT -> ROOT - */ +* The Node class which initializes a Node of a tree +* Consists of all 3 traversal methods: printInOrder, printPostOrder & printPreOrder +* printInOrder: LEFT -> ROOT -> RIGHT +* printPreOrder: ROOT -> LEFT -> RIGHT +* 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 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); + } + } + } +} diff --git a/data_structures/Trees/Valid BST or not.java b/data_structures/Trees/Valid BST or not.java new file mode 100644 index 00000000..0f71a46a --- /dev/null +++ b/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"); + } +} \ No newline at end of file