Merge branch 'master' of https://github.com/freitzzz/Java

# Conflicts:
#	Data Structures/HashMap/HashMap.java
#	Huffman.java
#	Misc/FloydTriangle.java
#	Misc/Huffman.java
#	Misc/InsertDeleteInArray.java
#	Misc/RootPrecision.java
#	Misc/ft.java
#	Misc/root_precision.java
#	Others/FloydTriangle.java
#	Others/Huffman.java
#	Others/insert_delete_in_array.java
#	Others/root_precision.java
#	insert_delete_in_array.java

Author: joaomagfreitas

Conversions/AnyBaseToAnyBase.java

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

Data Structures/HashMap/HashMap.java

@@ -1,3 +1,4 @@
+<<<<<<< HEAD:Data Structures/HashMap/HashMap.java
 
 
 import java.util.ArrayList;
@@ -139,3 +140,144 @@ private void rehash() throws Exception{
 
 	}
 }
+=======
+import java.util.ArrayList;
+import java.util.LinkedList;
+
+public class HashMap<K,V> {
+	public class hmnodes{ //HashMap nodes 
+		K key;
+		V value;
+	}
+	
+	private int size=0; //size of hashmap
+	private LinkedList<hmnodes> buckets[];  //array of addresses of list
+	
+	public HashMap(){
+		buckets=new LinkedList[4]; //initially create bucket of any size 
+		for(int i=0;i<4;i++)
+			buckets[i]=new LinkedList<>(); 
+	}
+	
+	public void put(K key,V value) throws Exception{
+		int bi=bucketIndex(key); //find the index,the new key will be inserted in linklist at that index
+		int fountAt=find(bi,key); //check if key already exists or not 
+		if(fountAt==-1){
+			hmnodes temp=new hmnodes(); //if doesn't exist create new node and insert 
+			temp.key=key;
+			temp.value=value;
+			buckets[bi].addLast(temp);
+			this.size++;
+		}else{
+			buckets[bi].get(fountAt).value=value;//if already exist modify the value
+		}
+		
+		double lambda = (this.size*1.0)/this.buckets.length;
+		if(lambda>2.0){
+			rehash();  //rehashing function which will increase the size of bucket as soon as lambda exceeds 2.0
+		}
+		
+		return;
+	}
+	
+
+	public V get(K key) throws Exception{
+		int bi=bucketIndex(key);
+		int fountAt=find(bi,key);
+		if(fountAt==-1){
+			return null;
+		}else{
+			return buckets[bi].get(fountAt).value;
+		}
+	}
+	
+	public V remove(K key) throws Exception{
+		int bi=bucketIndex(key);
+		int fountAt=find(bi,key);
+		if(fountAt==-1){
+			return null;
+		}else{
+			this.size--;
+			return buckets[bi].remove(fountAt).value;
+		}
+	}
+	
+	public boolean containskey(K key) throws Exception{
+		int bi=bucketIndex(key);
+		int fountAt=find(bi,key);
+		if(fountAt==-1){
+			return false;
+		}else{
+			return true;
+		}
+	}
+	
+	public int size(){
+		return this.size;
+	}
+	
+	
+	public boolean isempty(){
+		return this.size==0;
+	}
+	
+	public ArrayList<K> keyset() throws Exception{
+		ArrayList<K> arr=new ArrayList<>();
+		for(int i=0;i<buckets.length;i++){
+			for(int j=0;j<buckets[i].size();j++){
+				arr.add(buckets[i].get(j).key);
+			}
+		}
+		return arr;
+	}
+	
+	public ArrayList<V> valueset() throws Exception{
+		ArrayList<V> arr=new ArrayList<>();
+		for(int i=0;i<buckets.length;i++){
+			for(int j=0;j<buckets[i].size();j++){
+				arr.add(buckets[i].get(j).value);
+			}
+		}
+		return arr;
+	}
+	
+	public void display() throws Exception{
+		for(int i=0;i<buckets.length;i++){
+			System.out.print("Bucket: "+i+" ");
+			for(int j=0;j<buckets[i].size();j++){
+				hmnodes temp=buckets[i].get(j);
+				System.out.print("["+temp.key+"->"+temp.value+"]");
+			}
+			System.out.println();
+		}
+	}
+	
+	public int find(int bi,K key) throws Exception{
+		for(int i=0;i<buckets[bi].size();i++){
+			if(key.equals(buckets[bi].get(i).key))
+				return i;
+		}
+		return -1;
+	}
+	
+	public int bucketIndex(K key) throws Exception{
+		int bi=key.hashCode();
+		return Math.abs(bi%buckets.length);
+	}
+
+	private void rehash() throws Exception{
+		LinkedList<hmnodes> ob[]= buckets;
+		buckets=new LinkedList[ob.length*2];
+		for(int i=0;i<ob.length*2;i++)
+			buckets[i]=new LinkedList<>();
+		
+		size = 0;
+		for(int i=0;i<ob.length;i++){
+			for(int j=0;j<ob[i].size();j++){
+				put(ob[i].get(j).key,ob[i].get(j).value);
+			}
+		}
+		
+	}
+}
+>>>>>>> 7e3a8c55c865471a33f6932a022a1059c5243fc3:data_structures/HashMap/HashMap.java

Data Structures/Lists/CircleLinkedList.java

@@ -7,32 +7,44 @@ private Node(E value, Node<E> next){
               this.next = next;
          }
      }
-     private int size; //For better O.O design this should be private allows for better black box design
-     private Node<E> head; //this will point to dummy node;
-     public CircleLinkedList(){ //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;
-         head = new Node<E>(null,head); //creation of the dummy node
+     //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(){ 
+          //creation of the dummy node
+         head = new Node<E>(null,head); 
          size = 0;
      }
-     public int getSize(){ return size;} // getter for the size... needed because size is private.
-     public void append(E value){ // 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.
+      // getter for the size... needed because size is private.
+     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){
-         	throw new NullPointerException("Cannot add null element to the list"); // we do not want to add null elements to the list.
+          // we do not want to add null elements to the list.
+         	throw new NullPointerException("Cannot add null element to the list"); 
          }
-         head.next = new Node<E>(value,head); //head.next points to the last element;
+          //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){
-     		throw new IndexOutOfBoundsException("position cannot be greater than size or negative"); //catching errors
+               //catching errors
+     		throw new IndexOutOfBoundsException("position cannot be greater than size or negative"); 
      	}
      	Node<E> iterator = head.next; 
-     	Node<E> before = head; //we need to keep track of the element before the element we want to remove we can see why bellow.
+          //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++){
             iterator = iterator.next;
             before = before.next;   
      	}
      	E saved = iterator.value;
-     	before.next = iterator.next; // assigning the next referance to the the element following the element we want to remove... the last element will be assigned to the head.
-     	iterator.next = null; // scrubbing 
+          // assigning the next referance to the the element following the element we want to remove... the last element will be assigned to the head.
+     	before.next = iterator.next; 
+          // scrubbing 
+     	iterator.next = null; 
      	iterator.value = null; 
      	return saved;
 

Data Structures/Stacks/Stacks.java

@@ -42,7 +42,7 @@ public void push(int value){
 			top++;
 			stackArray[top] = value;
 		}else{
-			System.out.println("The stack is full, can't insert value");
+			resize(maxSize*2);
 		}
 	}
 
@@ -54,7 +54,12 @@ public void push(int value){
 	public int pop(){
 		if(!isEmpty()){ //Checks for an empty stack
 			return stackArray[top--];
-		}else{
+		}
+
+		if(top < maxSize/4){
+			resize(maxSize/2);
+		}
+		else{
 			System.out.println("The stack is already empty");
 			return -1;
 		}
@@ -74,6 +79,16 @@ public int peek(){
 		}
 	}
 
+	private void resize(int newSize){
+		private int[] transferArray = new int[newSize];
+
+		for(int i = 0; i < stackArray.length(); i++){
+			transferArray[i] = stackArray[i];
+			stackArray = transferArray;
+		}
+		maxSize = newSize;
+	}
+
 	/**
 	 * Returns true if the stack is empty
 	 *