mirror of
https://github.com/TheAlgorithms/Java.git
synced 2025-07-15 01:40:49 +08:00
docs: update the whole repository
* fix some bugs * delete duplicate files * format code
This commit is contained in:
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -1,108 +0,0 @@
|
||||
import java.util.ArrayList;
|
||||
import java.util.Comparator;
|
||||
import java.util.HashMap;
|
||||
|
||||
public class HEncoder {
|
||||
|
||||
public HashMap<Character, String> encoder = new HashMap<>(); // in order to encode
|
||||
public HashMap<String, Character> decoder = new HashMap<>(); // in order to decode
|
||||
|
||||
private static class Node {
|
||||
|
||||
Character ch;
|
||||
Integer freq;
|
||||
Node left;
|
||||
Node right;
|
||||
|
||||
public static final Nodecomparator Ctor = new Nodecomparator();
|
||||
|
||||
public static class Nodecomparator implements Comparator<Node> {
|
||||
|
||||
@Override
|
||||
public int compare(Node o1, Node o2) {
|
||||
return o2.freq - o1.freq;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
public HEncoder(String feeder) {
|
||||
// 1. freq map
|
||||
HashMap<Character, Integer> freqmap = new HashMap<>();
|
||||
for (int i = 0; i < feeder.length(); ++i) {
|
||||
char ch = feeder.charAt(i);
|
||||
if (freqmap.containsKey(ch)) {
|
||||
freqmap.put(ch, freqmap.get(ch) + 1);
|
||||
} else {
|
||||
freqmap.put(ch, 1);
|
||||
}
|
||||
}
|
||||
|
||||
// 2. prepare the heap from keyset
|
||||
genericheap<Node> heap = new genericheap<Node>(Node.Ctor);
|
||||
ArrayList<Character> k = new ArrayList<>(freqmap.keySet());
|
||||
for (Character c : k) {
|
||||
Node n = new Node();
|
||||
n.ch = c;
|
||||
n.left = null;
|
||||
n.right = null;
|
||||
n.freq = freqmap.get(c);
|
||||
heap.add(n);
|
||||
}
|
||||
|
||||
// 3.Prepare tree, remove two , merge, add it back
|
||||
Node fn = new Node();
|
||||
while (heap.size() != 1) {
|
||||
Node n1 = heap.removeHP();
|
||||
Node n2 = heap.removeHP();
|
||||
fn = new Node();
|
||||
|
||||
fn.freq = n1.freq + n2.freq;
|
||||
fn.left = n1;
|
||||
fn.right = n2;
|
||||
|
||||
heap.add(fn);
|
||||
}
|
||||
|
||||
// 4. traverse
|
||||
|
||||
traverse(heap.removeHP(), "");
|
||||
}
|
||||
|
||||
private void traverse(Node node, String osf) {
|
||||
|
||||
if (node.left == null && node.right == null) {
|
||||
encoder.put(node.ch, osf);
|
||||
decoder.put(osf, node.ch);
|
||||
return;
|
||||
}
|
||||
traverse(node.left, osf + "0");
|
||||
traverse(node.right, osf + "1");
|
||||
|
||||
}
|
||||
|
||||
// compression work done here
|
||||
public String compress(String str) {
|
||||
String rv = "";
|
||||
for (int i = 0; i < str.length(); ++i) {
|
||||
rv += encoder.get(str.charAt(i));
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
||||
//in order to decompress
|
||||
public String decompress(String str) {
|
||||
String s = "";
|
||||
String code = "";
|
||||
for (int i = 0; i < str.length(); ++i) {
|
||||
code += str.charAt(i);
|
||||
if (decoder.containsKey(code)) {
|
||||
s += decoder.get(code);
|
||||
code = "";
|
||||
}
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
}
|
@ -1,11 +0,0 @@
|
||||
|
||||
public class compressclient {
|
||||
|
||||
public static void main(String[] args) {
|
||||
|
||||
HEncoder h= new HEncoder("aaaabbbcccccccccccdddd");
|
||||
System.out.println(h.compress("aabccd"));
|
||||
System.out.println(h.decompress("101011000111"));
|
||||
}
|
||||
|
||||
}
|
@ -1,93 +0,0 @@
|
||||
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Comparator;
|
||||
|
||||
public class genericheap<T> { // create a generic heap class <T> , where T can be of any type.
|
||||
|
||||
private ArrayList<T> data = new ArrayList<>();
|
||||
private Comparator<T> ctor;
|
||||
|
||||
public genericheap(Comparator<T> ctor) { // constructor to initialize the generic comparator
|
||||
this.ctor=ctor;
|
||||
}
|
||||
|
||||
public int size() { // returns the size of the arraylist data
|
||||
return data.size();
|
||||
}
|
||||
|
||||
public boolean isEmpty() { // checks whether the list is empty or not :: return true or false for the same
|
||||
return data.isEmpty();
|
||||
}
|
||||
|
||||
public void display() { //displays the list
|
||||
System.out.println(this.data);
|
||||
}
|
||||
|
||||
public void add(T integer) { // in this function we have added the <t> type object into the arraylist and called upheapify
|
||||
data.add(integer);
|
||||
upheapify(data.size() - 1);
|
||||
}
|
||||
|
||||
private void upheapify(int ci) {
|
||||
if (ci == 0) {
|
||||
return;
|
||||
}
|
||||
int pi = (ci - 1) / 2;
|
||||
if (isLarger(ci,pi) == true) {
|
||||
swap(ci, pi);
|
||||
upheapify(pi);
|
||||
}
|
||||
}
|
||||
|
||||
private boolean isLarger(int i, int j) {
|
||||
T ith = data.get(i);
|
||||
T jth = data.get(j);
|
||||
if(ctor.compare(ith,jth)>0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private void swap(int ci, int pi) { // swap function written like this because of the generic property
|
||||
T ith = data.get(ci);
|
||||
T jth=data.get(pi);
|
||||
data.set(ci, jth);
|
||||
data.set(pi, ith);
|
||||
}
|
||||
|
||||
public T getHP() {
|
||||
return data.get(0);
|
||||
}
|
||||
|
||||
public T removeHP() {
|
||||
|
||||
swap(0, data.size() - 1);
|
||||
T rv=data.remove(data.size()-1);
|
||||
downheapify(0);
|
||||
return rv;
|
||||
}
|
||||
|
||||
private void downheapify(int pi) {
|
||||
int lci = 2 * pi + 1;
|
||||
int rci = 2 * pi + 2;
|
||||
|
||||
int max = pi;
|
||||
|
||||
if (lci < data.size() && isLarger(lci, max) == true) {
|
||||
max = lci;
|
||||
}
|
||||
if (rci < data.size() && isLarger(rci, max) == true) {
|
||||
max = rci;
|
||||
}
|
||||
if (max != pi) {
|
||||
swap(pi, max);
|
||||
downheapify(max);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
@ -1,3 +1,5 @@
|
||||
package Conversions;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.HashSet;
|
||||
import java.util.InputMismatchException;
|
||||
@ -10,7 +12,6 @@ import java.util.Scanner;
|
||||
*
|
||||
* @author Michael Rolland
|
||||
* @version 2017.10.10
|
||||
*
|
||||
*/
|
||||
public class AnyBaseToAnyBase {
|
||||
|
||||
@ -22,12 +23,12 @@ public class AnyBaseToAnyBase {
|
||||
public static void main(String[] args) {
|
||||
Scanner in = new Scanner(System.in);
|
||||
String n;
|
||||
int b1=0,b2=0;
|
||||
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+"): ");
|
||||
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!");
|
||||
@ -37,7 +38,7 @@ public class AnyBaseToAnyBase {
|
||||
System.out.println("The number is invalid for this base!");
|
||||
continue;
|
||||
}
|
||||
System.out.print("Enter end base (between "+MINIMUM_BASE+" and "+MAXIMUM_BASE+"): ");
|
||||
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!");
|
||||
@ -64,7 +65,7 @@ public class AnyBaseToAnyBase {
|
||||
|
||||
// Convert character array into set for convenience of contains() method
|
||||
HashSet<Character> digitsList = new HashSet();
|
||||
for (int i=0; i<digitsForBase.length; i++)
|
||||
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.
|
||||
@ -78,6 +79,7 @@ public class AnyBaseToAnyBase {
|
||||
/**
|
||||
* 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.
|
||||
@ -89,9 +91,9 @@ public class AnyBaseToAnyBase {
|
||||
// and the string that will be returned.
|
||||
int decimalValue = 0, charB2;
|
||||
char charB1;
|
||||
String output="";
|
||||
String output = "";
|
||||
// Go through every character of n
|
||||
for (int i=0; i<n.length(); i++) {
|
||||
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
|
||||
@ -121,7 +123,7 @@ public class AnyBaseToAnyBase {
|
||||
// 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;
|
||||
output = (char) ((decimalValue % b2) + 55) + output;
|
||||
// Divide by the new base again
|
||||
decimalValue /= b2;
|
||||
}
|
||||
|
@ -1,3 +1,5 @@
|
||||
package Conversions;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.InputStreamReader;
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
package Java.Conversions;
|
||||
package Conversions;
|
||||
|
||||
import java.util.Scanner;
|
||||
//given a source number , source base, destination base, this code can give you the destination number.
|
||||
|
@ -1,33 +1,30 @@
|
||||
package Conversions;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* This class converts a Binary number to a Decimal number
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class BinaryToDecimal
|
||||
{
|
||||
class BinaryToDecimal {
|
||||
|
||||
/**
|
||||
* Main Method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String args[])
|
||||
{
|
||||
Scanner sc=new Scanner(System.in);
|
||||
int n,k,d,s=0,c=0;
|
||||
public static void main(String args[]) {
|
||||
Scanner sc = new Scanner(System.in);
|
||||
int n, k, d, s = 0, c = 0;
|
||||
System.out.print("Binary number: ");
|
||||
n=sc.nextInt();
|
||||
k=n;
|
||||
while(k!=0)
|
||||
{
|
||||
d=k%10;
|
||||
s+=d*(int)Math.pow(2,c++);
|
||||
k/=10;
|
||||
n = sc.nextInt();
|
||||
k = n;
|
||||
while (k != 0) {
|
||||
d = k % 10;
|
||||
s += d * (int) Math.pow(2, c++);
|
||||
k /= 10;
|
||||
}
|
||||
System.out.println("Decimal equivalent:"+s);
|
||||
System.out.println("Decimal equivalent:" + s);
|
||||
sc.close();
|
||||
}
|
||||
}
|
||||
|
@ -1,9 +1,11 @@
|
||||
package Conversions;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Converts any Binary Number to a Hexadecimal Number
|
||||
*
|
||||
* @author Nishita Aggarwal
|
||||
*
|
||||
*/
|
||||
public class BinaryToHexadecimal {
|
||||
|
||||
@ -14,29 +16,25 @@ public class BinaryToHexadecimal {
|
||||
* @param binary The binary number
|
||||
* @return The hexadecimal number
|
||||
*/
|
||||
static String binToHex(int binary)
|
||||
{
|
||||
static String binToHex(int binary) {
|
||||
//hm to store hexadecimal codes for binary numbers within the range: 0000 to 1111 i.e. for decimal numbers 0 to 15
|
||||
HashMap<Integer,String> hm=new HashMap<>();
|
||||
HashMap<Integer, String> hm = new HashMap<>();
|
||||
//String to store hexadecimal code
|
||||
String hex="";
|
||||
String hex = "";
|
||||
int i;
|
||||
for(i=0 ; i<10 ; i++)
|
||||
{
|
||||
for (i = 0; i < 10; i++) {
|
||||
hm.put(i, String.valueOf(i));
|
||||
}
|
||||
for(i=10 ; i<16 ; i++) hm.put(i,String.valueOf((char)('A'+i-10)));
|
||||
for (i = 10; i < 16; i++) hm.put(i, String.valueOf((char) ('A' + i - 10)));
|
||||
int currbit;
|
||||
while(binary != 0)
|
||||
{
|
||||
while (binary != 0) {
|
||||
int code4 = 0; //to store decimal equivalent of number formed by 4 decimal digits
|
||||
for(i=0 ; i<4 ; i++)
|
||||
{
|
||||
for (i = 0; i < 4; i++) {
|
||||
currbit = binary % 10;
|
||||
binary = binary / 10;
|
||||
code4 += currbit * Math.pow(2, i);
|
||||
}
|
||||
hex= hm.get(code4) + hex;
|
||||
hex = hm.get(code4) + hex;
|
||||
}
|
||||
return hex;
|
||||
}
|
||||
|
@ -1,10 +1,11 @@
|
||||
package Conversions;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* Converts any Binary number to an Octal Number
|
||||
*
|
||||
* @author Zachary Jones
|
||||
*
|
||||
*/
|
||||
public class BinaryToOctal {
|
||||
|
||||
@ -29,9 +30,8 @@ public class BinaryToOctal {
|
||||
* @return The octal number
|
||||
*/
|
||||
public static int convertBinaryToOctal(int b) {
|
||||
int o = 0, r=0, j =1 ;
|
||||
while(b!=0)
|
||||
{
|
||||
int o = 0, r = 0, j = 1;
|
||||
while (b != 0) {
|
||||
r = b % 10;
|
||||
o = o + r * j;
|
||||
j = j * 2;
|
||||
|
@ -1,3 +1,5 @@
|
||||
package Conversions;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.InputStreamReader;
|
||||
import java.util.ArrayList;
|
||||
|
@ -1,10 +1,11 @@
|
||||
package Conversions;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* This class converts a Decimal number to a Binary number
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class DecimalToBinary {
|
||||
|
||||
|
@ -1,3 +1,4 @@
|
||||
package Conversions;
|
||||
|
||||
class DecimalToHexaDecimal {
|
||||
private static final int sizeOfIntInHalfBytes = 8;
|
||||
|
@ -1,33 +1,31 @@
|
||||
package Conversions;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* This class converts Decimal numbers to Octal Numbers
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Decimal_Octal
|
||||
{
|
||||
public class DecimalToOctal {
|
||||
/**
|
||||
* Main Method
|
||||
*
|
||||
* @param args Command line Arguments
|
||||
*/
|
||||
public static void main(String[] args)
|
||||
{
|
||||
Scanner sc=new Scanner(System.in);
|
||||
int n,k,d,s=0,c=0;
|
||||
public static void main(String[] args) {
|
||||
Scanner sc = new Scanner(System.in);
|
||||
int n, k, d, s = 0, c = 0;
|
||||
System.out.print("Decimal number: ");
|
||||
n=sc.nextInt();
|
||||
k=n;
|
||||
while(k!=0)
|
||||
{
|
||||
d=k%8;
|
||||
s+=d*(int)Math.pow(10,c++);
|
||||
k/=8;
|
||||
n = sc.nextInt();
|
||||
k = n;
|
||||
while (k != 0) {
|
||||
d = k % 8;
|
||||
s += d * (int) Math.pow(10, c++);
|
||||
k /= 8;
|
||||
}
|
||||
|
||||
System.out.println("Octal equivalent:"+s);
|
||||
System.out.println("Octal equivalent:" + s);
|
||||
sc.close();
|
||||
}
|
||||
}
|
||||
|
@ -1,73 +1,69 @@
|
||||
/**
|
||||
+ * Converts any Hexadecimal Number to Octal
|
||||
+ *
|
||||
+ * @author Tanmay Joshi
|
||||
+ *
|
||||
+ */
|
||||
package Conversions;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
public class HexToOct
|
||||
{
|
||||
/**
|
||||
* Converts any Hexadecimal Number to Octal
|
||||
*
|
||||
* @author Tanmay Joshi
|
||||
*/
|
||||
public class HexToOct {
|
||||
/**
|
||||
+ * This method converts a Hexadecimal number to
|
||||
+ * a decimal number
|
||||
+ *
|
||||
+ * @param The Hexadecimal Number
|
||||
+ * @return The Decimal number
|
||||
+ */
|
||||
public static int hex2decimal(String s)
|
||||
{
|
||||
* This method converts a Hexadecimal number to a decimal number
|
||||
*
|
||||
* @param s The Hexadecimal Number
|
||||
* @return The Decimal number
|
||||
*/
|
||||
public static int hex2decimal(String s) {
|
||||
String str = "0123456789ABCDEF";
|
||||
s = s.toUpperCase();
|
||||
int val = 0;
|
||||
for (int i = 0; i < s.length(); i++)
|
||||
{
|
||||
for (int i = 0; i < s.length(); i++) {
|
||||
char a = s.charAt(i);
|
||||
int n = str.indexOf(a);
|
||||
val = 16*val + n;
|
||||
val = 16 * val + n;
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
/**
|
||||
+ * This method converts a Decimal number to
|
||||
+ * a octal number
|
||||
+ *
|
||||
+ * @param The Decimal Number
|
||||
+ * @return The Octal number
|
||||
+ */
|
||||
public static int decimal2octal(int q)
|
||||
{
|
||||
* This method converts a Decimal number to a octal number
|
||||
*
|
||||
* @param q The Decimal Number
|
||||
* @return The Octal number
|
||||
*/
|
||||
public static int decimal2octal(int q) {
|
||||
int now;
|
||||
int i=1;
|
||||
int octnum=0;
|
||||
while(q>0)
|
||||
{
|
||||
now=q%8;
|
||||
octnum=(now*(int)(Math.pow(10,i)))+octnum;
|
||||
q/=8;
|
||||
int i = 1;
|
||||
int octnum = 0;
|
||||
while (q > 0) {
|
||||
now = q % 8;
|
||||
octnum = (now * (int) (Math.pow(10, i))) + octnum;
|
||||
q /= 8;
|
||||
i++;
|
||||
}
|
||||
octnum/=10;
|
||||
octnum /= 10;
|
||||
return octnum;
|
||||
}
|
||||
// Main method that gets the hex input from user and converts it into octal.
|
||||
public static void main(String args[])
|
||||
{
|
||||
|
||||
/**
|
||||
* Main method that gets the hex input from user and converts it into octal.
|
||||
* @param args arguments
|
||||
*/
|
||||
public static void main(String args[]) {
|
||||
String hexadecnum;
|
||||
int decnum,octalnum;
|
||||
int decnum, octalnum;
|
||||
Scanner scan = new Scanner(System.in);
|
||||
|
||||
System.out.print("Enter Hexadecimal Number : ");
|
||||
hexadecnum = scan.nextLine();
|
||||
|
||||
// first convert hexadecimal to decimal
|
||||
|
||||
decnum = hex2decimal(hexadecnum); //Pass the string to the hex2decimal function and get the decimal form in variable decnum
|
||||
|
||||
// convert decimal to octal
|
||||
octalnum=decimal2octal(decnum);
|
||||
System.out.println("Number in octal: "+octalnum);
|
||||
octalnum = decimal2octal(decnum);
|
||||
System.out.println("Number in octal: " + octalnum);
|
||||
|
||||
|
||||
}
|
||||
|
@ -1,3 +1,5 @@
|
||||
package Conversions;
|
||||
|
||||
public class HexaDecimalToBinary {
|
||||
|
||||
private final int LONG_BITS = 8;
|
||||
|
@ -5,22 +5,20 @@ import java.util.Scanner;
|
||||
public class HexaDecimalToDecimal {
|
||||
|
||||
// convert hexadecimal to decimal
|
||||
public static int getHexaToDec(String hex){
|
||||
public static int getHexaToDec(String hex) {
|
||||
String digits = "012345678910ABCDEFF";
|
||||
hex = hex.toUpperCase();
|
||||
int val = 0;
|
||||
for (int i = 0; i < hex.length(); i++)
|
||||
{
|
||||
for (int i = 0; i < hex.length(); i++) {
|
||||
int d = digits.indexOf(hex.charAt(i));
|
||||
val = 16*val + d;
|
||||
val = 16 * val + d;
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
// Main method gets the hexadecimal input from user and converts it into Decimal output.
|
||||
|
||||
public static void main(String args[])
|
||||
{
|
||||
public static void main(String args[]) {
|
||||
String hexa_Input;
|
||||
int dec_output;
|
||||
Scanner scan = new Scanner(System.in);
|
||||
@ -35,7 +33,7 @@ public class HexaDecimalToDecimal {
|
||||
Pass the string to the getHexaToDec function
|
||||
and it returns the decimal form in the variable dec_output.
|
||||
*/
|
||||
System.out.println("Number in Decimal: "+dec_output);
|
||||
System.out.println("Number in Decimal: " + dec_output);
|
||||
|
||||
|
||||
}
|
||||
|
@ -1,49 +0,0 @@
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* Converts any Octal number to a Binary number
|
||||
*
|
||||
* @author Zachary Jones
|
||||
*
|
||||
*/
|
||||
public class OctalToBinary {
|
||||
|
||||
/**
|
||||
* Main method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String args[]) {
|
||||
Scanner sc = new Scanner(System.in);
|
||||
int o = sc.nextInt();
|
||||
System.out.println("Binary equivalent: " + convertOctalToBinary(o));
|
||||
sc.close();
|
||||
}
|
||||
|
||||
/**
|
||||
* This method converts an octal number
|
||||
* to a binary number.
|
||||
*
|
||||
* @param o The octal number
|
||||
* @return The binary number
|
||||
*/
|
||||
public static int convertOctalToBinary(int o) {
|
||||
Scanner scan;
|
||||
int num;
|
||||
|
||||
void getVal() {
|
||||
|
||||
System.out.println("Octal to Binary");
|
||||
scan = new Scanner(System.in);
|
||||
// Entering the needed number
|
||||
System.out.println("\nEnter the number : ");
|
||||
num = Integer.parseInt(scan.nextLine(), 8);
|
||||
}
|
||||
|
||||
void convert() {
|
||||
|
||||
String binary = Integer.toBinaryString(num);
|
||||
System.out.println("Binary Value is : " + binary);
|
||||
}
|
||||
}
|
||||
}
|
@ -1,3 +1,5 @@
|
||||
package Conversions;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
|
@ -1,42 +1,38 @@
|
||||
/**
|
||||
+ + * Converts any Octal Number to HexaDecimal
|
||||
+ + *
|
||||
+ + * @author Tanmay Joshi
|
||||
+ + *
|
||||
+ + *
|
||||
**/
|
||||
package Conversions;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* Converts any Octal Number to HexaDecimal
|
||||
*
|
||||
* @author Tanmay Joshi
|
||||
*/
|
||||
public class OctalToHexadecimal {
|
||||
|
||||
/**
|
||||
+ + * This method converts a Octal number to
|
||||
+ + * a decimal number
|
||||
+ + *
|
||||
+ + * @param The Octal Number
|
||||
+ + * @return The Decimal number
|
||||
+ + */
|
||||
public static int OctToDec(String s)
|
||||
{
|
||||
int i =0;
|
||||
for(int j =0;j<s.length();j++)
|
||||
{
|
||||
* This method converts a Octal number to a decimal number
|
||||
*
|
||||
* @param s The Octal Number
|
||||
* @return The Decimal number
|
||||
*/
|
||||
public static int OctToDec(String s) {
|
||||
int i = 0;
|
||||
for (int j = 0; j < s.length(); j++) {
|
||||
char num = s.charAt(j);
|
||||
num-='0';
|
||||
i*=8;
|
||||
i+=num;
|
||||
num -= '0';
|
||||
i *= 8;
|
||||
i += num;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
+ + * This method converts a Decimal number to
|
||||
+ + * a Hexadecimal number
|
||||
+ + *
|
||||
+ + * @param The Decimal Number
|
||||
+ + * @return The Hexadecimal number
|
||||
+ + */
|
||||
public static String DecimalToHex(int d) {
|
||||
/**
|
||||
* This method converts a Decimal number to a Hexadecimal number
|
||||
*
|
||||
* @param d The Decimal Number
|
||||
* @return The Hexadecimal number
|
||||
*/
|
||||
public static String DecimalToHex(int d) {
|
||||
String digits = "0123456789ABCDEF";
|
||||
if (d <= 0)
|
||||
return "0";
|
||||
@ -47,17 +43,22 @@ public static String DecimalToHex(int d) {
|
||||
d = d / 16;
|
||||
}
|
||||
return hex;
|
||||
}
|
||||
}
|
||||
|
||||
//Driver Program
|
||||
public static void main ( String args[]) {
|
||||
|
||||
public static void main(String args[]) {
|
||||
|
||||
Scanner input = new Scanner(System.in);
|
||||
System.out.print("Enter the Octal number: ");
|
||||
String oct = input.next(); //Take octal number as input from user in a string
|
||||
int decimal = OctToDec(oct); //Pass the octal number to function and get converted deciaml form
|
||||
String hex = DecimalToHex(decimal); //Pass the decimla number to function and get converted Hex form of the number
|
||||
System.out.println("The Hexadecimal equivalant is: "+hex);
|
||||
// Take octal number as input from user in a string
|
||||
String oct = input.next();
|
||||
|
||||
// Pass the octal number to function and get converted deciaml form
|
||||
int decimal = OctToDec(oct);
|
||||
|
||||
// Pass the decimla number to function and get converted Hex form of the number
|
||||
String hex = DecimalToHex(decimal);
|
||||
System.out.println("The Hexadecimal equivalant is: " + hex);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,8 +1,10 @@
|
||||
package Conversions;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
public class RomanToInteger {
|
||||
|
||||
private static Map<Character, Integer> map = new HashMap<>() {{
|
||||
private static Map<Character, Integer> map = new HashMap<Character, Integer>() {{
|
||||
put('I', 1);
|
||||
put('V', 5);
|
||||
put('X', 10);
|
||||
|
@ -1,4 +1,4 @@
|
||||
package Bags;
|
||||
package DataStructures.Bags;
|
||||
|
||||
import java.util.Iterator;
|
||||
import java.util.NoSuchElementException;
|
||||
@ -59,7 +59,7 @@ public class Bag<Element> implements Iterable<Element> {
|
||||
*/
|
||||
public boolean contains(Element element) {
|
||||
Iterator<Element> iterator = this.iterator();
|
||||
while(iterator.hasNext()) {
|
||||
while (iterator.hasNext()) {
|
||||
if (iterator.next().equals(element)) {
|
||||
return true;
|
||||
}
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Buffers;
|
||||
|
||||
import java.util.Random;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
@ -9,7 +11,7 @@ public class CircularBuffer {
|
||||
private AtomicInteger _readable_data = new AtomicInteger(0);
|
||||
|
||||
public CircularBuffer(int buffer_size) {
|
||||
if(!IsPowerOfTwo(buffer_size)) {
|
||||
if (!IsPowerOfTwo(buffer_size)) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
this._buffer_size = buffer_size;
|
||||
@ -28,7 +30,7 @@ public class CircularBuffer {
|
||||
Character result = null;
|
||||
|
||||
//if we have data to read
|
||||
if(_readable_data.get() > 0) {
|
||||
if (_readable_data.get() > 0) {
|
||||
result = new Character(_buffer[getTrueIndex(_read_index)]);
|
||||
_readable_data.decrementAndGet();
|
||||
_read_index++;
|
||||
@ -41,7 +43,7 @@ public class CircularBuffer {
|
||||
boolean result = false;
|
||||
|
||||
//if we can write to the buffer
|
||||
if(_readable_data.get() < _buffer_size) {
|
||||
if (_readable_data.get() < _buffer_size) {
|
||||
//write to buffer
|
||||
_buffer[getTrueIndex(_write_index)] = c;
|
||||
_readable_data.incrementAndGet();
|
||||
@ -56,6 +58,7 @@ public class CircularBuffer {
|
||||
String _alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
|
||||
Random _random = new Random();
|
||||
CircularBuffer _buffer;
|
||||
|
||||
public TestWriteWorker(CircularBuffer cb) {
|
||||
this._buffer = cb;
|
||||
}
|
||||
@ -65,10 +68,10 @@ public class CircularBuffer {
|
||||
}
|
||||
|
||||
public void run() {
|
||||
while(!Thread.interrupted()) {
|
||||
if(!_buffer.writeToCharBuffer(getRandomChar())){
|
||||
while (!Thread.interrupted()) {
|
||||
if (!_buffer.writeToCharBuffer(getRandomChar())) {
|
||||
Thread.yield();
|
||||
try{
|
||||
try {
|
||||
Thread.sleep(10);
|
||||
} catch (InterruptedException e) {
|
||||
return;
|
||||
@ -80,15 +83,17 @@ public class CircularBuffer {
|
||||
|
||||
private static class TestReadWorker implements Runnable {
|
||||
CircularBuffer _buffer;
|
||||
|
||||
public TestReadWorker(CircularBuffer cb) {
|
||||
this._buffer = cb;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
System.out.println("Printing Buffer:");
|
||||
while(!Thread.interrupted()) {
|
||||
while (!Thread.interrupted()) {
|
||||
Character c = _buffer.readOutChar();
|
||||
if(c != null) {
|
||||
if (c != null) {
|
||||
System.out.print(c.charValue());
|
||||
} else {
|
||||
Thread.yield();
|
||||
|
@ -1,692 +0,0 @@
|
||||
/*
|
||||
* author: Christian Bender
|
||||
* class: CSVFile
|
||||
*
|
||||
* This class implements a data structure for handling of
|
||||
* CSV-files.
|
||||
*
|
||||
* Overview
|
||||
*
|
||||
* CSVFile(path : string, seperator : char)
|
||||
* compiles the CSV-file in the inner data structure.
|
||||
*
|
||||
* CSVFile (file : File, seperator : char)
|
||||
* CSVFile (seperator : char)
|
||||
*
|
||||
* compile (row : string, seperator : char) : string
|
||||
* compiles row in its columns.
|
||||
*
|
||||
* isPunctuation (ch : char) : boolean
|
||||
* check whether ch is a punctuation character.
|
||||
*
|
||||
* getElementString(row : int, column : int) : string
|
||||
* returns the specified element.
|
||||
*
|
||||
* getElementDouble(row : int, column : int) : double
|
||||
* returns the specified element as double.
|
||||
*
|
||||
* addRow(row : string) : void
|
||||
* adds a row to the inner data structure.
|
||||
* without writing into the CSV-file.
|
||||
*
|
||||
* set (row : int, column : int, item : string) : void
|
||||
* replaces the specified item with a newer.
|
||||
*
|
||||
* commit() : void
|
||||
* writes the added data into CSV-file.
|
||||
*
|
||||
* commit(path : String) : void
|
||||
* commit(file : File ) : void
|
||||
*
|
||||
* findRow(key : string) : ArrayList<String>
|
||||
* returns the searched row otherwise null.
|
||||
*
|
||||
* contains(key : string) : boolean
|
||||
* returns true if a row contains 'key' otherwise false.
|
||||
*
|
||||
* getColumn(column : int) : ArrayList<String>
|
||||
* returns the specified column as ArrayList.
|
||||
*
|
||||
* getColumn(key : string) : ArrayList<String>
|
||||
*
|
||||
* removeRow(key : string) : void
|
||||
* purpose removes the specified row at the inner data structure.
|
||||
*
|
||||
* removeRow(column : int) : void
|
||||
*
|
||||
* updateFile() : void
|
||||
* overwrites the CSV-file with the current inner data structure.
|
||||
* removed rows are remove in the CSV-file, too.
|
||||
*
|
||||
* updateFile(file : File) : void
|
||||
*
|
||||
* getNumberOfRows() : int
|
||||
* returns the number of rows in CSV-File
|
||||
* it counts only rows that in the table.
|
||||
*
|
||||
*/
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.BufferedWriter;
|
||||
import java.io.File;
|
||||
import java.io.FileReader;
|
||||
import java.io.FileWriter;
|
||||
import java.io.IOException;
|
||||
import java.io.PrintWriter;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Paths;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
public class CSVFile {
|
||||
|
||||
// the actual CSV-content
|
||||
private ArrayList<ArrayList<String>> table;
|
||||
// to tracking added rows.
|
||||
private ArrayList<Integer> trackList;
|
||||
// notice the seperator
|
||||
private char seperator;
|
||||
// notice the path of the CSV-File.
|
||||
private String pathCSVFile;
|
||||
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* @param path
|
||||
* @param seperator
|
||||
* @purpose loads the CSV-file and fills the inner table with the data
|
||||
*/
|
||||
public CSVFile(String path, char seperator) {
|
||||
this(new File(path),seperator);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param file
|
||||
* same constructor different arguments.
|
||||
*/
|
||||
public CSVFile(File file, char seperator) {
|
||||
table = new ArrayList<ArrayList<String>>();
|
||||
trackList = new ArrayList<Integer>();
|
||||
pathCSVFile = file.getPath();
|
||||
this.seperator = seperator;
|
||||
ArrayList<String> colums = new ArrayList<String>();
|
||||
if (!file.canRead() || !file.isFile()) {
|
||||
System.out.println("unable to open file");
|
||||
System.exit(1);
|
||||
}
|
||||
|
||||
try (BufferedReader br = Files.newBufferedReader(Paths.get(file.getAbsolutePath()))) {
|
||||
br.lines().forEach(line -> table.add(compile(line, seperator)));
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param separator
|
||||
* @purpose Constructor for empty CSV-File.
|
||||
*/
|
||||
public CSVFile(char separator) {
|
||||
table = new ArrayList<ArrayList<String>>();
|
||||
trackList = new ArrayList<Integer>();
|
||||
pathCSVFile = "";
|
||||
this.seperator = separator;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param row
|
||||
* @param sep
|
||||
* the seperator
|
||||
* @return ArrayList<String> that contains each column of row.
|
||||
* @purpose compiles row in its columns.
|
||||
*
|
||||
*/
|
||||
public static ArrayList<String> compile(String row, char sep) {
|
||||
ArrayList<String> columns = new ArrayList<String>();
|
||||
int state = 0;
|
||||
char ch = ' ';
|
||||
String column = "";
|
||||
int countQuotes = 0;
|
||||
for (int i = 0; i < row.length(); i++) {
|
||||
// fetch next character
|
||||
ch = row.charAt(i);
|
||||
switch (state) {
|
||||
|
||||
// state 0
|
||||
case 0:
|
||||
if (Character.isLetter(ch) || Character.isDigit(ch)) {
|
||||
state = 1;
|
||||
column += ch;
|
||||
} else if (ch == '"') { // catch "
|
||||
state = 2;
|
||||
column += ch;
|
||||
} else if (Character.isWhitespace(ch)) {
|
||||
state = 0;
|
||||
}
|
||||
break;
|
||||
// state 1
|
||||
case 1:
|
||||
if ((Character.isLetter(ch) || Character.isDigit(ch)
|
||||
|| isPunctuation(ch) || Character.isWhitespace(ch))
|
||||
&& (ch != sep)) {
|
||||
state = 1;
|
||||
column += ch;
|
||||
} else if (ch == sep || ch == '\n') {
|
||||
state = 0;
|
||||
column = column.trim();
|
||||
columns.add(column);
|
||||
column = "";
|
||||
} else { // error case
|
||||
throw new RuntimeException("compile: invalid"
|
||||
+ " character " + ch);
|
||||
}
|
||||
break;
|
||||
|
||||
// state 2
|
||||
case 2:
|
||||
if ((Character.isLetter(ch) || Character.isDigit(ch)
|
||||
|| Character.isWhitespace(ch) || isPunctuation(ch))
|
||||
&& (ch != '"')) {
|
||||
state = 2;
|
||||
column += ch;
|
||||
} else if (ch == '"') {
|
||||
state = 3;
|
||||
column += ch;
|
||||
} else { // error case
|
||||
throw new RuntimeException("compile: invalid"
|
||||
+ " character " + ch);
|
||||
}
|
||||
break;
|
||||
|
||||
// state 3
|
||||
case 3:
|
||||
if ((Character.isLetter(ch) || Character.isDigit(ch)
|
||||
|| Character.isWhitespace(ch) || isPunctuation(ch))
|
||||
&& (ch != '"') && (ch != sep)) {
|
||||
state = 2;
|
||||
column += ch;
|
||||
} else if (ch == ',') {
|
||||
state = 0;
|
||||
column = column.trim();
|
||||
columns.add(column);
|
||||
column = "";
|
||||
} else { // error case
|
||||
throw new RuntimeException("compile: invalid"
|
||||
+ " character " + ch);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
// for adding the remaining column
|
||||
columns.add(column);
|
||||
column = "";
|
||||
return columns;
|
||||
}
|
||||
|
||||
private static Pattern PATTERN_PUNCTUATION = Pattern.compile("\\p{Punct}");
|
||||
/**
|
||||
*
|
||||
* @param ch
|
||||
* @returns true if ch is punctuation character otherwise false.
|
||||
*/
|
||||
public static boolean isPunctuation(char ch) {
|
||||
return PATTERN_PUNCTUATION.matcher("" + ch).matches();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param row
|
||||
* @param column
|
||||
* @return the specific element as string
|
||||
*/
|
||||
public String getElementString(int row, int column) {
|
||||
// check arguments
|
||||
if (row < table.size() && column < table.get(0).size()) {
|
||||
return table.get(row).get(column);
|
||||
} else { // error case
|
||||
throw new RuntimeException("getElementString: "
|
||||
+ " arguments out of bound.");
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param row
|
||||
* @param column
|
||||
* @return the specific element as double
|
||||
* @throws NumberFormatException
|
||||
*/
|
||||
public double getElementDouble(int row, int column)
|
||||
throws NumberFormatException {
|
||||
// check arguments
|
||||
if (row < table.size() && column < table.get(0).size()) {
|
||||
return Double.parseDouble(table.get(row).get(column));
|
||||
} else { // error case
|
||||
throw new RuntimeException("getElementString: "
|
||||
+ " arguments out of bound.");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param row
|
||||
* @purpose adds a row to the inner data structure.
|
||||
* without writing into the CSV-file.
|
||||
*/
|
||||
public void addRow(String row) {
|
||||
table.add(compile(row, seperator));
|
||||
// tracking the last item.
|
||||
trackList.add(table.size() - 1);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @purpose: writes the added data into CSV-file.
|
||||
*/
|
||||
public void commit() {
|
||||
String row = "";
|
||||
PrintWriter pWriter = null;
|
||||
try {
|
||||
pWriter = new PrintWriter(new BufferedWriter(new FileWriter(
|
||||
pathCSVFile, true)));
|
||||
|
||||
// writes the tracked rows into CSV-file.
|
||||
for (int index : trackList) {
|
||||
for (int i = 0; i < table.get(index).size(); i++) {
|
||||
if (i != 0) {
|
||||
row += ",";
|
||||
row += table.get(index).get(i);
|
||||
} else {
|
||||
row += table.get(index).get(i);
|
||||
}
|
||||
}
|
||||
// add newline for next row
|
||||
row += "\n";
|
||||
pWriter.write(row);
|
||||
// clear row for the next one
|
||||
row = "";
|
||||
}
|
||||
} catch (IOException ioe) {
|
||||
ioe.printStackTrace();
|
||||
} finally {
|
||||
if (pWriter != null) {
|
||||
pWriter.flush();
|
||||
pWriter.close();
|
||||
}
|
||||
}
|
||||
|
||||
// remove tracked rows.
|
||||
trackList.clear();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @param path
|
||||
* @purpose: writes the added data into CSV-file (given path).
|
||||
*/
|
||||
public void commit(String path) {
|
||||
String row = "";
|
||||
pathCSVFile = path;
|
||||
PrintWriter pWriter = null;
|
||||
try {
|
||||
|
||||
pWriter = new PrintWriter(new BufferedWriter(new FileWriter(
|
||||
pathCSVFile, true)));
|
||||
|
||||
// writes the tracked rows into CSV-file.
|
||||
for (int index : trackList) {
|
||||
for (int i = 0; i < table.get(index).size(); i++) {
|
||||
if (i != 0) {
|
||||
row += ",";
|
||||
row += table.get(index).get(i);
|
||||
} else {
|
||||
row += table.get(index).get(i);
|
||||
}
|
||||
}
|
||||
// add newline for next row
|
||||
row += "\n";
|
||||
pWriter.write(row);
|
||||
// clear row
|
||||
row = "";
|
||||
}
|
||||
} catch (IOException ioe) {
|
||||
ioe.printStackTrace();
|
||||
} finally {
|
||||
if (pWriter != null) {
|
||||
pWriter.flush();
|
||||
pWriter.close();
|
||||
}
|
||||
}
|
||||
|
||||
// remove tracked rows.
|
||||
trackList.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param file
|
||||
* @purpose: writes the added data into CSV-file (given path).
|
||||
*/
|
||||
public void commit(File file) {
|
||||
String row = "";
|
||||
pathCSVFile = file.getPath();
|
||||
PrintWriter pWriter = null;
|
||||
try {
|
||||
|
||||
pWriter = new PrintWriter(new BufferedWriter(new FileWriter(
|
||||
file, true)));
|
||||
|
||||
// writes the tracked rows into CSV-file.
|
||||
for (int index : trackList) {
|
||||
for (int i = 0; i < table.get(index).size(); i++) {
|
||||
if (i != 0) {
|
||||
row += ",";
|
||||
row += table.get(index).get(i);
|
||||
} else {
|
||||
row += table.get(index).get(i);
|
||||
}
|
||||
}
|
||||
// add newline for next row
|
||||
row += "\n";
|
||||
pWriter.write(row);
|
||||
// clear row
|
||||
row = "";
|
||||
}
|
||||
} catch (IOException ioe) {
|
||||
ioe.printStackTrace();
|
||||
} finally {
|
||||
if (pWriter != null) {
|
||||
pWriter.flush();
|
||||
pWriter.close();
|
||||
}
|
||||
}
|
||||
|
||||
// remove tracked rows.
|
||||
trackList.clear();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key
|
||||
* @returns the searched row otherwise null.
|
||||
*/
|
||||
public ArrayList<String> findRow(String key) {
|
||||
ArrayList<String> ans = null;
|
||||
key = key.trim();
|
||||
for (int i = 0; i < table.size(); i++) {
|
||||
for (String item : table.get(i)) {
|
||||
item = item.trim();
|
||||
if (item.equals(key)) {
|
||||
ans = table.get(i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key
|
||||
* @returns true if a row contains 'key' otherwise false.
|
||||
*/
|
||||
public boolean contains(String key) {
|
||||
key = key.trim();
|
||||
for (int i = 0; i < table.size(); i++) {
|
||||
for (String item : table.get(i)) {
|
||||
item = item.trim();
|
||||
if (item.equals(key)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param n of type integer
|
||||
* @returns the specified column as ArrayList.
|
||||
*/
|
||||
public ArrayList<String> getColumn(int column) {
|
||||
ArrayList<String> ans = new ArrayList<String>();
|
||||
if (column < table.get(0).size()) {
|
||||
for (int i = 0; i < table.size(); i++) {
|
||||
ans.add(table.get(i).get(column));
|
||||
}
|
||||
} else { // error case
|
||||
throw new RuntimeException("getColumn: column is too large");
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param label of type string
|
||||
* @returns the specified column at label.
|
||||
*/
|
||||
public ArrayList<String> getColumn(String label) {
|
||||
ArrayList<String> ans = new ArrayList<String>();
|
||||
int n = table.get(0).indexOf(label);
|
||||
// check whether label exists.
|
||||
if (n != -1) {
|
||||
for (int i = 1; i < table.size(); i++) {
|
||||
ans.add(table.get(i).get(n));
|
||||
}
|
||||
} else { // error case
|
||||
throw new RuntimeException("getColumn: label " + label
|
||||
+ " don't exists.");
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param key of type string
|
||||
* @purpose removes the specified row at the inner data structure.
|
||||
*/
|
||||
public void removeRow(String key) {
|
||||
for (int i = 0; i < table.size(); i++) {
|
||||
if (table.get(i) != null) {
|
||||
for (String item : table.get(i)) {
|
||||
if (item.equals(key)) {
|
||||
table.set(i,null);
|
||||
// updates the track list
|
||||
if (trackList.indexOf(i) != -1) {
|
||||
trackList.remove(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// removes all null-elements
|
||||
table.removeAll(Collections.singleton(null));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param n of type integer
|
||||
* @purpose removes the specified row at the inner data structure.
|
||||
*/
|
||||
public void removeRow(int column) {
|
||||
if (column < table.size()) {
|
||||
table.set(column, null);
|
||||
// removes all null-elements
|
||||
table.removeAll(Collections.singleton(null));
|
||||
// updates the track list
|
||||
if (trackList.indexOf(column) != -1) {
|
||||
trackList.remove(column);
|
||||
}
|
||||
} else {
|
||||
throw new RuntimeException("removeRow: column is too large");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* overwrites the CSV-file with the current inner data structure.
|
||||
* removed rows are remove in the CSV-file, too.
|
||||
*/
|
||||
public void updateFile() {
|
||||
String row = "";
|
||||
PrintWriter pWriter = null;
|
||||
try {
|
||||
pWriter = new PrintWriter(new BufferedWriter(new FileWriter(
|
||||
pathCSVFile)));
|
||||
|
||||
// writes the table rows into CSV-file.
|
||||
for (int i = 0; i < table.size(); i++) {
|
||||
for (int j = 0; j < table.get(i).size(); j++) {
|
||||
if (j != 0) {
|
||||
row += ",";
|
||||
row += table.get(i).get(j);
|
||||
} else {
|
||||
row += table.get(i).get(j);
|
||||
}
|
||||
}
|
||||
// add newline for next row
|
||||
row += "\n";
|
||||
pWriter.write(row);
|
||||
// clear row
|
||||
row = "";
|
||||
}
|
||||
|
||||
// writes the tracked rows into CSV-file.
|
||||
for (int index : trackList) {
|
||||
for (int i = 0; i < table.get(index).size(); i++) {
|
||||
if (i != 0) {
|
||||
row += ",";
|
||||
row += table.get(index).get(i);
|
||||
} else {
|
||||
row += table.get(index).get(i);
|
||||
}
|
||||
}
|
||||
// add newline for next row
|
||||
row += "\n";
|
||||
pWriter.write(row);
|
||||
// clear row for the next one
|
||||
row = "";
|
||||
}
|
||||
} catch (IOException ioe) {
|
||||
ioe.printStackTrace();
|
||||
} finally {
|
||||
if (pWriter != null) {
|
||||
pWriter.flush();
|
||||
pWriter.close();
|
||||
}
|
||||
}
|
||||
|
||||
// remove tracked rows.
|
||||
trackList.clear();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param file
|
||||
* overwrites the CSV-file with the current inner data structure.
|
||||
* removed rows are remove in the CSV-file, too.
|
||||
*/
|
||||
public void updateFile(File file) {
|
||||
String row = "";
|
||||
PrintWriter pWriter = null;
|
||||
try {
|
||||
pWriter = new PrintWriter(new BufferedWriter(new FileWriter(
|
||||
file)));
|
||||
|
||||
// writes the table rows into CSV-file.
|
||||
for (int i = 0; i < table.size(); i++) {
|
||||
for (int j = 0; j < table.get(i).size(); j++) {
|
||||
if (j != 0) {
|
||||
row += ",";
|
||||
row += table.get(i).get(j);
|
||||
} else {
|
||||
row += table.get(i).get(j);
|
||||
}
|
||||
}
|
||||
// add newline for next row
|
||||
row += "\n";
|
||||
pWriter.write(row);
|
||||
// clear row
|
||||
row = "";
|
||||
}
|
||||
|
||||
// writes the tracked rows into CSV-file.
|
||||
for (int index : trackList) {
|
||||
for (int i = 0; i < table.get(index).size(); i++) {
|
||||
if (i != 0) {
|
||||
row += ",";
|
||||
row += table.get(index).get(i);
|
||||
} else {
|
||||
row += table.get(index).get(i);
|
||||
}
|
||||
}
|
||||
// add newline for next row
|
||||
row += "\n";
|
||||
pWriter.write(row);
|
||||
// clear row
|
||||
row = "";
|
||||
}
|
||||
} catch (IOException ioe) {
|
||||
ioe.printStackTrace();
|
||||
} finally {
|
||||
if (pWriter != null) {
|
||||
pWriter.flush();
|
||||
pWriter.close();
|
||||
}
|
||||
}
|
||||
|
||||
// remove tracked rows.
|
||||
trackList.clear();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @returns the number of rows in CSV-File
|
||||
* it counts only rows that in the table.
|
||||
*/
|
||||
public int getNumberOfRows() {
|
||||
return table.size();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param row
|
||||
* @param column
|
||||
* @param item
|
||||
* @purpose replaces the specified item with a newer.
|
||||
*/
|
||||
public void set(int row, int column, String item) {
|
||||
if (row < table.size()) {
|
||||
if (column < table.get(row).size()) {
|
||||
table.get(row).set(column, item);
|
||||
} else {
|
||||
throw new RuntimeException("set: column is too large!");
|
||||
}
|
||||
} else {
|
||||
throw new RuntimeException("set: row is too large!");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
@ -1,133 +0,0 @@
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.ArrayList;
|
||||
|
||||
public class TestCSVFile {
|
||||
|
||||
|
||||
@Test
|
||||
public void testConstructor1() {
|
||||
CSVFile testObj = new CSVFile("testData.csv",',');
|
||||
assertEquals(testObj.getElementDouble(1, 1),65.78331, 0.001);
|
||||
assertEquals(testObj.getElementString(1, 1),"65.78331");
|
||||
assertEquals(testObj.getElementString(0, 1),"\"Height(Inches)\"");
|
||||
assertEquals(testObj.getNumberOfRows(),25029);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConstructor2() {
|
||||
CSVFile testObj = new CSVFile(',');
|
||||
testObj.addRow("1, 65.78331, 112.9925");
|
||||
testObj.addRow("12, 67.62333, 114.143");
|
||||
testObj.addRow("6, 68.69784, 123.3024");
|
||||
// testObj.commit("testData2.csv");
|
||||
// testObj.commit(new File("testData2.csv"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConstructor3() {
|
||||
CSVFile testObj = new CSVFile(new File("testData.csv"),',');
|
||||
assertEquals(testObj.getElementDouble(1, 1),65.78331, 0.001);
|
||||
assertEquals(testObj.getElementString(1, 1),"65.78331");
|
||||
assertEquals(testObj.getElementString(0, 1),"\"Height(Inches)\"");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsPunctuation() {
|
||||
assertTrue(CSVFile.isPunctuation(':'));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCompile() {
|
||||
ArrayList<String> columns = new ArrayList<String>();
|
||||
columns.add("2");
|
||||
columns.add("71.51521");
|
||||
columns.add("136.4873");
|
||||
|
||||
|
||||
assertEquals(CSVFile.compile("2, 71.51521, 136.4873", ','),columns);
|
||||
columns.clear();
|
||||
|
||||
// test successful
|
||||
columns.add("\"Index\"");
|
||||
columns.add("\"Height(Inches)\"");
|
||||
columns.add("\"Weight(Pounds)\"");
|
||||
|
||||
assertEquals(CSVFile.compile("\"Index\", \"Height(Inches)\", "
|
||||
+ "\"Weight(Pounds)\"", ','),columns);
|
||||
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAddRowCommit() {
|
||||
// CSVFile testObj = new CSVFile("testData.csv",',');
|
||||
// testObj.addRow("1,1,1");
|
||||
// testObj.addRow("1,2,3");
|
||||
// testObj.commit();
|
||||
// test successful
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindRow() {
|
||||
CSVFile testObj = new CSVFile("testData.csv",',');
|
||||
ArrayList<String> columns = new ArrayList<String>();
|
||||
columns.add("2");
|
||||
columns.add("71.51521");
|
||||
columns.add("136.4873");
|
||||
assertEquals(testObj.findRow("71.51521"),columns);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testContains() {
|
||||
CSVFile testObj = new CSVFile("testData.csv",',');
|
||||
ArrayList<String> columns = new ArrayList<String>();
|
||||
columns.add("2");
|
||||
columns.add("71.51521");
|
||||
columns.add("136.4873");
|
||||
assertTrue(testObj.contains("71.51521"));
|
||||
assertFalse(testObj.contains("9889678"));
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testGetColumn() {
|
||||
CSVFile testObj = new CSVFile("testData2.csv",',');
|
||||
CSVFile testObj2 = new CSVFile("testData3.csv",',');
|
||||
ArrayList<String> columns = new ArrayList<String>();
|
||||
columns.add("height");
|
||||
columns.add("65.78331");
|
||||
columns.add("67.62333");
|
||||
assertEquals(testObj.getColumn(1),columns);
|
||||
columns.clear();
|
||||
columns.add("65.78331");
|
||||
columns.add("67.62333");
|
||||
assertEquals(testObj.getColumn("height"),columns);
|
||||
columns.clear();
|
||||
assertEquals(testObj2.getColumn("height"),columns);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testRemoving() {
|
||||
CSVFile testObj = new CSVFile("testData4.csv",',');
|
||||
//testObj.removeRow("68.69784");
|
||||
// testObj.removeRow(0);
|
||||
// testObj.updateFile(new File("testData4.csv"));
|
||||
// test successful
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSet() {
|
||||
// CSVFile testObj = new CSVFile("testData4.csv",',');
|
||||
// testObj.set(6, 2, "80");
|
||||
// testObj.updateFile();
|
||||
// test succesfull
|
||||
}
|
||||
|
||||
|
||||
}
|
File diff suppressed because it is too large
Load Diff
@ -1,3 +0,0 @@
|
||||
id, height, width
|
||||
1, 65.78331, 112.9925
|
||||
12, 67.62333, 114.143
|
|
@ -1 +0,0 @@
|
||||
id, height, width
|
|
@ -1,7 +0,0 @@
|
||||
1,65.78331,112.9925
|
||||
2,71.51521,136.4873
|
||||
3,69.39874,153.0269
|
||||
4,68.2166,142.3354
|
||||
5,67.78781,144.2971
|
||||
7,69.80204,141.4947
|
||||
8,70.01472,80
|
|
@ -1,62 +0,0 @@
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Implementation of a Breadth First Search
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
public class BFS{
|
||||
|
||||
/**
|
||||
* The BFS implemented in code to use.
|
||||
*
|
||||
* @param a Structure to perform the search on a graph, adjacency matrix etc.
|
||||
* @param vertices The vertices to use
|
||||
* @param source The Source
|
||||
*/
|
||||
public static void bfsImplement(byte [][] a,int vertices,int source){ //passing adjacency matrix and no of vertices
|
||||
byte []b=new byte[vertices]; //flag container containing status of each vertices
|
||||
Arrays.fill(b,(byte)-1); //status initialization
|
||||
/* code status
|
||||
-1 = ready
|
||||
0 = waiting
|
||||
1 = processed */
|
||||
|
||||
Stack st = new Stack(vertices); //operational stack
|
||||
st.push(source); //assigning source
|
||||
while(!st.isEmpty()){
|
||||
b[st.peek()]=(byte)0; //assigning waiting status
|
||||
System.out.println(st.peek());
|
||||
int pop=st.peek();
|
||||
b[pop]=(byte)1; //assigning processed status
|
||||
st.pop(); //removing head of the queue
|
||||
for(int i=0;i<vertices;i++){
|
||||
if(a[pop][i]!=0 && b[i]!=(byte)0 && b[i]!=(byte)1 ){
|
||||
st.push(i);
|
||||
b[i]=(byte)0; //assigning waiting status
|
||||
}}}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* The main method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String args[]){
|
||||
Scanner in=new Scanner(System.in);
|
||||
int vertices=in.nextInt(),source=in.nextInt();
|
||||
byte [][]a=new byte [vertices][vertices];
|
||||
//initially all elements of a are initialized with value zero
|
||||
|
||||
for(int i=0;i<vertices;i++){
|
||||
int size =in.nextInt();
|
||||
for(int j=0;j<size;j++){
|
||||
a[i][in.nextInt()]=1; //taking adjacency entries by assigning 1
|
||||
}
|
||||
}
|
||||
bfsImplement(a,vertices,source); //function call
|
||||
in.close();
|
||||
}
|
||||
}
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Graphs;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
@ -6,7 +8,6 @@ import java.util.Set;
|
||||
* A class that counts the number of different connected components in a graph
|
||||
*
|
||||
* @author Lukas Keul, Florian Mercks
|
||||
*
|
||||
*/
|
||||
class Graph<E extends Comparable<E>> {
|
||||
|
||||
@ -39,19 +40,15 @@ class Graph<E extends Comparable<E>> {
|
||||
* Adds a new Edge to the graph. If the nodes aren't yet in nodeList, they
|
||||
* will be added to it.
|
||||
*
|
||||
* @param startNode
|
||||
* the starting Node from the edge
|
||||
*
|
||||
* @param endNode
|
||||
* the ending Node from the edge
|
||||
* @param startNode the starting Node from the edge
|
||||
* @param endNode the ending Node from the edge
|
||||
*/
|
||||
public void addEdge(E startNode, E endNode) {
|
||||
Node start = null, end = null;
|
||||
for (Node node : nodeList) {
|
||||
if (startNode.compareTo(node.name) == 0) {
|
||||
start = node;
|
||||
}
|
||||
else if (endNode.compareTo(node.name) == 0) {
|
||||
} else if (endNode.compareTo(node.name) == 0) {
|
||||
end = node;
|
||||
}
|
||||
}
|
||||
@ -74,7 +71,6 @@ class Graph<E extends Comparable<E>> {
|
||||
* markedNodes and will be ignored if they are chosen in the nodeList.
|
||||
*
|
||||
* @return returns the amount of unconnected graphs
|
||||
*
|
||||
*/
|
||||
public int countGraphs() {
|
||||
int count = 0;
|
||||
@ -94,14 +90,9 @@ class Graph<E extends Comparable<E>> {
|
||||
/**
|
||||
* Implementation of depth first search.
|
||||
*
|
||||
* @param n
|
||||
* the actual visiting node
|
||||
*
|
||||
* @param visited
|
||||
* A list of already visited nodes in the depth first search
|
||||
*
|
||||
* @param n the actual visiting node
|
||||
* @param visited A list of already visited nodes in the depth first search
|
||||
* @return returns a set of visited nodes
|
||||
*
|
||||
*/
|
||||
public ArrayList<Node> depthFirstSearch(Node n, ArrayList<Node> visited) {
|
||||
visited.add(n);
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Graphs;
|
||||
|
||||
import java.util.Scanner;
|
||||
import java.util.ArrayList;
|
||||
|
||||
@ -5,10 +7,10 @@ import java.util.ArrayList;
|
||||
class Cycle {
|
||||
|
||||
private int nodes, edges;
|
||||
private int [][] adjacencyMatrix;
|
||||
private boolean [] visited;
|
||||
private int[][] adjacencyMatrix;
|
||||
private boolean[] visited;
|
||||
ArrayList<ArrayList<Integer>> cycles = new ArrayList<ArrayList<Integer>>();
|
||||
private boolean [] finalCycles;
|
||||
private boolean[] finalCycles;
|
||||
|
||||
public Cycle() {
|
||||
Scanner in = new Scanner(System.in);
|
||||
@ -17,8 +19,8 @@ class Cycle {
|
||||
System.out.print("Enter the no. of Edges: ");
|
||||
edges = in.nextInt();
|
||||
|
||||
adjacencyMatrix = new int [nodes][nodes];
|
||||
visited = new boolean [nodes];
|
||||
adjacencyMatrix = new int[nodes][nodes];
|
||||
visited = new boolean[nodes];
|
||||
|
||||
for (int i = 0; i < nodes; i++) {
|
||||
visited[i] = false;
|
||||
@ -26,7 +28,7 @@ class Cycle {
|
||||
|
||||
System.out.println("Enter the details of each edges <Start Node> <End Node>");
|
||||
|
||||
for(int i = 0; i < edges; i++) {
|
||||
for (int i = 0; i < edges; i++) {
|
||||
int start, end;
|
||||
start = in.nextInt();
|
||||
end = in.nextInt();
|
||||
@ -50,7 +52,7 @@ class Cycle {
|
||||
temp.add(curr);
|
||||
visited[curr] = true;
|
||||
for (int i = 0; i < nodes; i++) {
|
||||
if(adjacencyMatrix[curr][i] == 1) {
|
||||
if (adjacencyMatrix[curr][i] == 1) {
|
||||
if (i == start) {
|
||||
cycles.add(new ArrayList<Integer>(temp));
|
||||
} else {
|
||||
@ -61,7 +63,7 @@ class Cycle {
|
||||
}
|
||||
}
|
||||
|
||||
if(temp.size() > 0) {
|
||||
if (temp.size() > 0) {
|
||||
temp.remove(temp.size() - 1);
|
||||
}
|
||||
visited[curr] = false;
|
||||
|
@ -1,63 +0,0 @@
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Implementation of a Depth First Search
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
|
||||
public class DFS{
|
||||
|
||||
/**
|
||||
* Implementation in code of a DFS
|
||||
*
|
||||
* @param a structure to be DFS'ed
|
||||
* @param vertices The vertices
|
||||
* @param source The source
|
||||
*/
|
||||
public static void dfsImplement(byte [][] a,int vertices,int source){ //passing adjacency matrix and no of vertices
|
||||
byte []b=new byte[vertices]; //flag container containing status of each vertices
|
||||
Arrays.fill(b,(byte)-1); //status initialization
|
||||
/* code status
|
||||
-1 = ready
|
||||
0 = waiting
|
||||
1 = processed */
|
||||
|
||||
|
||||
Stack st=new Stack(vertices); //operational stack
|
||||
st.push(source); //assigning source
|
||||
while(!st.isEmpty()){
|
||||
b[st.peek()]=(byte)0; //assigning waiting status
|
||||
System.out.println(st.peek());
|
||||
int pop=st.pop();
|
||||
b[pop]=(byte)1; //assigning processed status
|
||||
for(int i=0;i<vertices;i++){
|
||||
if(a[pop][i]!=0 && b[i]!=(byte)0 && b[i]!=(byte)1 ){
|
||||
st.push(i);
|
||||
b[i]=(byte)0; //assigning waiting status
|
||||
}}}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* The main method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String args[]){
|
||||
Scanner in=new Scanner(System.in);
|
||||
int vertices=in.nextInt(),source=in.nextInt();
|
||||
byte [][]a=new byte [vertices][vertices];
|
||||
//initially all elements of a are initialized with value zero
|
||||
|
||||
for(int i=0;i<vertices;i++){
|
||||
int size =in.nextInt();
|
||||
for(int j=0;j<size;j++){
|
||||
a[i][in.nextInt()]=1; //taking adjacency entries by assigning 1
|
||||
}
|
||||
}
|
||||
dfsImplement(a,vertices,source); //function call
|
||||
in.close();
|
||||
}
|
||||
}
|
@ -1,78 +1,73 @@
|
||||
import java.util.Scanner;
|
||||
public class FloydWarshall
|
||||
{
|
||||
package DataStructures.Graphs;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Scanner;
|
||||
|
||||
public class FloydWarshall {
|
||||
private int DistanceMatrix[][];
|
||||
private int numberofvertices;//number of vertices in the graph
|
||||
public static final int INFINITY = 999;
|
||||
public FloydWarshall(int numberofvertices)
|
||||
{
|
||||
|
||||
public FloydWarshall(int numberofvertices) {
|
||||
DistanceMatrix = new int[numberofvertices + 1][numberofvertices + 1];//stores the value of distance from all the possible path form the source vertex to destination vertex
|
||||
Arrays.fill(DistanceMatrix, 0);
|
||||
this.numberofvertices = numberofvertices;
|
||||
}
|
||||
|
||||
public void floydwarshall(int AdjacencyMatrix[][])//calculates all the distances from source to destination vertex
|
||||
{
|
||||
for (int source = 1; source <= numberofvertices; source++)
|
||||
{
|
||||
for (int destination = 1; destination <= numberofvertices; destination++)
|
||||
{
|
||||
for (int source = 1; source <= numberofvertices; source++) {
|
||||
for (int destination = 1; destination <= numberofvertices; destination++) {
|
||||
DistanceMatrix[source][destination] = AdjacencyMatrix[source][destination];
|
||||
}
|
||||
}
|
||||
for (int intermediate = 1; intermediate <= numberofvertices; intermediate++)
|
||||
{
|
||||
for (int source = 1; source <= numberofvertices; source++)
|
||||
{
|
||||
for (int destination = 1; destination <= numberofvertices; destination++)
|
||||
{
|
||||
for (int intermediate = 1; intermediate <= numberofvertices; intermediate++) {
|
||||
for (int source = 1; source <= numberofvertices; source++) {
|
||||
for (int destination = 1; destination <= numberofvertices; destination++) {
|
||||
if (DistanceMatrix[source][intermediate] + DistanceMatrix[intermediate][destination]
|
||||
< DistanceMatrix[source][destination])//if the new distance calculated is less then the earlier shortest calculated distance it get replaced as new shortest distance
|
||||
< DistanceMatrix[source][destination])
|
||||
// if the new distance calculated is less then the earlier shortest
|
||||
// calculated distance it get replaced as new shortest distance
|
||||
{
|
||||
DistanceMatrix[source][destination] = DistanceMatrix[source][intermediate]
|
||||
+ DistanceMatrix[intermediate][destination];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int source = 1; source <= numberofvertices; source++)
|
||||
System.out.print("\t" + source);
|
||||
System.out.println();
|
||||
for (int source = 1; source <= numberofvertices; source++)
|
||||
{
|
||||
for (int source = 1; source <= numberofvertices; source++) {
|
||||
System.out.print(source + "\t");
|
||||
for (int destination = 1; destination <= numberofvertices; destination++)
|
||||
{
|
||||
for (int destination = 1; destination <= numberofvertices; destination++) {
|
||||
System.out.print(DistanceMatrix[source][destination] + "\t");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
}
|
||||
public static void main(String... arg)
|
||||
{
|
||||
int Adjacency_Matrix[][];
|
||||
int numberofvertices;
|
||||
|
||||
public static void main(String... arg) {
|
||||
Scanner scan = new Scanner(System.in);
|
||||
System.out.println("Enter the number of vertices");
|
||||
numberofvertices = scan.nextInt();
|
||||
Adjacency_Matrix = new int[numberofvertices + 1][numberofvertices + 1];
|
||||
int numberOfVertices = scan.nextInt();
|
||||
int[][] adjacencyMatrix = new int[numberOfVertices + 1][numberOfVertices + 1];
|
||||
System.out.println("Enter the Weighted Matrix for the graph");
|
||||
for (int source = 1; source <= numberofvertices; source++)
|
||||
{
|
||||
for (int destination = 1; destination <= numberofvertices; destination++)
|
||||
{
|
||||
Adjacency_Matrix[source][destination] = scan.nextInt();
|
||||
if (source == destination)
|
||||
{
|
||||
Adjacency_Matrix[source][destination] = 0;
|
||||
for (int source = 1; source <= numberOfVertices; source++) {
|
||||
for (int destination = 1; destination <= numberOfVertices; destination++) {
|
||||
adjacencyMatrix[source][destination] = scan.nextInt();
|
||||
if (source == destination) {
|
||||
adjacencyMatrix[source][destination] = 0;
|
||||
continue;
|
||||
}
|
||||
if (Adjacency_Matrix[source][destination] == 0)
|
||||
{
|
||||
Adjacency_Matrix[source][destination] = INFINITY;
|
||||
if (adjacencyMatrix[source][destination] == 0) {
|
||||
adjacencyMatrix[source][destination] = INFINITY;
|
||||
}
|
||||
}
|
||||
}
|
||||
System.out.println("The Transitive Closure of the Graph");
|
||||
FloydWarshall floydwarshall = new FloydWarshall(numberofvertices);
|
||||
floydwarshall.floydwarshall(adjacency_matrix);
|
||||
FloydWarshall floydwarshall = new FloydWarshall(numberOfVertices);
|
||||
floydwarshall.floydwarshall(adjacencyMatrix);
|
||||
scan.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Graphs;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.lang.StringBuilder;
|
||||
|
||||
@ -19,7 +21,7 @@ class AdjacencyListGraph<E extends Comparable<E>> {
|
||||
}
|
||||
|
||||
public boolean addAdjacentVertex(Vertex to) {
|
||||
for (Vertex v: adjacentVerticies) {
|
||||
for (Vertex v : adjacentVerticies) {
|
||||
if (v.data.compareTo(to.data) == 0) {
|
||||
return false; // the edge already exists
|
||||
}
|
||||
@ -51,7 +53,7 @@ class AdjacencyListGraph<E extends Comparable<E>> {
|
||||
*/
|
||||
public boolean removeEdge(E from, E to) {
|
||||
Vertex fromV = null;
|
||||
for (Vertex v: verticies) {
|
||||
for (Vertex v : verticies) {
|
||||
if (from.compareTo(v.data) == 0) {
|
||||
fromV = v;
|
||||
break;
|
||||
@ -60,6 +62,7 @@ class AdjacencyListGraph<E extends Comparable<E>> {
|
||||
if (fromV == null) return false;
|
||||
return fromV.removeAdjacentVertex(to);
|
||||
}
|
||||
|
||||
/**
|
||||
* this method adds an edge to the graph between two specified
|
||||
* verticies
|
||||
@ -70,7 +73,7 @@ class AdjacencyListGraph<E extends Comparable<E>> {
|
||||
*/
|
||||
public boolean addEdge(E from, E to) {
|
||||
Vertex fromV = null, toV = null;
|
||||
for (Vertex v: verticies) {
|
||||
for (Vertex v : verticies) {
|
||||
if (from.compareTo(v.data) == 0) { // see if from vertex already exists
|
||||
fromV = v;
|
||||
} else if (to.compareTo(v.data) == 0) { // see if to vertex already exists
|
||||
@ -94,14 +97,15 @@ class AdjacencyListGraph<E extends Comparable<E>> {
|
||||
*
|
||||
* @return returns a string describing this graph
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (Vertex v: verticies) {
|
||||
for (Vertex v : verticies) {
|
||||
sb.append("Vertex: ");
|
||||
sb.append(v.data);
|
||||
sb.append("\n");
|
||||
sb.append("Adjacent verticies: ");
|
||||
for (Vertex v2: v.adjacentVerticies) {
|
||||
for (Vertex v2 : v.adjacentVerticies) {
|
||||
sb.append(v2.data);
|
||||
sb.append(" ");
|
||||
}
|
||||
|
@ -1,174 +0,0 @@
|
||||
// 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();
|
||||
}
|
||||
}
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Graphs;
|
||||
|
||||
public class MatrixGraphs {
|
||||
|
||||
public static void main(String args[]) {
|
||||
@ -108,7 +110,7 @@ class AdjacencyMatrixGraph {
|
||||
* @return returns false if the edge doesn't exist, returns true if the edge exists and is removed
|
||||
*/
|
||||
public boolean removeEdge(int from, int to) {
|
||||
if(!this.vertexDoesExist(from) || !this.vertexDoesExist(to)) {
|
||||
if (!this.vertexDoesExist(from) || !this.vertexDoesExist(to)) {
|
||||
if (this.adjacencyOfEdgeDoesExist(from, to)) {
|
||||
this.adjacency()[from][to] = AdjacencyMatrixGraph.EDGE_NONE;
|
||||
this.adjacency()[to][from] = AdjacencyMatrixGraph.EDGE_NONE;
|
||||
|
@ -1,23 +1,23 @@
|
||||
// A Java program for Prim's Minimum Spanning Tree (MST) algorithm.
|
||||
//adjacency matrix representation of the graph
|
||||
package DataStructures.Graphs;
|
||||
|
||||
import java.lang.*;
|
||||
|
||||
class PrimMST
|
||||
{
|
||||
/**
|
||||
* A Java program for Prim's Minimum Spanning Tree (MST) algorithm.
|
||||
* adjacency matrix representation of the graph
|
||||
*/
|
||||
class PrimMST {
|
||||
// Number of vertices in the graph
|
||||
private static final int V=5;
|
||||
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[])
|
||||
{
|
||||
int minKey(int key[], Boolean mstSet[]) {
|
||||
// Initialize min value
|
||||
int min = Integer.MAX_VALUE, min_index=-1;
|
||||
int min = Integer.MAX_VALUE, min_index = -1;
|
||||
|
||||
for (int v = 0; v < V; v++)
|
||||
if (mstSet[v] == false && key[v] < min)
|
||||
{
|
||||
if (mstSet[v] == false && key[v] < min) {
|
||||
min = key[v];
|
||||
min_index = v;
|
||||
}
|
||||
@ -27,30 +27,27 @@ class PrimMST
|
||||
|
||||
// A utility function to print the constructed MST stored in
|
||||
// parent[]
|
||||
void printMST(int parent[], int n, int graph[][])
|
||||
{
|
||||
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+" "+
|
||||
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[][])
|
||||
{
|
||||
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];
|
||||
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++)
|
||||
{
|
||||
for (int i = 0; i < V; i++) {
|
||||
key[i] = Integer.MAX_VALUE;
|
||||
mstSet[i] = false;
|
||||
}
|
||||
@ -61,8 +58,7 @@ class PrimMST
|
||||
parent[0] = -1; // First node is always root of MST
|
||||
|
||||
// The MST will have V vertices
|
||||
for (int count = 0; count < V-1; count++)
|
||||
{
|
||||
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);
|
||||
@ -78,9 +74,8 @@ class PrimMST
|
||||
// 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])
|
||||
{
|
||||
if (graph[u][v] != 0 && mstSet[v] == false &&
|
||||
graph[u][v] < key[v]) {
|
||||
parent[v] = u;
|
||||
key[v] = graph[u][v];
|
||||
}
|
||||
@ -90,8 +85,7 @@ class PrimMST
|
||||
printMST(parent, V, graph);
|
||||
}
|
||||
|
||||
public static void main (String[] args)
|
||||
{
|
||||
public static void main(String[] args) {
|
||||
/* Let us create the following graph
|
||||
2 3
|
||||
(0)--(1)--(2)
|
||||
@ -101,7 +95,7 @@ class PrimMST
|
||||
(3)-------(4)
|
||||
9 */
|
||||
PrimMST t = new PrimMST();
|
||||
int graph[][] = new int[][] {{0, 2, 0, 6, 0},
|
||||
int graph[][] = new int[][]{{0, 2, 0, 6, 0},
|
||||
{2, 0, 3, 8, 5},
|
||||
{0, 3, 0, 0, 7},
|
||||
{6, 8, 0, 0, 9},
|
||||
|
@ -1,10 +1,13 @@
|
||||
package DataStructures.HashMap.Hashing;
|
||||
|
||||
|
||||
class HashMap {
|
||||
private int hsize;
|
||||
private LinkedList[] buckets;
|
||||
|
||||
public HashMap(int hsize) {
|
||||
buckets = new LinkedList[hsize];
|
||||
for (int i = 0; i < hsize ; i++ ) {
|
||||
for (int i = 0; i < hsize; i++) {
|
||||
buckets[i] = new LinkedList();
|
||||
// Java requires explicit initialisaton of each object
|
||||
}
|
||||
@ -13,7 +16,7 @@ class HashMap {
|
||||
|
||||
public int hashing(int key) {
|
||||
int hash = key % hsize;
|
||||
if(hash < 0)
|
||||
if (hash < 0)
|
||||
hash += hsize;
|
||||
return hash;
|
||||
}
|
||||
@ -29,9 +32,10 @@ class HashMap {
|
||||
|
||||
buckets[hash].delete(key);
|
||||
}
|
||||
|
||||
public void displayHashtable() {
|
||||
for (int i = 0;i < hsize ; i++) {
|
||||
System.out.printf("Bucket %d :",i);
|
||||
for (int i = 0; i < hsize; i++) {
|
||||
System.out.printf("Bucket %d :", i);
|
||||
buckets[i].display();
|
||||
}
|
||||
}
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.HashMap.Hashing;
|
||||
|
||||
class LinkedList {
|
||||
|
||||
private Node Head;
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.HashMap.Hashing;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
public class Main {
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.HashMap.Hashing;
|
||||
|
||||
class Node {
|
||||
int data;
|
||||
Node next;
|
||||
|
@ -1,6 +1,3 @@
|
||||
/**
|
||||
*
|
||||
*/
|
||||
package DataStructures.Heaps;
|
||||
|
||||
/**
|
||||
|
@ -1,6 +1,3 @@
|
||||
/**
|
||||
*
|
||||
*/
|
||||
package DataStructures.Heaps;
|
||||
|
||||
import java.lang.Double;
|
||||
|
@ -1,6 +1,3 @@
|
||||
/**
|
||||
*
|
||||
*/
|
||||
package DataStructures.Heaps;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
@ -1,5 +1,7 @@
|
||||
package DataStructures.Heaps;
|
||||
/* Minimum Priority Queue
|
||||
|
||||
/**
|
||||
* Minimum Priority Queue
|
||||
* It is a part of heap data structure
|
||||
* A heap is a specific tree based data structure
|
||||
* in which all the nodes of tree are in a specific order.
|
||||
@ -7,10 +9,10 @@ package DataStructures.Heaps;
|
||||
* respect of their parents, can either be greater
|
||||
* or less than the parent. This makes it a min priority queue
|
||||
* or max priority queue.
|
||||
* <p>
|
||||
* <p>
|
||||
* Functions: insert, delete, peek, isEmpty, print, heapSort, sink
|
||||
*/
|
||||
|
||||
// Functions: insert, delete, peek, isEmpty, print, heapSort, sink
|
||||
|
||||
public class MinPriorityQueue {
|
||||
private int[] heap;
|
||||
private int capacity;
|
||||
|
@ -1,42 +1,53 @@
|
||||
public class CircleLinkedList<E>{
|
||||
private static class Node<E>{
|
||||
package DataStructures.Lists;
|
||||
|
||||
public class CircleLinkedList<E> {
|
||||
private static class Node<E> {
|
||||
Node<E> next;
|
||||
E value;
|
||||
private Node(E value, Node<E> next){
|
||||
|
||||
private Node(E value, Node<E> next) {
|
||||
this.value = value;
|
||||
this.next = next;
|
||||
}
|
||||
}
|
||||
|
||||
//For better O.O design this should be private allows for better black box design
|
||||
private int size;
|
||||
//this will point to dummy node;
|
||||
private Node<E> head;
|
||||
|
||||
//constructer for class.. here we will make a dummy node for circly linked list implementation with reduced error catching as our list will never be empty;
|
||||
public CircleLinkedList(){
|
||||
public CircleLinkedList() {
|
||||
//creation of the dummy node
|
||||
head = new Node<E>(null,head);
|
||||
head = new Node<E>(null, head);
|
||||
size = 0;
|
||||
}
|
||||
|
||||
// getter for the size... needed because size is private.
|
||||
public int getSize(){ return size;}
|
||||
public int getSize() {
|
||||
return size;
|
||||
}
|
||||
|
||||
// for the sake of simplistiy this class will only contain the append function or addLast other add functions can be implemented however this is the basses of them all really.
|
||||
public void append(E value){
|
||||
if(value == null){
|
||||
public void append(E value) {
|
||||
if (value == null) {
|
||||
// we do not want to add null elements to the list.
|
||||
throw new NullPointerException("Cannot add null element to the list");
|
||||
}
|
||||
//head.next points to the last element;
|
||||
head.next = new Node<E>(value,head);
|
||||
size++;}
|
||||
public E remove(int pos){
|
||||
if(pos>size || pos< 0){
|
||||
head.next = new Node<E>(value, head);
|
||||
size++;
|
||||
}
|
||||
|
||||
public E remove(int pos) {
|
||||
if (pos > size || pos < 0) {
|
||||
//catching errors
|
||||
throw new IndexOutOfBoundsException("position cannot be greater than size or negative");
|
||||
}
|
||||
Node<E> iterator = head.next;
|
||||
//we need to keep track of the element before the element we want to remove we can see why bellow.
|
||||
Node<E> before = head;
|
||||
for(int i = 1; i<=pos; i++){
|
||||
for (int i = 1; i <= pos; i++) {
|
||||
iterator = iterator.next;
|
||||
before = before.next;
|
||||
}
|
||||
@ -50,5 +61,5 @@ public class CircleLinkedList<E>{
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,3 +1,7 @@
|
||||
package DataStructures.Lists;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
public class CursorLinkedList<T> {
|
||||
|
||||
private static class Node<T> {
|
||||
@ -93,7 +97,7 @@ public class CursorLinkedList<T> {
|
||||
while (start != -1) {
|
||||
|
||||
T element = cursorSpace[start].element;
|
||||
if (counter == position){
|
||||
if (counter == position) {
|
||||
return element;
|
||||
}
|
||||
|
||||
@ -107,9 +111,9 @@ public class CursorLinkedList<T> {
|
||||
}
|
||||
|
||||
|
||||
public void removeByIndex(int index){
|
||||
public void removeByIndex(int index) {
|
||||
|
||||
if(index >= 0 && index < count){
|
||||
if (index >= 0 && index < count) {
|
||||
|
||||
T element = get(index);
|
||||
remove(element);
|
||||
@ -133,10 +137,10 @@ public class CursorLinkedList<T> {
|
||||
int prev_index = head;
|
||||
int current_index = cursorSpace[prev_index].next;
|
||||
|
||||
while (current_index != -1 ) {
|
||||
while (current_index != -1) {
|
||||
|
||||
T current_element = cursorSpace[current_index].element;
|
||||
if(current_element.equals(element)){
|
||||
if (current_element.equals(element)) {
|
||||
cursorSpace[prev_index].next = cursorSpace[current_index].next;
|
||||
free(current_index);
|
||||
break;
|
||||
|
@ -1,3 +1,4 @@
|
||||
package DataStructures.Lists;
|
||||
|
||||
/**
|
||||
* This class implements a DoublyLinkedList. This is done using the classes
|
||||
@ -13,7 +14,7 @@
|
||||
* @author Unknown
|
||||
*/
|
||||
|
||||
class DoublyLinkedList {
|
||||
public class DoublyLinkedList {
|
||||
/**
|
||||
* Head refers to the front of the list
|
||||
*/
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Lists;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
import java.util.PriorityQueue;
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Lists;
|
||||
|
||||
/**
|
||||
* This class implements a SinglyLinked List. This is done
|
||||
* using SinglyLinkedList class and a LinkForLinkedList Class.
|
||||
@ -8,10 +10,8 @@
|
||||
* it grows and shrinks as it is edited. This is an example of
|
||||
* a singly linked list. Elements can only be added/removed
|
||||
* at the head/front of the list.
|
||||
*
|
||||
* @author yanglbme
|
||||
*/
|
||||
class SinglyLinkedList {
|
||||
public class SinglyLinkedList {
|
||||
/**
|
||||
* Head refer to the front of the list
|
||||
*/
|
||||
@ -38,8 +38,7 @@ class SinglyLinkedList {
|
||||
public void insertNth(int data, int position) {
|
||||
if (position < 0 || position > getSize()) {
|
||||
throw new RuntimeException("position less than zero or position more than the count of list");
|
||||
}
|
||||
else if (position == 0)
|
||||
} else if (position == 0)
|
||||
insertHead(data);
|
||||
else {
|
||||
Node cur = head;
|
||||
@ -71,8 +70,7 @@ class SinglyLinkedList {
|
||||
public void deleteNth(int position) {
|
||||
if (position < 0 || position > getSize()) {
|
||||
throw new RuntimeException("position less than zero or position more than the count of list");
|
||||
}
|
||||
else if (position == 0)
|
||||
} else if (position == 0)
|
||||
deleteHead();
|
||||
else {
|
||||
Node cur = head;
|
||||
@ -156,8 +154,6 @@ class SinglyLinkedList {
|
||||
* This class is the nodes of the SinglyLinked List.
|
||||
* They consist of a value and a pointer to the node
|
||||
* after them.
|
||||
*
|
||||
* @author yanglbme
|
||||
*/
|
||||
class Node {
|
||||
/**
|
||||
|
@ -1,8 +1,10 @@
|
||||
package DataStructures.Matrix;
|
||||
|
||||
/**
|
||||
* Matrix data-type.
|
||||
*
|
||||
* @author Kyler Smith, 2017
|
||||
*/
|
||||
* Matrix data-type.
|
||||
*
|
||||
* @author Kyler Smith, 2017
|
||||
*/
|
||||
|
||||
|
||||
public class Matrix {
|
||||
@ -38,7 +40,7 @@ public class Matrix {
|
||||
System.out.println("m2 / 2:\n" + m2.divide(2));
|
||||
System.out.println("m2 + m3:\n" + m2.plus(m3));
|
||||
System.out.println("m2 - m3:\n" + m2.minus(m3));
|
||||
System.out.println("m2 * m3: \n"+m2.multiply(m3));
|
||||
System.out.println("m2 * m3: \n" + m2.multiply(m3));
|
||||
}
|
||||
|
||||
|
||||
@ -55,11 +57,11 @@ public class Matrix {
|
||||
public Matrix(int[][] pData) {
|
||||
|
||||
/** Make a deep copy of the data */
|
||||
if(pData.length != 0) {
|
||||
if (pData.length != 0) {
|
||||
int[][] newData = new int[pData.length][pData[0].length];
|
||||
|
||||
for(int i = 0; i < pData.length; i++)
|
||||
for(int j = 0; j < pData[0].length; j++)
|
||||
for (int i = 0; i < pData.length; i++)
|
||||
for (int j = 0; j < pData[0].length; j++)
|
||||
newData[i][j] = pData[i][j];
|
||||
|
||||
this.data = newData;
|
||||
@ -85,7 +87,7 @@ public class Matrix {
|
||||
* @return rows
|
||||
*/
|
||||
public int getRows() {
|
||||
if(this.data == null)
|
||||
if (this.data == null)
|
||||
return 0;
|
||||
|
||||
return data.length;
|
||||
@ -97,7 +99,7 @@ public class Matrix {
|
||||
* @return columns
|
||||
*/
|
||||
public int getColumns() {
|
||||
if(this.data == null)
|
||||
if (this.data == null)
|
||||
return 0;
|
||||
return data[0].length;
|
||||
}
|
||||
@ -114,7 +116,7 @@ public class Matrix {
|
||||
int[][] newData = new int[this.data.length][this.data[0].length];
|
||||
|
||||
for (int i = 0; i < this.getRows(); ++i)
|
||||
for(int j = 0; j < this.getColumns(); ++j)
|
||||
for (int j = 0; j < this.getColumns(); ++j)
|
||||
newData[i][j] = this.data[i][j] * scalar;
|
||||
|
||||
return new Matrix(newData);
|
||||
@ -132,7 +134,7 @@ public class Matrix {
|
||||
int[][] newData = new int[this.data.length][this.data[0].length];
|
||||
|
||||
for (int i = 0; i < this.getRows(); ++i)
|
||||
for(int j = 0; j < this.getColumns(); ++j)
|
||||
for (int j = 0; j < this.getColumns(); ++j)
|
||||
newData[i][j] = this.data[i][j] / scalar;
|
||||
|
||||
return new Matrix(newData);
|
||||
@ -148,11 +150,11 @@ public class Matrix {
|
||||
|
||||
int[][] newData = new int[this.data.length][this.data[0].length];
|
||||
|
||||
if(this.getRows() != other.getRows() || this.getColumns() != other.getColumns())
|
||||
if (this.getRows() != other.getRows() || this.getColumns() != other.getColumns())
|
||||
throw new RuntimeException("Not the same size matrix.");
|
||||
|
||||
for (int i = 0; i < this.getRows(); ++i)
|
||||
for(int j = 0; j < this.getColumns(); ++j)
|
||||
for (int j = 0; j < this.getColumns(); ++j)
|
||||
newData[i][j] = this.data[i][j] + other.getElement(i, j);
|
||||
|
||||
return new Matrix(newData);
|
||||
@ -168,11 +170,11 @@ public class Matrix {
|
||||
|
||||
int[][] newData = new int[this.data.length][this.data[0].length];
|
||||
|
||||
if(this.getRows() != other.getRows() || this.getColumns() != other.getColumns())
|
||||
if (this.getRows() != other.getRows() || this.getColumns() != other.getColumns())
|
||||
throw new RuntimeException("Not the same size matrix.");
|
||||
|
||||
for (int i = 0; i < this.getRows(); ++i)
|
||||
for(int j = 0; j < this.getColumns(); ++j)
|
||||
for (int j = 0; j < this.getColumns(); ++j)
|
||||
newData[i][j] = this.data[i][j] - other.getElement(i, j);
|
||||
|
||||
return new Matrix(newData);
|
||||
@ -188,13 +190,13 @@ public class Matrix {
|
||||
|
||||
int[][] newData = new int[this.data.length][other.getColumns()];
|
||||
|
||||
if(this.getColumns() !=other.getRows())
|
||||
if (this.getColumns() != other.getRows())
|
||||
throw new RuntimeException("The two matrices cannot be multiplied.");
|
||||
int sum;
|
||||
for (int i = 0; i < this.getRows(); ++i)
|
||||
for(int j = 0; j < other.getColumns(); ++j){
|
||||
for (int j = 0; j < other.getColumns(); ++j) {
|
||||
sum = 0;
|
||||
for(int k=0;k<this.getColumns();++k){
|
||||
for (int k = 0; k < this.getColumns(); ++k) {
|
||||
sum += this.data[i][k] * other.getElement(k, j);
|
||||
}
|
||||
newData[i][j] = sum;
|
||||
@ -224,7 +226,7 @@ public class Matrix {
|
||||
|
||||
/**
|
||||
* Returns the Matrix as a String in the following format
|
||||
*
|
||||
* <p>
|
||||
* [ a b c ] ...
|
||||
* [ x y z ] ...
|
||||
* [ i j k ] ...
|
||||
@ -236,9 +238,9 @@ public class Matrix {
|
||||
public String toString() {
|
||||
String str = "";
|
||||
|
||||
for(int i = 0; i < this.data.length; i++) {
|
||||
for (int i = 0; i < this.data.length; i++) {
|
||||
str += "[ ";
|
||||
for(int j = 0; j < this.data[0].length; j++) {
|
||||
for (int j = 0; j < this.data[0].length; j++) {
|
||||
str += data[i][j];
|
||||
str += " ";
|
||||
}
|
||||
@ -259,7 +261,7 @@ public class Matrix {
|
||||
int[][] newData = new int[this.data[0].length][this.data.length];
|
||||
|
||||
for (int i = 0; i < this.getColumns(); ++i)
|
||||
for(int j = 0; j < this.getRows(); ++j)
|
||||
for (int j = 0; j < this.getRows(); ++j)
|
||||
newData[i][j] = this.data[j][i];
|
||||
|
||||
return new Matrix(newData);
|
||||
|
@ -1,191 +0,0 @@
|
||||
/**
|
||||
*
|
||||
* Java implementation of Matrix fast power
|
||||
* It can calculate the high power of constant Matrix with O( log(K) )
|
||||
* where K is the power of the Matrix
|
||||
*
|
||||
* In order to do that, Matrix must be square Matrix ( columns equals rows)
|
||||
*
|
||||
* Notice : large power of Matrix may cause overflow
|
||||
*
|
||||
*
|
||||
* other Matrix basic operator is based on @author Kyler Smith, 2017
|
||||
*
|
||||
* @author DDullahan, 2018
|
||||
*
|
||||
*/
|
||||
|
||||
class MatrixFastPower {
|
||||
|
||||
/**
|
||||
* Matrix Fast Power
|
||||
*
|
||||
* @param matrix : square Matrix
|
||||
* @param k : power of Matrix
|
||||
* @return product
|
||||
*/
|
||||
public static Matrix FastPower(Matrix matrix, int k) throws RuntimeException {
|
||||
|
||||
if(matrix.getColumns() != matrix.getRows())
|
||||
throw new RuntimeException("Matrix is not square Matrix.");
|
||||
|
||||
int[][] newData = new int[matrix.getColumns()][matrix.getRows()];
|
||||
|
||||
for(int i = 0; i < matrix.getColumns(); i++)
|
||||
newData[i][i] = 1;
|
||||
|
||||
Matrix newMatrix = new Matrix(newData),
|
||||
coMatrix = new Matrix(matrix.data);
|
||||
|
||||
while(k != 0) {
|
||||
|
||||
if((k & 1) != 0)
|
||||
newMatrix = newMatrix.multiply(coMatrix);
|
||||
|
||||
k >>= 1;
|
||||
coMatrix = coMatrix.multiply(coMatrix);
|
||||
|
||||
}
|
||||
|
||||
return newMatrix;
|
||||
}
|
||||
|
||||
public static void main(String[] argv) {
|
||||
|
||||
int[][] data = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
|
||||
Matrix matrix = new Matrix(data);
|
||||
|
||||
System.out.println("original matrix : ");
|
||||
System.out.println(matrix.toString());
|
||||
|
||||
matrix = MatrixFastPower.FastPower(matrix, 5);
|
||||
|
||||
System.out.println("after power : ");
|
||||
System.out.println(matrix.toString());
|
||||
|
||||
matrix = MatrixFastPower.FastPower(matrix, 1000000);
|
||||
|
||||
System.out.println("notice, large power may cause overflow : ");
|
||||
System.out.print(matrix.toString());
|
||||
System.out.println("you can use mod to fix that :-) ");
|
||||
|
||||
}
|
||||
}
|
||||
class Matrix {
|
||||
public int[][] data;
|
||||
|
||||
/**
|
||||
* Constructor for the matrix takes in a 2D array
|
||||
*
|
||||
* @param pData
|
||||
*/
|
||||
public Matrix(int[][] pData) {
|
||||
|
||||
/** Make a deep copy of the data */
|
||||
if(pData.length != 0) {
|
||||
int[][] newData = new int[pData.length][pData[0].length];
|
||||
|
||||
for(int i = 0; i < pData.length; i++)
|
||||
for(int j = 0; j < pData[0].length; j++)
|
||||
newData[i][j] = pData[i][j];
|
||||
|
||||
this.data = newData;
|
||||
} else {
|
||||
this.data = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the element specified by the given location
|
||||
*
|
||||
* @param x : x cooridinate
|
||||
* @param y : y cooridinate
|
||||
* @return int : value at location
|
||||
*/
|
||||
public int getElement(int x, int y) {
|
||||
return data[x][y];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of rows in the Matrix
|
||||
*
|
||||
* @return rows
|
||||
*/
|
||||
public int getRows() {
|
||||
if(this.data == null)
|
||||
return 0;
|
||||
|
||||
return data.length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of rows in the Matrix
|
||||
*
|
||||
* @return columns
|
||||
*/
|
||||
public int getColumns() {
|
||||
if(this.data == null)
|
||||
return 0;
|
||||
|
||||
return data[0].length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Multiplies this matrix with another matrix.
|
||||
*
|
||||
* @param other : Matrix to be multiplied with
|
||||
* @return product
|
||||
*/
|
||||
public Matrix multiply(Matrix other) throws RuntimeException {
|
||||
|
||||
int[][] newData = new int[this.data.length][other.getColumns()];
|
||||
|
||||
if(this.getColumns() != other.getRows())
|
||||
throw new RuntimeException("The two matrices cannot be multiplied.");
|
||||
|
||||
int sum;
|
||||
|
||||
for (int i = 0; i < this.getRows(); ++i)
|
||||
for(int j = 0; j < other.getColumns(); ++j) {
|
||||
sum = 0;
|
||||
|
||||
for(int k = 0; k < this.getColumns(); ++k) {
|
||||
sum += this.data[i][k] * other.getElement(k, j);
|
||||
}
|
||||
|
||||
newData[i][j] = sum;
|
||||
}
|
||||
|
||||
return new Matrix(newData);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the Matrix as a String in the following format
|
||||
*
|
||||
* [ a b c ] ...
|
||||
* [ x y z ] ...
|
||||
* [ i j k ] ...
|
||||
* ...
|
||||
*
|
||||
* @return Matrix as String
|
||||
* TODO: Work formatting for different digit sizes
|
||||
*/
|
||||
public String toString() {
|
||||
String str = "";
|
||||
|
||||
for(int i = 0; i < this.data.length; i++) {
|
||||
str += "[ ";
|
||||
|
||||
for(int j = 0; j < this.data[0].length; j++) {
|
||||
str += data[i][j];
|
||||
str += " ";
|
||||
}
|
||||
|
||||
str += "]";
|
||||
str += "\n";
|
||||
}
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
}
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Queues;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
public class GenericArrayListQueue<T> {
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Queues;
|
||||
|
||||
/**
|
||||
* This class implements a PriorityQueue.
|
||||
* <p>
|
||||
@ -6,7 +8,6 @@
|
||||
* In this example I give numbers that are bigger, a higher priority.
|
||||
* Queues in theory have no fixed size but when using an array
|
||||
* implementation it does.
|
||||
*
|
||||
*/
|
||||
class PriorityQueue {
|
||||
/**
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Queues;
|
||||
|
||||
/**
|
||||
* This implements Queues by using the class Queue.
|
||||
* <p>
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Stacks;
|
||||
|
||||
/**
|
||||
* @author Varun Upadhyay (https://github.com/varunu28)
|
||||
*/
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Trees;
|
||||
|
||||
public class AVLTree {
|
||||
|
||||
private Node root;
|
||||
@ -43,26 +45,26 @@ public class AVLTree {
|
||||
return true;
|
||||
}
|
||||
|
||||
private void delete(Node node){
|
||||
if(node.left == null && node.right == null){
|
||||
if(node.parent == null) root = null;
|
||||
else{
|
||||
private void delete(Node node) {
|
||||
if (node.left == null && node.right == null) {
|
||||
if (node.parent == null) root = null;
|
||||
else {
|
||||
Node parent = node.parent;
|
||||
if(parent.left == node){
|
||||
if (parent.left == node) {
|
||||
parent.left = null;
|
||||
}else parent.right = null;
|
||||
} else parent.right = null;
|
||||
rebalance(parent);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if(node.left!=null){
|
||||
if (node.left != null) {
|
||||
Node child = node.left;
|
||||
while (child.right!=null) child = child.right;
|
||||
while (child.right != null) child = child.right;
|
||||
node.key = child.key;
|
||||
delete(child);
|
||||
}else{
|
||||
} else {
|
||||
Node child = node.right;
|
||||
while (child.left!=null) child = child.left;
|
||||
while (child.left != null) child = child.left;
|
||||
node.key = child.key;
|
||||
delete(child);
|
||||
}
|
||||
@ -194,9 +196,9 @@ public class AVLTree {
|
||||
}
|
||||
}
|
||||
|
||||
private void reheight(Node node){
|
||||
if(node!=null){
|
||||
node.height=1 + Math.max(height(node.left), height(node.right));
|
||||
private void reheight(Node node) {
|
||||
if (node != null) {
|
||||
node.height = 1 + Math.max(height(node.left), height(node.right));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,21 +1,31 @@
|
||||
package DataStructures.Trees;
|
||||
|
||||
/**
|
||||
* This entire class is used to build a Binary Tree data structure.
|
||||
* There is the Node Class and the Tree Class, both explained below.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
* This entire class is used to build a Binary Tree data structure.
|
||||
* There is the Node Class and the Tree Class, both explained below.
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* This class implements the nodes that will go on the Binary Tree.
|
||||
* They consist of the data in them, the node to the left, the node
|
||||
* to the right, and the parent from which they came from.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Node{
|
||||
* A binary tree is a data structure in which an element
|
||||
* has two successors(children). The left child is usually
|
||||
* smaller than the parent, and the right child is usually
|
||||
* bigger.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
public class BinaryTree {
|
||||
|
||||
/**
|
||||
* This class implements the nodes that will go on the Binary Tree.
|
||||
* They consist of the data in them, the node to the left, the node
|
||||
* to the right, and the parent from which they came from.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Node {
|
||||
/** Data for the node */
|
||||
public int data;
|
||||
/** The Node to the left of this one */
|
||||
@ -30,32 +40,22 @@ class Node{
|
||||
*
|
||||
* @param value Value to put in the node
|
||||
*/
|
||||
public Node(int value){
|
||||
public Node(int value) {
|
||||
data = value;
|
||||
left = null;
|
||||
right = null;
|
||||
parent = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A binary tree is a data structure in which an element
|
||||
* has two successors(children). The left child is usually
|
||||
* smaller than the parent, and the right child is usually
|
||||
* bigger.
|
||||
*
|
||||
* @author Unknown
|
||||
*
|
||||
*/
|
||||
class Tree{
|
||||
/** The root of the Binary Tree */
|
||||
private Node root;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*/
|
||||
public Tree(){
|
||||
public BinaryTree() {
|
||||
root = null;
|
||||
}
|
||||
|
||||
@ -68,12 +68,12 @@ class Tree{
|
||||
public Node find(int key) {
|
||||
Node current = root;
|
||||
while (current != null) {
|
||||
if(key < current.data) {
|
||||
if(current.left == null)
|
||||
if (key < current.data) {
|
||||
if (current.left == null)
|
||||
return current; //The key isn't exist, returns the parent
|
||||
current = current.left;
|
||||
} else if(key > current.data) {
|
||||
if(current.right == null)
|
||||
} else if (key > current.data) {
|
||||
if (current.right == null)
|
||||
return current;
|
||||
current = current.right;
|
||||
} else { // If you find the value return it
|
||||
@ -88,21 +88,20 @@ class Tree{
|
||||
*
|
||||
* @param value Value to be inserted
|
||||
*/
|
||||
public void put(int value){
|
||||
public void put(int value) {
|
||||
Node newNode = new Node(value);
|
||||
if(root == null)
|
||||
if (root == null)
|
||||
root = newNode;
|
||||
else{
|
||||
else {
|
||||
//This will return the soon to be parent of the value you're inserting
|
||||
Node parent = find(value);
|
||||
|
||||
//This if/else assigns the new node to be either the left or right child of the parent
|
||||
if(value < parent.data){
|
||||
if (value < parent.data) {
|
||||
parent.left = newNode;
|
||||
parent.left.parent = parent;
|
||||
return;
|
||||
}
|
||||
else{
|
||||
} else {
|
||||
parent.right = newNode;
|
||||
parent.right.parent = parent;
|
||||
return;
|
||||
@ -116,21 +115,21 @@ class Tree{
|
||||
* @param value Value to be deleted
|
||||
* @return If the value was deleted
|
||||
*/
|
||||
public boolean remove(int value){
|
||||
public boolean remove(int value) {
|
||||
//temp is the node to be deleted
|
||||
Node temp = find(value);
|
||||
|
||||
//If the value doesn't exist
|
||||
if(temp.data != value)
|
||||
if (temp.data != value)
|
||||
return false;
|
||||
|
||||
//No children
|
||||
if(temp.right == null && temp.left == null){
|
||||
if(temp == root)
|
||||
if (temp.right == null && temp.left == null) {
|
||||
if (temp == root)
|
||||
root = null;
|
||||
|
||||
//This if/else assigns the new node to be either the left or right child of the parent
|
||||
else if(temp.parent.data < temp.data)
|
||||
else if (temp.parent.data < temp.data)
|
||||
temp.parent.right = null;
|
||||
else
|
||||
temp.parent.left = null;
|
||||
@ -138,7 +137,7 @@ class Tree{
|
||||
}
|
||||
|
||||
//Two children
|
||||
else if(temp.left != null && temp.right != null){
|
||||
else if (temp.left != null && temp.right != null) {
|
||||
Node successor = findSuccessor(temp);
|
||||
|
||||
//The left tree of temp is made the left tree of the successor
|
||||
@ -146,24 +145,24 @@ class Tree{
|
||||
successor.left.parent = successor;
|
||||
|
||||
//If the successor has a right child, the child's grandparent is it's new parent
|
||||
if(successor.right != null && successor.parent != temp){
|
||||
if (successor.right != null && successor.parent != temp) {
|
||||
successor.right.parent = successor.parent;
|
||||
successor.parent.left = successor.right;
|
||||
successor.right = temp.right;
|
||||
successor.right.parent = successor;
|
||||
}
|
||||
if(temp == root){
|
||||
if (temp == root) {
|
||||
successor.parent = null;
|
||||
root = successor;
|
||||
return true;
|
||||
}
|
||||
|
||||
//If you're not deleting the root
|
||||
else{
|
||||
else {
|
||||
successor.parent = temp.parent;
|
||||
|
||||
//This if/else assigns the new node to be either the left or right child of the parent
|
||||
if(temp.parent.data < temp.data)
|
||||
if (temp.parent.data < temp.data)
|
||||
temp.parent.right = successor;
|
||||
else
|
||||
temp.parent.left = successor;
|
||||
@ -171,30 +170,34 @@ class Tree{
|
||||
}
|
||||
}
|
||||
//One child
|
||||
else{
|
||||
else {
|
||||
//If it has a right child
|
||||
if(temp.right != null){
|
||||
if(temp == root){
|
||||
root = temp.right; return true;}
|
||||
if (temp.right != null) {
|
||||
if (temp == root) {
|
||||
root = temp.right;
|
||||
return true;
|
||||
}
|
||||
|
||||
temp.right.parent = temp.parent;
|
||||
|
||||
//Assigns temp to left or right child
|
||||
if(temp.data < temp.parent.data)
|
||||
if (temp.data < temp.parent.data)
|
||||
temp.parent.left = temp.right;
|
||||
else
|
||||
temp.parent.right = temp.right;
|
||||
return true;
|
||||
}
|
||||
//If it has a left child
|
||||
else{
|
||||
if(temp == root){
|
||||
root = temp.left; return true;}
|
||||
else {
|
||||
if (temp == root) {
|
||||
root = temp.left;
|
||||
return true;
|
||||
}
|
||||
|
||||
temp.left.parent = temp.parent;
|
||||
|
||||
//Assigns temp to left or right side
|
||||
if(temp.data < temp.parent.data)
|
||||
if (temp.data < temp.parent.data)
|
||||
temp.parent.left = temp.left;
|
||||
else
|
||||
temp.parent.right = temp.left;
|
||||
@ -210,12 +213,12 @@ class Tree{
|
||||
* @param n Node that you want to find the Successor of
|
||||
* @return The Successor of the node
|
||||
*/
|
||||
public Node findSuccessor(Node n){
|
||||
if(n.right == null)
|
||||
public Node findSuccessor(Node n) {
|
||||
if (n.right == null)
|
||||
return n;
|
||||
Node current = n.right;
|
||||
Node parent = n.right;
|
||||
while(current != null){
|
||||
while (current != null) {
|
||||
parent = current;
|
||||
current = current.left;
|
||||
}
|
||||
@ -227,7 +230,7 @@ class Tree{
|
||||
*
|
||||
* @return the root of the Binary Tree
|
||||
*/
|
||||
public Node getRoot(){
|
||||
public Node getRoot() {
|
||||
return root;
|
||||
}
|
||||
|
||||
@ -236,8 +239,8 @@ class Tree{
|
||||
*
|
||||
* @param localRoot The local root of the binary tree
|
||||
*/
|
||||
public void inOrder(Node localRoot){
|
||||
if(localRoot != null){
|
||||
public void inOrder(Node localRoot) {
|
||||
if (localRoot != null) {
|
||||
inOrder(localRoot.left);
|
||||
System.out.print(localRoot.data + " ");
|
||||
inOrder(localRoot.right);
|
||||
@ -249,8 +252,8 @@ class Tree{
|
||||
*
|
||||
* @param localRoot The local root of the binary tree
|
||||
*/
|
||||
public void preOrder(Node localRoot){
|
||||
if(localRoot != null){
|
||||
public void preOrder(Node localRoot) {
|
||||
if (localRoot != null) {
|
||||
System.out.print(localRoot.data + " ");
|
||||
preOrder(localRoot.left);
|
||||
preOrder(localRoot.right);
|
||||
@ -262,11 +265,11 @@ class Tree{
|
||||
*
|
||||
* @param localRoot The local root of the binary tree
|
||||
*/
|
||||
public void postOrder(Node localRoot){
|
||||
if(localRoot != null){
|
||||
public void postOrder(Node localRoot) {
|
||||
if (localRoot != null) {
|
||||
postOrder(localRoot.left);
|
||||
postOrder(localRoot.right);
|
||||
System.out.print(localRoot.data + " ");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,100 +0,0 @@
|
||||
/**
|
||||
*
|
||||
* @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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DataStructures.Trees;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.LinkedList;
|
||||
import java.util.Scanner;
|
||||
@ -224,3 +226,4 @@ public class GenericTree {
|
||||
}
|
||||
}
|
||||
|
||||
}
|
@ -1,74 +1,55 @@
|
||||
class Node
|
||||
{
|
||||
package DataStructures.Trees;
|
||||
|
||||
public class LevelOrderTraversal {
|
||||
|
||||
class Node {
|
||||
int data;
|
||||
Node left, right;
|
||||
public Node(int item)
|
||||
{
|
||||
|
||||
public Node(int item) {
|
||||
data = item;
|
||||
left = right = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class LevelOrderTraversal
|
||||
{
|
||||
// Root of the Binary Tree
|
||||
Node root;
|
||||
|
||||
public LevelOrderTraversal()
|
||||
{
|
||||
public LevelOrderTraversal() {
|
||||
root = null;
|
||||
}
|
||||
|
||||
/* function to print level order traversal of tree*/
|
||||
void printLevelOrder()
|
||||
{
|
||||
void printLevelOrder() {
|
||||
int h = height(root);
|
||||
int i;
|
||||
for (i=1; i<=h; 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)
|
||||
{
|
||||
int height(Node root) {
|
||||
if (root == null)
|
||||
return 0;
|
||||
else
|
||||
{
|
||||
else {
|
||||
/**
|
||||
* Return the height of larger subtree
|
||||
*/
|
||||
return Math.max(height(root.left),height(root.right)) + 1;
|
||||
return Math.max(height(root.left), height(root.right)) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
/* Print nodes at the given level */
|
||||
void printGivenLevel (Node root ,int 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);
|
||||
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[])
|
||||
{
|
||||
LevelOrderTraversal tree = new LevelOrderTraversal();
|
||||
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();
|
||||
}
|
||||
}
|
||||
|
@ -1,8 +1,14 @@
|
||||
package DataStructures.Trees;
|
||||
|
||||
import java.util.Queue;
|
||||
import java.util.LinkedList;
|
||||
|
||||
/* Class to represent Tree node */
|
||||
class Node {
|
||||
|
||||
/* Class to print Level Order Traversal */
|
||||
public class LevelOrderTraversalQueue {
|
||||
|
||||
/* Class to represent Tree node */
|
||||
class Node {
|
||||
int data;
|
||||
Node left, right;
|
||||
|
||||
@ -11,21 +17,16 @@ class Node {
|
||||
left = null;
|
||||
right = null;
|
||||
}
|
||||
}
|
||||
|
||||
/* Class to print Level Order Traversal */
|
||||
public class LevelOrderTraversalQueue {
|
||||
}
|
||||
|
||||
Node root;
|
||||
|
||||
/* Given a binary tree. Print its nodes in level order
|
||||
using array for implementing queue */
|
||||
void printLevelOrder()
|
||||
{
|
||||
void printLevelOrder() {
|
||||
Queue<Node> queue = new LinkedList<Node>();
|
||||
queue.add(root);
|
||||
while (!queue.isEmpty())
|
||||
{
|
||||
while (!queue.isEmpty()) {
|
||||
|
||||
/* poll() removes the present head.
|
||||
For more information on poll() visit
|
||||
@ -44,19 +45,4 @@ public class LevelOrderTraversalQueue {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void main(String args[])
|
||||
{
|
||||
/* creating a binary tree and entering
|
||||
the nodes */
|
||||
LevelOrderTraversalQueue tree_level = new LevelOrderTraversalQueue();
|
||||
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();
|
||||
}
|
||||
}
|
@ -1,16 +1,17 @@
|
||||
// Java program to print top view of Binary tree
|
||||
import java.util.*;
|
||||
package DataStructures.Trees;// Java program to print top view of Binary tree
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedList;
|
||||
import java.util.Queue;
|
||||
|
||||
// Class for a tree node
|
||||
class TreeNode
|
||||
{
|
||||
class TreeNode {
|
||||
// Members
|
||||
int key;
|
||||
TreeNode left, right;
|
||||
|
||||
// Constructor
|
||||
public TreeNode(int key)
|
||||
{
|
||||
public TreeNode(int key) {
|
||||
this.key = key;
|
||||
left = right = null;
|
||||
}
|
||||
@ -19,31 +20,35 @@ class TreeNode
|
||||
// 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
|
||||
{
|
||||
class QItem {
|
||||
TreeNode node;
|
||||
int hd;
|
||||
public QItem(TreeNode n, int h)
|
||||
{
|
||||
|
||||
public QItem(TreeNode n, int h) {
|
||||
node = n;
|
||||
hd = h;
|
||||
}
|
||||
}
|
||||
|
||||
// Class for a Binary Tree
|
||||
class Tree
|
||||
{
|
||||
class Tree {
|
||||
TreeNode root;
|
||||
|
||||
// Constructors
|
||||
public Tree() { root = null; }
|
||||
public Tree(TreeNode n) { root = n; }
|
||||
public Tree() {
|
||||
root = null;
|
||||
}
|
||||
|
||||
public Tree(TreeNode n) {
|
||||
root = n;
|
||||
}
|
||||
|
||||
// This method prints nodes in top view of binary tree
|
||||
public void printTopView()
|
||||
{
|
||||
public void printTopView() {
|
||||
// base case
|
||||
if (root == null) { return; }
|
||||
if (root == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Creates an empty hashset
|
||||
HashSet<Integer> set = new HashSet<>();
|
||||
@ -53,8 +58,7 @@ class Tree
|
||||
Q.add(new QItem(root, 0)); // Horizontal distance of root is 0
|
||||
|
||||
// Standard BFS or level order traversal loop
|
||||
while (!Q.isEmpty())
|
||||
{
|
||||
while (!Q.isEmpty()) {
|
||||
// Remove the front item and get its details
|
||||
QItem qi = Q.remove();
|
||||
int hd = qi.hd;
|
||||
@ -62,26 +66,23 @@ class Tree
|
||||
|
||||
// If this is the first node at its horizontal distance,
|
||||
// then this node is in top view
|
||||
if (!set.contains(hd))
|
||||
{
|
||||
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));
|
||||
Q.add(new QItem(n.left, hd - 1));
|
||||
if (n.right != null)
|
||||
Q.add(new QItem(n.right, hd+1));
|
||||
Q.add(new QItem(n.right, hd + 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Driver class to test above methods
|
||||
public class PrintTopViewofTree
|
||||
{
|
||||
public static void main(String[] args)
|
||||
{
|
||||
public class PrintTopViewofTree {
|
||||
public static void main(String[] args) {
|
||||
/* Create following Binary Tree
|
||||
1
|
||||
/ \
|
||||
|
@ -1,5 +1,8 @@
|
||||
package DataStructures.Trees;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author jack870131
|
||||
*/
|
||||
public class RedBlackBST {
|
||||
|
@ -1,10 +1,10 @@
|
||||
package DataStructures.Trees;
|
||||
|
||||
import java.util.LinkedList;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Varun Upadhyay (https://github.com/varunu28)
|
||||
*
|
||||
*/
|
||||
* @author Varun Upadhyay (https://github.com/varunu28)
|
||||
*/
|
||||
|
||||
|
||||
// Driver Program
|
||||
@ -38,13 +38,13 @@ public class TreeTraversal {
|
||||
}
|
||||
|
||||
/**
|
||||
* The Node class which initializes a Node of a tree
|
||||
* Consists of all 4 traversal methods: printInOrder, printPostOrder, printPreOrder & printLevelOrder
|
||||
* printInOrder: LEFT -> ROOT -> RIGHT
|
||||
* printPreOrder: ROOT -> LEFT -> RIGHT
|
||||
* printPostOrder: LEFT -> RIGHT -> ROOT
|
||||
* printLevelOrder: Prints by level (starting at root), from left to right.
|
||||
*/
|
||||
* The Node class which initializes a Node of a tree
|
||||
* Consists of all 4 traversal methods: printInOrder, printPostOrder, printPreOrder & printLevelOrder
|
||||
* 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;
|
||||
@ -53,20 +53,17 @@ class Node {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
public void insert (int value) {
|
||||
public void insert(int value) {
|
||||
if (value < data) {
|
||||
if (left == null) {
|
||||
left = new Node(value);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
left.insert(value);
|
||||
}
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
if (right == null) {
|
||||
right = new Node(value);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
right.insert(value);
|
||||
}
|
||||
}
|
||||
|
@ -1,10 +1,11 @@
|
||||
//Trie Data structure implementation without any libraries */
|
||||
package DataStructures.Trees;
|
||||
|
||||
/**
|
||||
* Trie Data structure implementation without any libraries
|
||||
*
|
||||
* @author Dheeraj Kumar Barnwal (https://github.com/dheeraj92)
|
||||
*
|
||||
*/
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
public class TrieImp {
|
||||
@ -13,34 +14,37 @@ public class TrieImp {
|
||||
TrieNode[] child;
|
||||
boolean end;
|
||||
|
||||
public TrieNode(){
|
||||
public TrieNode() {
|
||||
child = new TrieNode[26];
|
||||
end = false;
|
||||
}
|
||||
}
|
||||
|
||||
private final TrieNode root;
|
||||
public TrieImp(){
|
||||
|
||||
public TrieImp() {
|
||||
root = new TrieNode();
|
||||
}
|
||||
|
||||
public void insert(String word){
|
||||
public void insert(String word) {
|
||||
TrieNode currentNode = root;
|
||||
for(int i=0; i < word.length();i++){
|
||||
TrieNode node = currentNode.child[word.charAt(i)-'a'];
|
||||
if(node == null){
|
||||
for (int i = 0; i < word.length(); i++) {
|
||||
TrieNode node = currentNode.child[word.charAt(i) - 'a'];
|
||||
if (node == null) {
|
||||
node = new TrieNode();
|
||||
currentNode.child[word.charAt(i)-'a']=node;
|
||||
currentNode.child[word.charAt(i) - 'a'] = node;
|
||||
}
|
||||
currentNode = node;
|
||||
}
|
||||
currentNode.end = true;
|
||||
}
|
||||
public boolean search(String word){
|
||||
|
||||
public boolean search(String word) {
|
||||
TrieNode currentNode = root;
|
||||
for(int i=0;i<word.length();i++){
|
||||
for (int i = 0; i < word.length(); i++) {
|
||||
char ch = word.charAt(i);
|
||||
TrieNode node = currentNode.child[ch-'a'];
|
||||
if(node == null){
|
||||
TrieNode node = currentNode.child[ch - 'a'];
|
||||
if (node == null) {
|
||||
return false;
|
||||
}
|
||||
currentNode = node;
|
||||
@ -48,29 +52,31 @@ public class TrieImp {
|
||||
return currentNode.end;
|
||||
}
|
||||
|
||||
public boolean delete(String word){
|
||||
public boolean delete(String word) {
|
||||
TrieNode currentNode = root;
|
||||
for(int i=0;i<word.length();i++){
|
||||
for (int i = 0; i < word.length(); i++) {
|
||||
char ch = word.charAt(i);
|
||||
TrieNode node = currentNode.child[ch-'a'];
|
||||
if(node == null){
|
||||
TrieNode node = currentNode.child[ch - 'a'];
|
||||
if (node == null) {
|
||||
return false;
|
||||
}
|
||||
currentNode = node;
|
||||
}
|
||||
if(currentNode.end == true){
|
||||
if (currentNode.end == true) {
|
||||
currentNode.end = false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static void sop(String print){
|
||||
public static void sop(String print) {
|
||||
System.out.println(print);
|
||||
}
|
||||
|
||||
//Regex to check if word contains only a-z character
|
||||
public static boolean isValid(String word){
|
||||
/**
|
||||
* Regex to check if word contains only a-z character
|
||||
*/
|
||||
public static boolean isValid(String word) {
|
||||
return word.matches("^[a-z]+$");
|
||||
}
|
||||
|
||||
@ -80,40 +86,40 @@ public class TrieImp {
|
||||
@SuppressWarnings("resource")
|
||||
Scanner scan = new Scanner(System.in);
|
||||
sop("string should contain only a-z character for all operation");
|
||||
while(true){
|
||||
while (true) {
|
||||
sop("1. Insert\n2. Search\n3. Delete\n4. Quit");
|
||||
try{
|
||||
try {
|
||||
int t = scan.nextInt();
|
||||
switch (t) {
|
||||
case 1:
|
||||
word = scan.next();
|
||||
if(isValid(word))
|
||||
if (isValid(word))
|
||||
obj.insert(word);
|
||||
else
|
||||
sop("Invalid string: allowed only a-z");
|
||||
break;
|
||||
case 2:
|
||||
word = scan.next();
|
||||
boolean resS=false;
|
||||
if(isValid(word))
|
||||
boolean resS = false;
|
||||
if (isValid(word))
|
||||
resS = obj.search(word);
|
||||
else
|
||||
sop("Invalid string: allowed only a-z");
|
||||
if(resS)
|
||||
if (resS)
|
||||
sop("word found");
|
||||
else
|
||||
sop("word not found");
|
||||
break;
|
||||
case 3:
|
||||
word = scan.next();
|
||||
boolean resD=false;
|
||||
if(isValid(word))
|
||||
boolean resD = false;
|
||||
if (isValid(word))
|
||||
resD = obj.delete(word);
|
||||
else
|
||||
sop("Invalid string: allowed only a-z");
|
||||
if(resD){
|
||||
if (resD) {
|
||||
sop("word got deleted successfully");
|
||||
}else{
|
||||
} else {
|
||||
sop("word not found");
|
||||
}
|
||||
break;
|
||||
@ -125,7 +131,7 @@ public class TrieImp {
|
||||
sop("Input int from 1-4");
|
||||
break;
|
||||
}
|
||||
}catch(Exception e){
|
||||
} catch (Exception e) {
|
||||
String badInput = scan.next();
|
||||
sop("This is bad input: " + badInput);
|
||||
}
|
||||
|
@ -1,17 +1,17 @@
|
||||
class Node
|
||||
{
|
||||
package DataStructures.Trees;
|
||||
|
||||
public class ValidBSTOrNot {
|
||||
|
||||
class Node {
|
||||
int data;
|
||||
Node left, right;
|
||||
|
||||
public Node(int item)
|
||||
{
|
||||
public Node(int item) {
|
||||
data = item;
|
||||
left = right = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public class ValidBSTOrNot
|
||||
{
|
||||
//Root of the Binary Tree
|
||||
Node root;
|
||||
|
||||
@ -27,8 +27,7 @@ public class ValidBSTOrNot
|
||||
|
||||
/* Returns true if the given tree is a BST and its
|
||||
values are >= min and <= max. */
|
||||
boolean isBSTUtil(Node node, int min, int max)
|
||||
{
|
||||
boolean isBSTUtil(Node node, int min, int max) {
|
||||
/* an empty tree is BST */
|
||||
if (node == null)
|
||||
return true;
|
||||
@ -40,23 +39,7 @@ public class ValidBSTOrNot
|
||||
/* 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[])
|
||||
{
|
||||
ValidBSTOrNot tree = new ValidBSTOrNot();
|
||||
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");
|
||||
return (isBSTUtil(node.left, min, node.data - 1) &&
|
||||
isBSTUtil(node.right, node.data + 1, max));
|
||||
}
|
||||
}
|
@ -1,89 +0,0 @@
|
||||
/**
|
||||
Author : SUBHAM SANGHAI
|
||||
A Dynamic Programming based solution for Edit Distance problem In Java
|
||||
**/
|
||||
|
||||
/**Description of Edit Distance with an Example:
|
||||
|
||||
Edit distance is a way of quantifying how dissimilar two strings (e.g., words) are to one another,
|
||||
by counting the minimum number of operations required to transform one string into the other. The
|
||||
distance operations are the removal, insertion, or substitution of a character in the string.
|
||||
|
||||
|
||||
The Distance between "kitten" and "sitting" is 3. A minimal edit script that transforms the former into the latter is:
|
||||
|
||||
kitten → sitten (substitution of "s" for "k")
|
||||
sitten → sittin (substitution of "i" for "e")
|
||||
sittin → sitting (insertion of "g" at the end).**/
|
||||
|
||||
import java.util.Scanner;
|
||||
public class Edit_Distance
|
||||
{
|
||||
|
||||
|
||||
|
||||
public static int minDistance(String word1, String word2)
|
||||
{
|
||||
int len1 = word1.length();
|
||||
int len2 = word2.length();
|
||||
// len1+1, len2+1, because finally return dp[len1][len2]
|
||||
int[][] dp = new int[len1 + 1][len2 + 1];
|
||||
/* If second string is empty, the only option is to
|
||||
insert all characters of first string into second*/
|
||||
for (int i = 0; i <= len1; i++)
|
||||
{
|
||||
dp[i][0] = i;
|
||||
}
|
||||
/* If first string is empty, the only option is to
|
||||
insert all characters of second string into first*/
|
||||
for (int j = 0; j <= len2; j++)
|
||||
{
|
||||
dp[0][j] = j;
|
||||
}
|
||||
//iterate though, and check last char
|
||||
for (int i = 0; i < len1; i++)
|
||||
{
|
||||
char c1 = word1.charAt(i);
|
||||
for (int j = 0; j < len2; j++)
|
||||
{
|
||||
char c2 = word2.charAt(j);
|
||||
//if last two chars equal
|
||||
if (c1 == c2)
|
||||
{
|
||||
//update dp value for +1 length
|
||||
dp[i + 1][j + 1] = dp[i][j];
|
||||
}
|
||||
else
|
||||
{
|
||||
/* if two characters are different ,
|
||||
then take the minimum of the various operations(i.e insertion,removal,substitution)*/
|
||||
int replace = dp[i][j] + 1;
|
||||
int insert = dp[i][j + 1] + 1;
|
||||
int delete = dp[i + 1][j] + 1;
|
||||
|
||||
int min = replace > insert ? insert : replace;
|
||||
min = delete > min ? min : delete;
|
||||
dp[i + 1][j + 1] = min;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* return the final answer , after traversing through both the strings*/
|
||||
return dp[len1][len2];
|
||||
}
|
||||
|
||||
|
||||
// Driver program to test above function
|
||||
public static void main(String args[])
|
||||
{
|
||||
Scanner input = new Scanner(System.in);
|
||||
String s1,s2;
|
||||
System.out.println("Enter the First String");
|
||||
s1 = input.nextLine();
|
||||
System.out.println("Enter the Second String");
|
||||
s2 = input.nextLine();
|
||||
//ans stores the final Edit Distance between the two strings
|
||||
int ans=0;
|
||||
ans=minDistance(s1,s2);
|
||||
System.out.println("The minimum Edit Distance between \"" + s1 + "\" and \"" + s2 +"\" is "+ans);
|
||||
}
|
||||
}
|
@ -1,71 +0,0 @@
|
||||
import java.util.LinkedList;
|
||||
import java.util.Queue;
|
||||
import java.util.Scanner;
|
||||
import java.util.Vector;
|
||||
|
||||
public class Ford_Fulkerson {
|
||||
Scanner scan = new Scanner(System.in);
|
||||
final static int INF = 987654321;
|
||||
static int V; // edges
|
||||
static int[][] capacity, flow;
|
||||
|
||||
public static void main(String[] args) {
|
||||
System.out.println("V : 6");
|
||||
V = 6;
|
||||
capacity = new int[V][V];
|
||||
|
||||
capacity[0][1] = 12;
|
||||
capacity[0][3] = 13;
|
||||
capacity[1][2] = 10;
|
||||
capacity[2][3] = 13;
|
||||
capacity[2][4] = 3;
|
||||
capacity[2][5] = 15;
|
||||
capacity[3][2] = 7;
|
||||
capacity[3][4] = 15;
|
||||
capacity[4][5] = 17;
|
||||
|
||||
System.out.println("Max capacity in networkFlow : " + networkFlow(0, 5));
|
||||
}
|
||||
|
||||
private static int networkFlow(int source, int sink) {
|
||||
flow = new int[V][V];
|
||||
int totalFlow = 0;
|
||||
while (true) {
|
||||
Vector<Integer> parent = new Vector<>(V);
|
||||
for (int i = 0; i < V; i++)
|
||||
parent.add(-1);
|
||||
Queue<Integer> q = new LinkedList<>();
|
||||
parent.set(source, source);
|
||||
q.add(source);
|
||||
while (!q.isEmpty() && parent.get(sink) == -1) {
|
||||
int here = q.peek();
|
||||
q.poll();
|
||||
for (int there = 0; there < V; ++there)
|
||||
if (capacity[here][there] - flow[here][there] > 0 && parent.get(there) == -1) {
|
||||
q.add(there);
|
||||
parent.set(there, here);
|
||||
}
|
||||
}
|
||||
if (parent.get(sink) == -1)
|
||||
break;
|
||||
|
||||
int amount = INF;
|
||||
String printer = "path : ";
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (int p = sink; p != source; p = parent.get(p)) {
|
||||
amount = Math.min(capacity[parent.get(p)][p] - flow[parent.get(p)][p], amount);
|
||||
sb.append(p + "-");
|
||||
}
|
||||
sb.append(source);
|
||||
for (int p = sink; p != source; p = parent.get(p)) {
|
||||
flow[parent.get(p)][p] += amount;
|
||||
flow[p][parent.get(p)] -= amount;
|
||||
}
|
||||
totalFlow += amount;
|
||||
printer += sb.reverse() + " / max flow : " + totalFlow;
|
||||
System.out.println(printer);
|
||||
}
|
||||
|
||||
return totalFlow;
|
||||
}
|
||||
}
|
@ -1,55 +0,0 @@
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* Program to implement Kadane’s Algorithm to
|
||||
* calculate maximum contiguous subarray sum of an array
|
||||
* Time Complexity: O(n)
|
||||
*
|
||||
* @author Nishita Aggarwal
|
||||
*
|
||||
*/
|
||||
|
||||
public class KadaneAlgorithm {
|
||||
|
||||
/**
|
||||
* This method implements Kadane's Algorithm
|
||||
*
|
||||
* @param arr The input array
|
||||
* @return The maximum contiguous subarray sum of the array
|
||||
*
|
||||
*/
|
||||
static int largestContiguousSum(int arr[]){
|
||||
int i,len=arr.length,cursum=0,maxsum=Integer.MIN_VALUE;
|
||||
if(len==0) //empty array
|
||||
return 0;
|
||||
for(i=0;i<len;i++){
|
||||
cursum+=arr[i];
|
||||
if(cursum>maxsum){
|
||||
maxsum=cursum;
|
||||
}
|
||||
if(cursum<=0){
|
||||
cursum=0;
|
||||
}
|
||||
}
|
||||
return maxsum;
|
||||
}
|
||||
|
||||
/**
|
||||
* Main method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
Scanner sc=new Scanner(System.in);
|
||||
int n,arr[],i;
|
||||
n=sc.nextInt();
|
||||
arr=new int[n];
|
||||
for(i=0;i<n;i++){
|
||||
arr[i]=sc.nextInt();
|
||||
}
|
||||
int maxContSum=largestContiguousSum(arr);
|
||||
System.out.println(maxContSum);
|
||||
sc.close();
|
||||
}
|
||||
|
||||
}
|
@ -1,38 +0,0 @@
|
||||
// A Dynamic Programming based solution for 0-1 Knapsack problem
|
||||
|
||||
public class Knapsack
|
||||
{
|
||||
|
||||
private static int knapSack(int W, int wt[], int val[], int n)
|
||||
{
|
||||
int i, w;
|
||||
int rv[][] = new int[n+1][W+1]; //rv means return value
|
||||
|
||||
// Build table rv[][] in bottom up manner
|
||||
for (i = 0; i <= n; i++)
|
||||
{
|
||||
for (w = 0; w <= W; w++)
|
||||
{
|
||||
if (i==0 || w==0)
|
||||
rv[i][w] = 0;
|
||||
else if (wt[i-1] <= w)
|
||||
rv[i][w] = Math.max(val[i-1] + rv[i-1][w-wt[i-1]], rv[i-1][w]);
|
||||
else
|
||||
rv[i][w] = rv[i-1][w];
|
||||
}
|
||||
}
|
||||
|
||||
return rv[n][W];
|
||||
}
|
||||
|
||||
|
||||
// Driver program to test above function
|
||||
public static void main(String args[])
|
||||
{
|
||||
int val[] = new int[]{50, 100, 130};
|
||||
int wt[] = new int[]{10, 20, 40};
|
||||
int W = 50;
|
||||
int n = val.length;
|
||||
System.out.println(knapSack(W, wt, val, n));
|
||||
}
|
||||
}
|
@ -1,66 +0,0 @@
|
||||
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());
|
||||
}
|
||||
}
|
||||
}
|
@ -1,9 +1,8 @@
|
||||
/**
|
||||
*
|
||||
* @author Varun Upadhyay (https://github.com/varunu28)
|
||||
*
|
||||
*/
|
||||
package DynamicProgramming;
|
||||
|
||||
/**
|
||||
* @author Varun Upadhyay (https://github.com/varunu28)
|
||||
*/
|
||||
public class CoinChange {
|
||||
|
||||
// Driver Program
|
||||
@ -26,12 +25,12 @@ public class CoinChange {
|
||||
**/
|
||||
public static int change(int[] coins, int amount) {
|
||||
|
||||
int[] combinations = new int[amount+1];
|
||||
int[] combinations = new int[amount + 1];
|
||||
combinations[0] = 1;
|
||||
|
||||
for (int coin : coins) {
|
||||
for (int i=coin; i<amount+1; i++) {
|
||||
combinations[i] += combinations[i-coin];
|
||||
for (int i = coin; i < amount + 1; i++) {
|
||||
combinations[i] += combinations[i - coin];
|
||||
}
|
||||
// Uncomment the below line to see the state of combinations for each coin
|
||||
// printAmount(combinations);
|
||||
@ -39,6 +38,7 @@ public class CoinChange {
|
||||
|
||||
return combinations[amount];
|
||||
}
|
||||
|
||||
/**
|
||||
* This method finds the minimum number of coins needed for a given amount.
|
||||
*
|
||||
@ -48,17 +48,17 @@ public class CoinChange {
|
||||
**/
|
||||
public static int minimumCoins(int[] coins, int amount) {
|
||||
//minimumCoins[i] will store the minimum coins needed for amount i
|
||||
int[] minimumCoins = new int[amount+1];
|
||||
int[] minimumCoins = new int[amount + 1];
|
||||
|
||||
minimumCoins[0] = 0;
|
||||
|
||||
for(int i=1;i<=amount;i++){
|
||||
minimumCoins[i]=Integer.MAX_VALUE;
|
||||
for (int i = 1; i <= amount; i++) {
|
||||
minimumCoins[i] = Integer.MAX_VALUE;
|
||||
}
|
||||
for(int i=1;i<=amount;i++){
|
||||
for (int coin :coins){
|
||||
if(coin <=i){
|
||||
int sub_res = minimumCoins[i-coin];
|
||||
for (int i = 1; i <= amount; i++) {
|
||||
for (int coin : coins) {
|
||||
if (coin <= i) {
|
||||
int sub_res = minimumCoins[i - coin];
|
||||
if (sub_res != Integer.MAX_VALUE && sub_res + 1 < minimumCoins[i])
|
||||
minimumCoins[i] = sub_res + 1;
|
||||
}
|
||||
@ -71,7 +71,7 @@ public class CoinChange {
|
||||
|
||||
// A basic print method which prints all the contents of the array
|
||||
public static void printAmount(int[] arr) {
|
||||
for (int i=0; i<arr.length; i++) {
|
||||
for (int i = 0; i < arr.length; i++) {
|
||||
System.out.print(arr[i] + " ");
|
||||
}
|
||||
System.out.println();
|
103
DynamicProgramming/Edit_Distance.java
Normal file
103
DynamicProgramming/Edit_Distance.java
Normal file
@ -0,0 +1,103 @@
|
||||
package DynamicProgramming; /**
|
||||
* Author : SUBHAM SANGHAI
|
||||
* A DynamicProgramming based solution for Edit Distance problem In Java
|
||||
* Description of Edit Distance with an Example:
|
||||
* <p>
|
||||
* Edit distance is a way of quantifying how dissimilar two strings (e.g., words) are to one another,
|
||||
* by counting the minimum number of operations required to transform one string into the other. The
|
||||
* distance operations are the removal, insertion, or substitution of a character in the string.
|
||||
* <p>
|
||||
* <p>
|
||||
* The Distance between "kitten" and "sitting" is 3. A minimal edit script that transforms the former into the latter is:
|
||||
* <p>
|
||||
* kitten → sitten (substitution of "s" for "k")
|
||||
* sitten → sittin (substitution of "i" for "e")
|
||||
* sittin → sitting (insertion of "g" at the end).
|
||||
* Description of Edit Distance with an Example:
|
||||
* <p>
|
||||
* Edit distance is a way of quantifying how dissimilar two strings (e.g., words) are to one another,
|
||||
* by counting the minimum number of operations required to transform one string into the other. The
|
||||
* distance operations are the removal, insertion, or substitution of a character in the string.
|
||||
* <p>
|
||||
* <p>
|
||||
* The Distance between "kitten" and "sitting" is 3. A minimal edit script that transforms the former into the latter is:
|
||||
* <p>
|
||||
* kitten → sitten (substitution of "s" for "k")
|
||||
* sitten → sittin (substitution of "i" for "e")
|
||||
* sittin → sitting (insertion of "g" at the end).
|
||||
**/
|
||||
|
||||
/**Description of Edit Distance with an Example:
|
||||
|
||||
Edit distance is a way of quantifying how dissimilar two strings (e.g., words) are to one another,
|
||||
by counting the minimum number of operations required to transform one string into the other. The
|
||||
distance operations are the removal, insertion, or substitution of a character in the string.
|
||||
|
||||
|
||||
The Distance between "kitten" and "sitting" is 3. A minimal edit script that transforms the former into the latter is:
|
||||
|
||||
kitten → sitten (substitution of "s" for "k")
|
||||
sitten → sittin (substitution of "i" for "e")
|
||||
sittin → sitting (insertion of "g" at the end).**/
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
public class Edit_Distance {
|
||||
|
||||
|
||||
public static int minDistance(String word1, String word2) {
|
||||
int len1 = word1.length();
|
||||
int len2 = word2.length();
|
||||
// len1+1, len2+1, because finally return dp[len1][len2]
|
||||
int[][] dp = new int[len1 + 1][len2 + 1];
|
||||
/* If second string is empty, the only option is to
|
||||
insert all characters of first string into second*/
|
||||
for (int i = 0; i <= len1; i++) {
|
||||
dp[i][0] = i;
|
||||
}
|
||||
/* If first string is empty, the only option is to
|
||||
insert all characters of second string into first*/
|
||||
for (int j = 0; j <= len2; j++) {
|
||||
dp[0][j] = j;
|
||||
}
|
||||
//iterate though, and check last char
|
||||
for (int i = 0; i < len1; i++) {
|
||||
char c1 = word1.charAt(i);
|
||||
for (int j = 0; j < len2; j++) {
|
||||
char c2 = word2.charAt(j);
|
||||
//if last two chars equal
|
||||
if (c1 == c2) {
|
||||
//update dp value for +1 length
|
||||
dp[i + 1][j + 1] = dp[i][j];
|
||||
} else {
|
||||
/* if two characters are different ,
|
||||
then take the minimum of the various operations(i.e insertion,removal,substitution)*/
|
||||
int replace = dp[i][j] + 1;
|
||||
int insert = dp[i][j + 1] + 1;
|
||||
int delete = dp[i + 1][j] + 1;
|
||||
|
||||
int min = replace > insert ? insert : replace;
|
||||
min = delete > min ? min : delete;
|
||||
dp[i + 1][j + 1] = min;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* return the final answer , after traversing through both the strings*/
|
||||
return dp[len1][len2];
|
||||
}
|
||||
|
||||
|
||||
// Driver program to test above function
|
||||
public static void main(String args[]) {
|
||||
Scanner input = new Scanner(System.in);
|
||||
String s1, s2;
|
||||
System.out.println("Enter the First String");
|
||||
s1 = input.nextLine();
|
||||
System.out.println("Enter the Second String");
|
||||
s2 = input.nextLine();
|
||||
//ans stores the final Edit Distance between the two strings
|
||||
int ans = 0;
|
||||
ans = minDistance(s1, s2);
|
||||
System.out.println("The minimum Edit Distance between \"" + s1 + "\" and \"" + s2 + "\" is " + ans);
|
||||
}
|
||||
}
|
@ -1,5 +1,7 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
/**
|
||||
* Dynamic Programming solution for the Egg Dropping Puzzle
|
||||
* DynamicProgramming solution for the Egg Dropping Puzzle
|
||||
*/
|
||||
public class EggDropping {
|
||||
|
@ -1,3 +1,5 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
import java.io.BufferedReader;
|
||||
import java.io.InputStreamReader;
|
||||
import java.util.HashMap;
|
||||
@ -5,7 +7,6 @@ import java.util.Map;
|
||||
|
||||
/**
|
||||
* @author Varun Upadhyay (https://github.com/varunu28)
|
||||
* @author yanglbme (https://github.com/yanglbme)
|
||||
*/
|
||||
|
||||
public class Fibonacci {
|
73
DynamicProgramming/Ford_Fulkerson.java
Normal file
73
DynamicProgramming/Ford_Fulkerson.java
Normal file
@ -0,0 +1,73 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
import java.util.LinkedList;
|
||||
import java.util.Queue;
|
||||
import java.util.Scanner;
|
||||
import java.util.Vector;
|
||||
|
||||
public class Ford_Fulkerson {
|
||||
Scanner scan = new Scanner(System.in);
|
||||
final static int INF = 987654321;
|
||||
static int V; // edges
|
||||
static int[][] capacity, flow;
|
||||
|
||||
public static void main(String[] args) {
|
||||
System.out.println("V : 6");
|
||||
V = 6;
|
||||
capacity = new int[V][V];
|
||||
|
||||
capacity[0][1] = 12;
|
||||
capacity[0][3] = 13;
|
||||
capacity[1][2] = 10;
|
||||
capacity[2][3] = 13;
|
||||
capacity[2][4] = 3;
|
||||
capacity[2][5] = 15;
|
||||
capacity[3][2] = 7;
|
||||
capacity[3][4] = 15;
|
||||
capacity[4][5] = 17;
|
||||
|
||||
System.out.println("Max capacity in networkFlow : " + networkFlow(0, 5));
|
||||
}
|
||||
|
||||
private static int networkFlow(int source, int sink) {
|
||||
flow = new int[V][V];
|
||||
int totalFlow = 0;
|
||||
while (true) {
|
||||
Vector<Integer> parent = new Vector<>(V);
|
||||
for (int i = 0; i < V; i++)
|
||||
parent.add(-1);
|
||||
Queue<Integer> q = new LinkedList<>();
|
||||
parent.set(source, source);
|
||||
q.add(source);
|
||||
while (!q.isEmpty() && parent.get(sink) == -1) {
|
||||
int here = q.peek();
|
||||
q.poll();
|
||||
for (int there = 0; there < V; ++there)
|
||||
if (capacity[here][there] - flow[here][there] > 0 && parent.get(there) == -1) {
|
||||
q.add(there);
|
||||
parent.set(there, here);
|
||||
}
|
||||
}
|
||||
if (parent.get(sink) == -1)
|
||||
break;
|
||||
|
||||
int amount = INF;
|
||||
String printer = "path : ";
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (int p = sink; p != source; p = parent.get(p)) {
|
||||
amount = Math.min(capacity[parent.get(p)][p] - flow[parent.get(p)][p], amount);
|
||||
sb.append(p + "-");
|
||||
}
|
||||
sb.append(source);
|
||||
for (int p = sink; p != source; p = parent.get(p)) {
|
||||
flow[parent.get(p)][p] += amount;
|
||||
flow[p][parent.get(p)] -= amount;
|
||||
}
|
||||
totalFlow += amount;
|
||||
printer += sb.reverse() + " / max flow : " + totalFlow;
|
||||
System.out.println(printer);
|
||||
}
|
||||
|
||||
return totalFlow;
|
||||
}
|
||||
}
|
55
DynamicProgramming/KadaneAlgorithm.java
Normal file
55
DynamicProgramming/KadaneAlgorithm.java
Normal file
@ -0,0 +1,55 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* Program to implement Kadane’s Algorithm to
|
||||
* calculate maximum contiguous subarray sum of an array
|
||||
* Time Complexity: O(n)
|
||||
*
|
||||
* @author Nishita Aggarwal
|
||||
*/
|
||||
|
||||
public class KadaneAlgorithm {
|
||||
|
||||
/**
|
||||
* This method implements Kadane's Algorithm
|
||||
*
|
||||
* @param arr The input array
|
||||
* @return The maximum contiguous subarray sum of the array
|
||||
*/
|
||||
static int largestContiguousSum(int arr[]) {
|
||||
int i, len = arr.length, cursum = 0, maxsum = Integer.MIN_VALUE;
|
||||
if (len == 0) //empty array
|
||||
return 0;
|
||||
for (i = 0; i < len; i++) {
|
||||
cursum += arr[i];
|
||||
if (cursum > maxsum) {
|
||||
maxsum = cursum;
|
||||
}
|
||||
if (cursum <= 0) {
|
||||
cursum = 0;
|
||||
}
|
||||
}
|
||||
return maxsum;
|
||||
}
|
||||
|
||||
/**
|
||||
* Main method
|
||||
*
|
||||
* @param args Command line arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
Scanner sc = new Scanner(System.in);
|
||||
int n, arr[], i;
|
||||
n = sc.nextInt();
|
||||
arr = new int[n];
|
||||
for (i = 0; i < n; i++) {
|
||||
arr[i] = sc.nextInt();
|
||||
}
|
||||
int maxContSum = largestContiguousSum(arr);
|
||||
System.out.println(maxContSum);
|
||||
sc.close();
|
||||
}
|
||||
|
||||
}
|
37
DynamicProgramming/Knapsack.java
Normal file
37
DynamicProgramming/Knapsack.java
Normal file
@ -0,0 +1,37 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
/**
|
||||
* A DynamicProgramming based solution for 0-1 Knapsack problem
|
||||
*/
|
||||
|
||||
public class Knapsack {
|
||||
|
||||
private static int knapSack(int W, int wt[], int val[], int n) {
|
||||
int i, w;
|
||||
int rv[][] = new int[n + 1][W + 1]; //rv means return value
|
||||
|
||||
// Build table rv[][] in bottom up manner
|
||||
for (i = 0; i <= n; i++) {
|
||||
for (w = 0; w <= W; w++) {
|
||||
if (i == 0 || w == 0)
|
||||
rv[i][w] = 0;
|
||||
else if (wt[i - 1] <= w)
|
||||
rv[i][w] = Math.max(val[i - 1] + rv[i - 1][w - wt[i - 1]], rv[i - 1][w]);
|
||||
else
|
||||
rv[i][w] = rv[i - 1][w];
|
||||
}
|
||||
}
|
||||
|
||||
return rv[n][W];
|
||||
}
|
||||
|
||||
|
||||
// Driver program to test above function
|
||||
public static void main(String args[]) {
|
||||
int val[] = new int[]{50, 100, 130};
|
||||
int wt[] = new int[]{10, 20, 40};
|
||||
int W = 50;
|
||||
int n = val.length;
|
||||
System.out.println(knapSack(W, wt, val, n));
|
||||
}
|
||||
}
|
@ -1,3 +1,5 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
/**
|
||||
* @author Kshitij VERMA (github.com/kv19971)
|
||||
* LEVENSHTEIN DISTANCE dyamic programming implementation to show the difference between two strings (https://en.wikipedia.org/wiki/Levenshtein_distance)
|
68
DynamicProgramming/LongestCommonSubsequence.java
Normal file
68
DynamicProgramming/LongestCommonSubsequence.java
Normal file
@ -0,0 +1,68 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
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());
|
||||
}
|
||||
}
|
||||
}
|
@ -1,8 +1,9 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* @author Afrizal Fikri (https://github.com/icalF)
|
||||
* @author Libin Yang (https://github.com/yanglbme)
|
||||
*/
|
||||
public class LongestIncreasingSubsequence {
|
||||
public static void main(String[] args) {
|
@ -1,3 +1,5 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
@ -1,3 +1,5 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Scanner;
|
@ -1,8 +1,9 @@
|
||||
package DynamicProgramming;
|
||||
|
||||
/**
|
||||
* A Dynamic Programming solution for Rod cutting problem
|
||||
* A DynamicProgramming solution for Rod cutting problem
|
||||
* Returns the best obtainable price for a rod of
|
||||
* length n and price[] as prices of different pieces
|
||||
*
|
||||
*/
|
||||
public class RodCutting {
|
||||
|
@ -1,3 +1,5 @@
|
||||
package MinimizingLateness;
|
||||
|
||||
import java.io.*;
|
||||
import java.util.*;
|
||||
|
||||
|
@ -1,10 +1,12 @@
|
||||
package Misc;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.PriorityQueue;
|
||||
|
||||
/**********************
|
||||
author: shrutisheoran
|
||||
***********************/
|
||||
|
||||
/**
|
||||
* @author shrutisheoran
|
||||
*/
|
||||
public class MedianOfRunningArray {
|
||||
private PriorityQueue<Integer> p1;
|
||||
private PriorityQueue<Integer> p2;
|
||||
@ -21,7 +23,7 @@ public class MedianOfRunningArray {
|
||||
*/
|
||||
public void insert(Integer e) {
|
||||
p2.add(e);
|
||||
if(p2.size() - p1.size() > 1)
|
||||
if (p2.size() - p1.size() > 1)
|
||||
p1.add(p2.remove());
|
||||
}
|
||||
|
||||
@ -29,9 +31,9 @@ public class MedianOfRunningArray {
|
||||
Returns median at any given point
|
||||
*/
|
||||
public Integer median() {
|
||||
if(p1.size()==p2.size())
|
||||
return (p1.peek() + p2.peek())/2;
|
||||
return p1.size()>p2.size() ? p1.peek() : p2.peek();
|
||||
if (p1.size() == p2.size())
|
||||
return (p1.peek() + p2.peek()) / 2;
|
||||
return p1.size() > p2.size() ? p1.peek() : p2.peek();
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
@ -41,7 +43,7 @@ public class MedianOfRunningArray {
|
||||
|
||||
MedianOfRunningArray p = new MedianOfRunningArray();
|
||||
int arr[] = {10, 7, 4, 9, 2, 3, 11, 17, 14};
|
||||
for(int i = 0 ; i < 9 ; i++) {
|
||||
for (int i = 0; i < 9; i++) {
|
||||
p.insert(arr[i]);
|
||||
System.out.print(p.median() + " ");
|
||||
}
|
||||
|
@ -1,3 +1,5 @@
|
||||
package Misc;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
public class PalindromePrime {
|
||||
@ -20,9 +22,9 @@ public class PalindromePrime {
|
||||
|
||||
public static int reverse(int n) { // Returns the reverse of the number
|
||||
int reverse = 0;
|
||||
while(n != 0) {
|
||||
while (n != 0) {
|
||||
reverse *= 10;
|
||||
reverse += n%10;
|
||||
reverse += n % 10;
|
||||
n /= 10;
|
||||
}
|
||||
return reverse;
|
||||
@ -33,8 +35,8 @@ public class PalindromePrime {
|
||||
System.out.print(2 + "\n"); // print the first Palindromic Prime
|
||||
int count = 1;
|
||||
int num = 3;
|
||||
while(count < y) {
|
||||
if(num == reverse(num) && prime(num)) { // number is prime and it's reverse is same
|
||||
while (count < y) {
|
||||
if (num == reverse(num) && prime(num)) { // number is prime and it's reverse is same
|
||||
count++; // counts check when to terminate while loop
|
||||
System.out.print(num + "\n"); // print the Palindromic Prime
|
||||
}
|
@ -1,7 +1,7 @@
|
||||
public class heap_sort
|
||||
{
|
||||
public void sort(int arr[])
|
||||
{
|
||||
package Misc;
|
||||
|
||||
public class heap_sort {
|
||||
public void sort(int arr[]) {
|
||||
int n = arr.length;
|
||||
|
||||
// Build heap (rearrange array)
|
||||
@ -9,8 +9,7 @@ public class heap_sort
|
||||
heapify(arr, n, i);
|
||||
|
||||
// One by one extract an element from heap
|
||||
for (int i=n-1; i>=0; i--)
|
||||
{
|
||||
for (int i = n - 1; i >= 0; i--) {
|
||||
// Move current root to end
|
||||
int temp = arr[0];
|
||||
arr[0] = arr[i];
|
||||
@ -23,11 +22,10 @@ public class heap_sort
|
||||
|
||||
// To heapify a subtree rooted with node i which is
|
||||
// an index in arr[]. n is size of heap
|
||||
void heapify(int arr[], int n, int i)
|
||||
{
|
||||
void heapify(int arr[], int n, int i) {
|
||||
int largest = i; // Initialize largest as root
|
||||
int l = 2*i + 1; // left = 2*i + 1
|
||||
int r = 2*i + 2; // right = 2*i + 2
|
||||
int l = 2 * i + 1; // left = 2*i + 1
|
||||
int r = 2 * i + 2; // right = 2*i + 2
|
||||
|
||||
// If left child is larger than root
|
||||
if (l < n && arr[l] > arr[largest])
|
||||
@ -38,8 +36,7 @@ public class heap_sort
|
||||
largest = r;
|
||||
|
||||
// If largest is not root
|
||||
if (largest != i)
|
||||
{
|
||||
if (largest != i) {
|
||||
int swap = arr[i];
|
||||
arr[i] = arr[largest];
|
||||
arr[largest] = swap;
|
||||
@ -50,17 +47,15 @@ public class heap_sort
|
||||
}
|
||||
|
||||
/* A utility function to print array of size n */
|
||||
static void printArray(int arr[])
|
||||
{
|
||||
static void printArray(int arr[]) {
|
||||
int n = arr.length;
|
||||
for (int i=0; i<n; ++i)
|
||||
System.out.print(arr[i]+" ");
|
||||
for (int i = 0; i < n; ++i)
|
||||
System.out.print(arr[i] + " ");
|
||||
System.out.println();
|
||||
}
|
||||
|
||||
// Driver program
|
||||
public static void main(String args[])
|
||||
{
|
||||
public static void main(String args[]) {
|
||||
int arr[] = {12, 11, 13, 5, 6, 7};
|
||||
int n = arr.length;
|
||||
|
||||
|
@ -1,16 +1,23 @@
|
||||
//Oskar Enmalm 29/9/17
|
||||
//An Abecadrian is a word where each letter is in alphabetical order
|
||||
package Others;
|
||||
|
||||
class Abecedarian{
|
||||
/**
|
||||
* An Abecadrian is a word where each letter is in alphabetical order
|
||||
*
|
||||
* @author Oskar Enmalm
|
||||
*/
|
||||
class Abecedarian {
|
||||
|
||||
public static boolean isAbecedarian(String s){
|
||||
public static boolean isAbecedarian(String s) {
|
||||
int index = s.length() - 1;
|
||||
|
||||
for(int i =0; i <index; i++){
|
||||
for (int i = 0; i < index; i++) {
|
||||
|
||||
if(s.charAt(i)<=s.charAt(i + 1)){} //Need to check if each letter for the whole word is less than the one before it
|
||||
if (s.charAt(i) <= s.charAt(i + 1)) {
|
||||
} //Need to check if each letter for the whole word is less than the one before it
|
||||
|
||||
else{return false;}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
@ -1,3 +1,5 @@
|
||||
package Others;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
@ -6,10 +8,10 @@ import java.util.Scanner;
|
||||
* 153, 370, 371, 407 etc. For example 153 = 1^3 + 5^3 +3^3
|
||||
*
|
||||
* @author mani manasa mylavarapu
|
||||
*
|
||||
*/
|
||||
public class Armstrong {
|
||||
static Scanner scan;
|
||||
|
||||
public static void main(String[] args) {
|
||||
scan = new Scanner(System.in);
|
||||
int n = inputInt("please enter the number");
|
||||
@ -43,6 +45,7 @@ public class Armstrong {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static int inputInt(String string) {
|
||||
System.out.print(string);
|
||||
return Integer.parseInt(scan.nextLine());
|
||||
|
@ -1,22 +1,22 @@
|
||||
package Others;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
*
|
||||
* @author Nishita Aggarwal
|
||||
*
|
||||
* <p>
|
||||
* Brian Kernighan’s Algorithm
|
||||
*
|
||||
* <p>
|
||||
* algorithm to count the number of set bits in a given number
|
||||
*
|
||||
* <p>
|
||||
* Subtraction of 1 from a number toggles all the bits (from right to left) till the rightmost set bit(including the
|
||||
* rightmost set bit).
|
||||
* So if we subtract a number by 1 and do bitwise & with itself i.e. (n & (n-1)), we unset the rightmost set bit.
|
||||
*
|
||||
* <p>
|
||||
* If we do n & (n-1) in a loop and count the no of times loop executes we get the set bit count.
|
||||
*
|
||||
*
|
||||
* <p>
|
||||
* <p>
|
||||
* Time Complexity: O(logn)
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
@ -24,15 +24,12 @@ public class BrianKernighanAlgorithm {
|
||||
|
||||
/**
|
||||
* @param num: number in which we count the set bits
|
||||
*
|
||||
* @return int: Number of set bits
|
||||
* */
|
||||
static int countSetBits(int num)
|
||||
{
|
||||
*/
|
||||
static int countSetBits(int num) {
|
||||
int cnt = 0;
|
||||
while(num != 0)
|
||||
{
|
||||
num = num & (num-1);
|
||||
while (num != 0) {
|
||||
num = num & (num - 1);
|
||||
cnt++;
|
||||
}
|
||||
return cnt;
|
||||
@ -40,12 +37,9 @@ public class BrianKernighanAlgorithm {
|
||||
|
||||
|
||||
/**
|
||||
*
|
||||
* @param args : command line arguments
|
||||
*
|
||||
*/
|
||||
public static void main(String args[])
|
||||
{
|
||||
public static void main(String args[]) {
|
||||
Scanner sc = new Scanner(System.in);
|
||||
int num = sc.nextInt();
|
||||
int setBitCount = countSetBits(num);
|
||||
|
@ -1,3 +1,5 @@
|
||||
package Others;
|
||||
|
||||
import java.util.BitSet;
|
||||
|
||||
/**
|
@ -1,12 +1,14 @@
|
||||
package Others;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
|
||||
/**
|
||||
* @author Kyler Smith, 2017
|
||||
*
|
||||
* <p>
|
||||
* Implementation of a character count.
|
||||
* (Slow, could be improved upon, effectively O(n).
|
||||
* */
|
||||
*/
|
||||
|
||||
public class CountChar {
|
||||
|
||||
@ -20,23 +22,22 @@ public class CountChar {
|
||||
|
||||
/**
|
||||
* @param str: String to count the characters
|
||||
*
|
||||
* @return int: Number of characters in the passed string
|
||||
* */
|
||||
*/
|
||||
|
||||
private static int CountCharacters(String str) {
|
||||
|
||||
int count = 0;
|
||||
|
||||
if(str == "" || str == null) //Exceptions
|
||||
{
|
||||
if (str == "" || str == null) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
for(int i = 0; i < str.length(); i++) {
|
||||
if(!Character.isWhitespace(str.charAt(i))) {
|
||||
for (int i = 0; i < str.length(); i++) {
|
||||
if (!Character.isWhitespace(str.charAt(i))) {
|
||||
count++;
|
||||
}}
|
||||
}
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
28
Others/CountWords.java
Normal file
28
Others/CountWords.java
Normal file
@ -0,0 +1,28 @@
|
||||
package Others;
|
||||
|
||||
import java.util.Scanner;
|
||||
|
||||
/**
|
||||
* You enter a string into this program, and it will return how many words were
|
||||
* in that particular string
|
||||
*
|
||||
* @author Marcus
|
||||
*/
|
||||
public class CountWords {
|
||||
|
||||
public static void main(String[] args) {
|
||||
Scanner input = new Scanner(System.in);
|
||||
System.out.println("Enter your text: ");
|
||||
String str = input.nextLine();
|
||||
|
||||
System.out.println("Your text has " + wordCount(str) + " word(s)");
|
||||
input.close();
|
||||
}
|
||||
|
||||
private static int wordCount(String s) {
|
||||
if (s == null || s.isEmpty())
|
||||
return 0;
|
||||
return s.trim().split("[\\s]+").length;
|
||||
}
|
||||
|
||||
}
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user