Merge pull request #288 from freitzzz/master

Fixed files and folders name conventions
This commit is contained in:
Varun Upadhyay
2017-10-28 09:20:59 -07:00
committed by GitHub
41 changed files with 717 additions and 523 deletions

View File

@ -0,0 +1,283 @@
<<<<<<< HEAD:Data Structures/HashMap/HashMap.java
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);
}
}
}
}
=======
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

View File

@ -1,226 +1,226 @@
import java.util.ArrayList; import java.util.ArrayList;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.Scanner; import java.util.Scanner;
public class treeclass { public class treeclass {
private class Node { private class Node {
int data; int data;
ArrayList<Node> child = new ArrayList<>(); ArrayList<Node> child = new ArrayList<>();
} }
private Node root; private Node root;
private int size; private int size;
/* /*
A generic tree is a tree which can have as many children as it can be A generic tree is a tree which can have as many children as it can be
It might be possible that every node present is directly connected to It might be possible that every node present is directly connected to
root node. root node.
In this code In this code
Every function has two copies: one function is helper function which can be called from Every function has two copies: one function is helper function which can be called from
main and from that function a private function is called which will do the actual work. main and from that function a private function is called which will do the actual work.
I have done this, while calling from main one have to give minimum parameters. I have done this, while calling from main one have to give minimum parameters.
*/ */
public treeclass() { //Constructor public treeclass() { //Constructor
Scanner scn = new Scanner(System.in); Scanner scn = new Scanner(System.in);
root = create_treeG(null, 0, scn); root = create_treeG(null, 0, scn);
} }
private Node create_treeG(Node node, int childindx, Scanner scn) { private Node create_treeG(Node node, int childindx, Scanner scn) {
// display // display
if (node == null) { if (node == null) {
System.out.println("Enter root's data"); System.out.println("Enter root's data");
} else { } else {
System.out.println("Enter data of parent of index " + node.data + " " + childindx); System.out.println("Enter data of parent of index " + node.data + " " + childindx);
} }
// input // input
node = new Node(); node = new Node();
node.data = scn.nextInt(); node.data = scn.nextInt();
System.out.println("number of children"); System.out.println("number of children");
int number = scn.nextInt(); int number = scn.nextInt();
for (int i = 0; i < number; i++) { for (int i = 0; i < number; i++) {
Node childd = create_treeG(node, i, scn); Node childd = create_treeG(node, i, scn);
size++; size++;
node.child.add(childd); node.child.add(childd);
} }
return node; return node;
} }
/* /*
Function to display the generic tree Function to display the generic tree
*/ */
public void display() { //Helper function public void display() { //Helper function
display_1(root); display_1(root);
return; return;
} }
private void display_1(Node parent) { private void display_1(Node parent) {
System.out.print(parent.data + "=>"); System.out.print(parent.data + "=>");
for (int i = 0; i < parent.child.size(); i++) { for (int i = 0; i < parent.child.size(); i++) {
System.out.print(parent.child.get(i).data + " "); System.out.print(parent.child.get(i).data + " ");
} }
System.out.println("."); System.out.println(".");
for (int i = 0; i < parent.child.size(); i++) { for (int i = 0; i < parent.child.size(); i++) {
display_1(parent.child.get(i)); display_1(parent.child.get(i));
} }
return; return;
} }
/* /*
One call store the size directly but if you are asked compute size this function to calcuate One call store the size directly but if you are asked compute size this function to calcuate
size goes as follows size goes as follows
*/ */
public int size2call() { public int size2call() {
return size2(root); return size2(root);
} }
public int size2(Node roott) { public int size2(Node roott) {
int sz = 0; int sz = 0;
for (int i = 0; i < roott.child.size(); i++) { for (int i = 0; i < roott.child.size(); i++) {
sz += size2(roott.child.get(i)); sz += size2(roott.child.get(i));
} }
return sz + 1; return sz + 1;
} }
/* /*
Function to compute maximum value in the generic tree Function to compute maximum value in the generic tree
*/ */
public int maxcall() { public int maxcall() {
int maxi = root.data; int maxi = root.data;
return max(root, maxi); return max(root, maxi);
} }
private int max(Node roott, int maxi) { private int max(Node roott, int maxi) {
if (maxi < roott.data) if (maxi < roott.data)
maxi = roott.data; maxi = roott.data;
for (int i = 0; i < roott.child.size(); i++) { for (int i = 0; i < roott.child.size(); i++) {
maxi = max(roott.child.get(i), maxi); maxi = max(roott.child.get(i), maxi);
} }
return maxi; return maxi;
} }
/* /*
Function to compute HEIGHT of the generic tree Function to compute HEIGHT of the generic tree
*/ */
public int heightcall() { public int heightcall() {
return height(root) - 1; return height(root) - 1;
} }
private int height(Node node) { private int height(Node node) {
int h = 0; int h = 0;
for (int i = 0; i < node.child.size(); i++) { for (int i = 0; i < node.child.size(); i++) {
int k = height(node.child.get(i)); int k = height(node.child.get(i));
if (k > h) if (k > h)
h = k; h = k;
} }
return h + 1; return h + 1;
} }
/* /*
Function to find whether a number is present in the generic tree or not Function to find whether a number is present in the generic tree or not
*/ */
public boolean findcall(int info) { public boolean findcall(int info) {
return find(root, info); return find(root, info);
} }
private boolean find(Node node, int info) { private boolean find(Node node, int info) {
if (node.data == info) if (node.data == info)
return true; return true;
for (int i = 0; i < node.child.size(); i++) { for (int i = 0; i < node.child.size(); i++) {
if (find(node.child.get(i), info)) if (find(node.child.get(i), info))
return true; return true;
} }
return false; return false;
} }
/* /*
Function to calculate depth of generic tree Function to calculate depth of generic tree
*/ */
public void depthcaller(int dep) { public void depthcaller(int dep) {
depth(root, dep); depth(root, dep);
} }
public void depth(Node node, int dep) { public void depth(Node node, int dep) {
if (dep == 0) { if (dep == 0) {
System.out.println(node.data); System.out.println(node.data);
return; return;
} }
for (int i = 0; i < node.child.size(); i++) for (int i = 0; i < node.child.size(); i++)
depth(node.child.get(i), dep - 1); depth(node.child.get(i), dep - 1);
return; return;
} }
/* /*
Function to print generic tree in pre-order Function to print generic tree in pre-order
*/ */
public void preordercall() { public void preordercall() {
preorder(root); preorder(root);
System.out.println("."); System.out.println(".");
} }
private void preorder(Node node) { private void preorder(Node node) {
System.out.print(node.data + " "); System.out.print(node.data + " ");
for (int i = 0; i < node.child.size(); i++) for (int i = 0; i < node.child.size(); i++)
preorder(node.child.get(i)); preorder(node.child.get(i));
} }
/* /*
Function to print generic tree in post-order Function to print generic tree in post-order
*/ */
public void postordercall() { public void postordercall() {
postorder(root); postorder(root);
System.out.println("."); System.out.println(".");
} }
private void postorder(Node node) { private void postorder(Node node) {
for (int i = 0; i < node.child.size(); i++) for (int i = 0; i < node.child.size(); i++)
postorder(node.child.get(i)); postorder(node.child.get(i));
System.out.print(node.data + " "); System.out.print(node.data + " ");
} }
/* /*
Function to print generic tree in level-order Function to print generic tree in level-order
*/ */
public void levelorder() { public void levelorder() {
LinkedList<Node> q = new LinkedList<>(); LinkedList<Node> q = new LinkedList<>();
q.addLast(root); q.addLast(root);
while (!q.isEmpty()) { while (!q.isEmpty()) {
int k = q.getFirst().data; int k = q.getFirst().data;
System.out.print(k + " "); System.out.print(k + " ");
for (int i = 0; i < q.getFirst().child.size(); i++) { for (int i = 0; i < q.getFirst().child.size(); i++) {
q.addLast(q.getFirst().child.get(i)); q.addLast(q.getFirst().child.get(i));
} }
q.removeFirst(); q.removeFirst();
} }
System.out.println("."); System.out.println(".");
} }
/* /*
Function to remove all leaves of generic tree Function to remove all leaves of generic tree
*/ */
public void removeleavescall() { public void removeleavescall() {
removeleaves(root); removeleaves(root);
} }
private void removeleaves(Node node) { private void removeleaves(Node node) {
ArrayList<Integer> arr = new ArrayList<>(); ArrayList<Integer> arr = new ArrayList<>();
for (int i = 0; i < node.child.size(); i++) { for (int i = 0; i < node.child.size(); i++) {
if (node.child.get(i).child.size() == 0) { if (node.child.get(i).child.size() == 0) {
arr.add(i); arr.add(i);
// node.child.remove(i); // node.child.remove(i);
// i--; // i--;
} else } else
removeleaves(node.child.get(i)); removeleaves(node.child.get(i));
} }
for (int i = arr.size() - 1; i >= 0; i--) { for (int i = arr.size() - 1; i >= 0; i--) {
node.child.remove(arr.get(i) + 0); node.child.remove(arr.get(i) + 0);
} }
} }

17
Misc/FloydTriangle.java Normal file
View File

@ -0,0 +1,17 @@
import java.util.Scanner;
class FloydTriangle {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Enter the number of rows which you want in your Floyd Triangle: ");
int r = sc.nextInt(), n = 0;
for(int i=0; i < r; i++) {
for(int j=0; j <= i; j++) {
System.out.print(++n + " ");
}
System.out.println();
}
}
}

33
Misc/RootPrecision.java Normal file
View File

@ -0,0 +1,33 @@
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
public static void main(String[] args) {
//take input
Scanner scn = new Scanner(System.in);
int N = scn.nextInt(); //N is the input number
int P = scn.nextInt(); //P is precision value for eg - P is 3 in 2.564 and 5 in 3.80870.
System.out.println(squareRoot(N, P));
}
public static double squareRoot(int N, int P) {
double rv = 0; //rv means return value
double root = Math.pow(N, 0.5);
//calculate precision to power of 10 and then multiply it with root value.
int precision = (int) Math.pow(10, P);
root = root * precision;
/*typecast it into integer then divide by precision and again typecast into double
so as to have decimal points upto P precision */
rv = (int)root;
return (double)rv/precision;
}
}

View File

@ -1,158 +1,158 @@
import java.util.Comparator; import java.util.Comparator;
import java.util.Iterator; import java.util.Iterator;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
import java.util.Scanner; import java.util.Scanner;
import java.util.Stack; import java.util.Stack;
/** /**
* *
* @author Mayank Kumar (mk9440) * @author Mayank Kumar (mk9440)
*/ */
/* /*
Output : Output :
Enter number of distinct letters Enter number of distinct letters
6 6
Enter letters with its frequncy to encode Enter letters with its frequncy to encode
Enter letter : a Enter letter : a
Enter frequncy : 45 Enter frequncy : 45
Enter letter : b Enter letter : b
Enter frequncy : 13 Enter frequncy : 13
Enter letter : c Enter letter : c
Enter frequncy : 12 Enter frequncy : 12
Enter letter : d Enter letter : d
Enter frequncy : 16 Enter frequncy : 16
Enter letter : e Enter letter : e
Enter frequncy : 9 Enter frequncy : 9
Enter letter : f Enter letter : f
Enter frequncy : 5 Enter frequncy : 5
Letter Encoded Form Letter Encoded Form
a 0 a 0
b 1 0 1 b 1 0 1
c 1 0 0 c 1 0 0
d 1 1 1 d 1 1 1
e 1 1 0 1 e 1 1 0 1
f 1 1 0 0 f 1 1 0 0
*/ */
class Node{ class Node{
String letr=""; String letr="";
int freq=0,data=0; int freq=0,data=0;
Node left=null,right=null; Node left=null,right=null;
} }
//A comparator class to sort list on the basis of their frequency //A comparator class to sort list on the basis of their frequency
class comp implements Comparator<Node>{ class comp implements Comparator<Node>{
@Override @Override
public int compare(Node o1, Node o2) { public int compare(Node o1, Node o2) {
if(o1.freq>o2.freq){return 1;} if(o1.freq>o2.freq){return 1;}
else if(o1.freq<o2.freq){return -1;} else if(o1.freq<o2.freq){return -1;}
else{return 0;} else{return 0;}
} }
} }
public class Huffman { public class Huffman {
// A simple function to print a given list // A simple function to print a given list
//I just made it for debugging //I just made it for debugging
public static void print_list(List li){ public static void print_list(List li){
Iterator<Node> it=li.iterator(); Iterator<Node> it=li.iterator();
while(it.hasNext()){Node n=it.next();System.out.print(n.freq+" ");}System.out.println(); while(it.hasNext()){Node n=it.next();System.out.print(n.freq+" ");}System.out.println();
} }
//Function for making tree (Huffman Tree) //Function for making tree (Huffman Tree)
public static Node make_huffmann_tree(List li){ public static Node make_huffmann_tree(List li){
//Sorting list in increasing order of its letter frequency //Sorting list in increasing order of its letter frequency
li.sort(new comp()); li.sort(new comp());
Node temp=null; Node temp=null;
Iterator it=li.iterator(); Iterator it=li.iterator();
//System.out.println(li.size()); //System.out.println(li.size());
//Loop for making huffman tree till only single node remains in list //Loop for making huffman tree till only single node remains in list
while(true){ while(true){
temp=new Node(); temp=new Node();
//a and b are Node which are to be combine to make its parent //a and b are Node which are to be combine to make its parent
Node a=new Node(),b=new Node(); Node a=new Node(),b=new Node();
a=null;b=null; a=null;b=null;
//checking if list is eligible for combining or not //checking if list is eligible for combining or not
//here first assignment of it.next in a will always be true as list till end will //here first assignment of it.next in a will always be true as list till end will
//must have atleast one node //must have atleast one node
a=(Node)it.next(); a=(Node)it.next();
//Below condition is to check either list has 2nd node or not to combine //Below condition is to check either list has 2nd node or not to combine
//If this condition will be false, then it means construction of huffman tree is completed //If this condition will be false, then it means construction of huffman tree is completed
if(it.hasNext()){b=(Node)it.next();} if(it.hasNext()){b=(Node)it.next();}
//Combining first two smallest nodes in list to make its parent whose frequncy //Combining first two smallest nodes in list to make its parent whose frequncy
//will be equals to sum of frequency of these two nodes //will be equals to sum of frequency of these two nodes
if(b!=null){ if(b!=null){
temp.freq=a.freq+b.freq;a.data=0;b.data=1;//assigining 0 and 1 to left and right nodes temp.freq=a.freq+b.freq;a.data=0;b.data=1;//assigining 0 and 1 to left and right nodes
temp.left=a;temp.right=b; temp.left=a;temp.right=b;
//after combing, removing first two nodes in list which are already combined //after combing, removing first two nodes in list which are already combined
li.remove(0);//removes first element which is now combined -step1 li.remove(0);//removes first element which is now combined -step1
li.remove(0);//removes 2nd element which comes on 1st position after deleting first in step1 li.remove(0);//removes 2nd element which comes on 1st position after deleting first in step1
li.add(temp);//adding new combined node to list li.add(temp);//adding new combined node to list
//print_list(li); //For visualizing each combination step //print_list(li); //For visualizing each combination step
} }
//Sorting after combining to again repeat above on sorted frequency list //Sorting after combining to again repeat above on sorted frequency list
li.sort(new comp()); li.sort(new comp());
it=li.iterator();//resetting list pointer to first node (head/root of tree) it=li.iterator();//resetting list pointer to first node (head/root of tree)
if(li.size()==1){return (Node)it.next();} //base condition ,returning root of huffman tree if(li.size()==1){return (Node)it.next();} //base condition ,returning root of huffman tree
} }
} }
//Function for finding path between root and given letter ch //Function for finding path between root and given letter ch
public static void dfs(Node n,String ch){ public static void dfs(Node n,String ch){
Stack<Node> st=new Stack(); // stack for storing path Stack<Node> st=new Stack(); // stack for storing path
int freq=n.freq; // recording root freq to avoid it adding in path encoding int freq=n.freq; // recording root freq to avoid it adding in path encoding
find_path_and_encode(st,n,ch,freq); find_path_and_encode(st,n,ch,freq);
} }
//A simple utility function to print stack (Used for printing path) //A simple utility function to print stack (Used for printing path)
public static void print_path(Stack<Node> st){ public static void print_path(Stack<Node> st){
for(int i=0;i<st.size();i++){ for(int i=0;i<st.size();i++){
System.out.print(st.elementAt(i).data+" "); System.out.print(st.elementAt(i).data+" ");
} }
} }
public static void find_path_and_encode(Stack<Node> st,Node root,String s,int f){ public static void find_path_and_encode(Stack<Node> st,Node root,String s,int f){
//Base condition //Base condition
if(root!= null){ if(root!= null){
if(root.freq!=f){st.push(root);} // avoiding root to add in path/encoding bits if(root.freq!=f){st.push(root);} // avoiding root to add in path/encoding bits
if(root.letr.equals(s)){print_path(st);return;} // Recursion stopping condition when path gets founded if(root.letr.equals(s)){print_path(st);return;} // Recursion stopping condition when path gets founded
find_path_and_encode(st,root.left,s,f); find_path_and_encode(st,root.left,s,f);
find_path_and_encode(st,root.right,s,f); find_path_and_encode(st,root.right,s,f);
//Popping if path not found in right or left of this node,because we previously //Popping if path not found in right or left of this node,because we previously
//pushed this node in taking a mindset that it might be in path //pushed this node in taking a mindset that it might be in path
st.pop(); st.pop();
} }
} }
public static void main(String args[]){ public static void main(String args[]){
List <Node> li=new LinkedList<>(); List <Node> li=new LinkedList<>();
Scanner in=new Scanner(System.in); Scanner in=new Scanner(System.in);
System.out.println("Enter number of distinct letters "); System.out.println("Enter number of distinct letters ");
int n=in.nextInt(); int n=in.nextInt();
String s[]=new String[n]; String s[]=new String[n];
System.out.print("Enter letters with its frequncy to encode\n"); System.out.print("Enter letters with its frequncy to encode\n");
for(int i=0;i<n;i++){ for(int i=0;i<n;i++){
Node a=new Node(); Node a=new Node();
System.out.print("Enter letter : "); System.out.print("Enter letter : ");
a.letr=in.next();s[i]=a.letr; a.letr=in.next();s[i]=a.letr;
System.out.print("Enter frequncy : "); System.out.print("Enter frequncy : ");
a.freq=in.nextInt();System.out.println(); a.freq=in.nextInt();System.out.println();
li.add(a); li.add(a);
} }
Node root=new Node(); Node root=new Node();
root=make_huffmann_tree(li); root=make_huffmann_tree(li);
System.out.println("Letter\t\tEncoded Form"); System.out.println("Letter\t\tEncoded Form");
for(int i=0;i<n;i++){ for(int i=0;i<n;i++){
System.out.print(s[i]+"\t\t");dfs(root,s[i]);System.out.println();} System.out.print(s[i]+"\t\t");dfs(root,s[i]);System.out.println();}
} }
} }

View File

@ -1,139 +0,0 @@
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);
}
}
}
}