Hash Java3哈希程序
这段代码中的说明给我带来了麻烦，我不知道如何正确地遵循它们。（我们必须在有美元符号的地方编写代码。） 说明：编写重复调用HashPerformanceClass主驱动程序的代码。然后，重复代码从StatInsertions开始计算插入次数，通过增量增加插入计数，直到结束插入值 问题 我在重复调用HashPerformanceClass主驱动程序时遇到问题，我不知道该怎么办。如果有人有任何建议，我将不胜感激Hash Java3哈希程序,hash,Hash,这段代码中的说明给我带来了麻烦，我不知道如何正确地遵循它们。（我们必须在有美元符号的地方编写代码。） 说明：编写重复调用HashPerformanceClass主驱动程序的代码。然后，重复代码从StatInsertions开始计算插入次数，通过增量增加插入计数，直到结束插入值 问题 我在重复调用HashPerformanceClass主驱动程序时遇到问题，我不知道该怎么办。如果有人有任何建议，我将不胜感激 public class MainClass { static int disp
public class MainClass {
static int displayResultsNo = 0;
void displayHashResults() {
displayResultsNo++;
System.out.println("\nDisplay No. - "+displayResultsNo);
System.out.println("\n\nHash Instrumented Performance:\n-----------------------------");
System.out.println("Trials: " + HashPerformanceClass.trials + ", " +
"Insert Count: " + HashPerformanceClass.insertCount + ", " +
"Load: " + HashPerformanceClass.payload + ", " +
"Table Start Size: " + HashPerformanceClass.startingSize);
System.out.println("\nLinear Hashing:");
System.out.println("Insertion Total Probes: " + HashPerformanceClass.insertionLinearProbes) ;
System.out.println("Insertion Average Probes: " + HashPerformanceClass.insertionLinearProbesAvg);
System.out.println("\nDouble Hashing:");
System.out.println("Insertion Total Probes: " + HashPerformanceClass.insertionDoubleProbes) ;
System.out.println("Insertion Average Probes: " + HashPerformanceClass.insertionDoubleProbesAvg);
System.out.println("\nPerfect Hashing:");
System.out.println("Insertion Total Probes: " + HashPerformanceClass.insertionPerfectProbes) ;
System.out.println("Insertion Average Probes: " + HashPerformanceClass.insertionPerfectProbesAvg);
}//displayHashResults()
static int displayNo = 0;
void displayHashAvgProbesTable(int trials, int startInsertions, int endInsertions, int deltaInsertions, double load, int startSize) {
displayNo++;
System.out.println("\n\nDisplay No. - "+displayNo);
System.out.println("\nAverage Number of Probes Table \n------------------------------\ntrials: "+trials+" Load: "+load+" Start Size: "+startSize+"\n");
System.out.println(String.format("%-15s %-15s %-15s %-15s", "No Of Items","Linear Hash" ,"Double Hash" ,"Perfect Hash ") );
System.out.println(String.format("%-15s %-15s %-15s %-15s", "Inserted" ,"Probe Average","Probe Average","Probe Average") );
System.out.println(String.format("%-15s %-15s %-15s %-15s", "-----------","-------------","-------------","-------------") );
//$ write a code that repetitively invokes the HashPerformanceClass mainDriver
// The the repetitive code starts the number of insertions at startInsertions, increases the insert count by the deltaInsertions
//until end insertions value
}//displayHashAvgProbesTable()
MainClass () {
//$Invoke HashPerformanceClass mainDriver using arguments of insertCount=1, trials =10, payLoad=100%, Starting Size =7, display results
HashPerformanceClass.mainDriver( 1, 1, 1.0, 7); displayHashResults();
HashPerformanceClass.mainDriver(100, 80, 0.5, 101); displayHashResults(); //third column 1.0 = 100%
HashPerformanceClass.mainDriver(100, 80, 0.9, 101); displayHashResults();
HashPerformanceClass.mainDriver( 20, 1000, 0.5, 503); displayHashResults();
HashPerformanceClass.mainDriver( 20, 1000, 1.0, 1009); displayHashResults();
HashPerformanceClass.mainDriver( 20, 1000, 1.0, 4999); displayHashResults();
HashPerformanceClass.mainDriver(100, 2400, 0.5, 4999); displayHashResults();
displayHashAvgProbesTable ( 10, 100, 2000, 100, 0.5, 1009);
displayHashAvgProbesTable ( 10, 100, 2500, 1000, 0.5, 4999);
displayHashAvgProbesTable ( 10, 100, 2500, 1000, 0.5, 4999);
}//MainClass
public static void main(String[] args) {
new MainClass();
}//main()
}//MainClass
___________________________________________________________
import java.util.*;
/**
* A class for generating statistical information hash table insertion.
*/
public class HashPerformanceClass {
static int insertionLinearProbes = 0, insertionDoubleProbes = 0, insertionPerfectProbes = 0;
static float insertionLinearProbesAvg = 0, insertionDoubleProbesAvg = 0, insertionPerfectProbesAvg = 0;
static int trials;
static int insertCount;
static double payload;
static int startingSize;
public static void mainDriver(int trials, int insertCount, double payLoad, int startingSize) {
HashPerformanceClass.trials = trials;
HashPerformanceClass.insertCount = insertCount;
HashPerformanceClass.payload = payLoad;
HashPerformanceClass.startingSize= startingSize;
insertionLinearProbes = insertionDoubleProbes = insertionPerfectProbes = 0;
insertionLinearProbesAvg = insertionDoubleProbesAvg = insertionPerfectProbesAvg = 0;
//$ Declare all 3 hash table objects (linear, double, perfect) using the generic parameterized types as String and setting Starting Size from the mainDriver input parameter
DictionaryInstrumentedLinearImplementation <String, String> linearHashTableObj;
DictionaryInstrumentedDoubleImplementation <String, String> doubleHashTableObj;
DictionaryInstrumentedPerfectImplementation<String, String> perfectHashTableObj;
//Array used to hold random data inserted
String dataArray[];
//$
//For each trial set the inputs for the hash table Implementation
// Generate the Random Data array using insert count, do only once for each trial so that all hash table types have same source data set
// For all 3 hash table types
// Instantiate new hash table object
// Set the pay load factor hashtableobject.set payload
// Insert all the data from the array into the table insertalldata( , );
// Reset the probe counters for the hash table insertionlinear probes +=
// Sum up the probe statistics
//do this for all insertionlinearprobes double and perfect . . .
//$ Calculate all the insertion probes averages into the class variables for each hash type
}//mainDriver()
/* Generate an array of random of pseudo words. Each word will be composed of three randomly chosen syllables.
* @param arraySize The number of strings to generate.
* @return The array of strings.
*/
private static String[] generateRandomData(int arraySize) {
String uniqueWordStringArray[] = new String[arraySize];
DictionaryInstrumentedLinearImplementation<String,String> checkTable = new DictionaryInstrumentedLinearImplementation<String,String>();
String firstSylStringArray [] = {"ther", "fal", "sol", "cal", "com", "don", "gan", "tel", "fren", "ras", "tar", "men", "tri", "cap", "har"};
String secondSylStringArray[] = {"mo", "ta", "ra", "te", "bo", "bi", "du", "ca", "dan", "sen", "di", "no", "fe", "mi", "so" };
String thirdSylStringArray [] = {"tion", "ral", "tal", "ly", "nance", "tor", "ing", "ger", "ten", "ful", "son", "dar", "der", "den", "ton"};
Random generator = new Random();
int i=0;
while (i < arraySize) {
String valueString;
valueString = firstSylStringArray [generator.nextInt( firstSylStringArray.length) ];
valueString += secondSylStringArray[generator.nextInt(secondSylStringArray.length) ];
valueString += thirdSylStringArray [generator.nextInt( thirdSylStringArray.length) ];
if (!checkTable.contains(valueString)) {
// Have not seen pseudo word string before, so add it to the list array list
uniqueWordStringArray[i] = valueString;
checkTable.add(valueString,valueString);
i++;
}//end if
}//while
return uniqueWordStringArray;
}
/* Insert all of the values in the array into the hash table.
* @param dict The dictionary to insert all the words into.
*/
private static void insertAllData(DictionaryInterface<String,String> dict, String[] dataArray) {
for (String wordString : dataArray) {
dict.add(wordString, wordString);
}
}//insertAllData()
}//HashPerformanceClass
public类MainClass{
静态int-displayResultsNo=0；
void displayHashResults（）{
displayResultsNo++；
System.out.println（“\n显示编号-”+显示结果编号）；
System.out.println（“\n\nHash检测的性能：\n----------------------------------------------”；
System.out.println（“试验：+HashPerformanceClass.Trials+”，“+
插入计数：“+HashPerformanceClass.insertCount+”+
加载：“+HashPerformanceClass.payload+”+
“表开始大小：”+HashPerformanceClass.startingSize）；
System.out.println（“\n线性哈希：”）；
System.out.println（“插入总探针：+HashPerformanceClass.insertionLinearProbes”）；
System.out.println（“插入平均探针：+HashPerformanceClass.insertionLinearProbesAvg”）；
System.out.println（“\n双倍哈希：”）；
System.out.println（“插入总探针：+HashPerformanceClass.insertionDoubleProbes”）；
System.out.println（“插入平均探针：+HashPerformanceClass.insertionDoubleProbesAvg”）；
System.out.println（“\n完美散列：”）；
System.out.println（“插入总探针：+HashPerformanceClass.InsertionPerfectProbe”）；
System.out.println（“插入平均探针：+HashPerformanceClass.insertionPerfectProbesAvg”）；
}//displayHashResults（）
静态int displayNo=0；
void displayHashAvgProbesTable（int-trials、int-startInsertions、int-endInsertions、int-deltaInsertions、双重加载、int-startSize）{
displayNo++；
System.out.println（“\n\n显示编号-”+显示编号）；
System.out.println（“\n探头平均数表\n---------------------------------------------列：“+trials+”Load:“+Load+”开始大小：“+startSize+”\n”）；
System.out.println（String.format（“%-15s%-15s%-15s%-15s%-15s”，“项数”，“线性散列”，“双散列”，“完美散列”））；
System.out.println（String.format（“%-15s%-15s%-15s%-15s%-15s”，“insert”，“Probe Average”，“Probe Average”，“Probe Average”，“Probe Average”））；
System.out.println（String.format（“%-15s%-15s%-15s%-15s%-15s”、“-----------”、“-----------”、“-----------”、“-----------”、“-----------”、“-----------”）；
//$编写重复调用HashPerformanceClass主驱动程序的代码
//重复代码从startInsertions开始计算插入次数，通过增量增加插入计数
//直到结束插入值
}//displayHashAvgProbesTable（）
主类（）{
//$Invoke HashPerformanceClass mainDriver，使用insertCount=1、trials=10、payLoad=100%、起始大小=7、显示结果等参数
mainDriver（1,1,1.0,7）；displayHashResults（）；
HashPerformanceClass.mainDriver（100,80,0.5101）；displayHashResults（）；//第三列1.0=100%
mainDriver（100,80,0.9,101）；displayHashResults（）；
mainDriver（20,1000,0.5,503）；displayHashResults（）；
mainDriver（2010001.01009）；displayHashResults（）；
mainDriver（20,1000,1.0,4999）；displayHashResults（）；
mainDriver（10024000,0.54999）；displayHashResults（）；
displayHashAvgProbesTable（1010020001000.51009）；
displayHashAvgProbesTable（10100125001000,0.54999）；
displayHashAvgProbesTable（10100125001000,0.54999）；
}//主类
公共静态void main（字符串[]args）{
新的main类（）；
}//main（）
}//主类
___________________________________________________________
导入java.util.*；
/**
*用于生成统计信息哈希表插入的类。
*/
公共类HashPerformanceClass{
静态int insertionLinearProbes=0，insertionDoubleProbes=0，insertionPerfectProbes=0；
静态浮点insertionLinearProbesAvg=0，insertionDoubleProbesAvg=0，insertionPerfectProbesAvg=0；
静态int试验；
静态整数插入计数；
静态双有效载荷；
静态int启动大小；
公共静态无效主驱动器（int试验、int插入计数、双有效负载、int启动大小）{
HashPerformanceClass.trials=试验；
HashPerformanceClass.insertCount=insertCount；
HashPerformanceClass.payload=有效载荷；
HashPerformanceClass.startingSize=startingSize；
insertionLinearProbes=insertionDoubleProbes=insertionPerfectProbes=0；
insertionLinearProbesAvg=insertionDoubleProbesAvg=insertionPerfectProbesAvg=0；
//$使用通用参数化类型作为字符串声明所有3个哈希表对象（线性、双精度、完美），并从mainDriver输入参数设置起始大小
词典仪表化线性化实施线性化表格OBJ；
DictionaryInstrumentedDoubleHashTableObj实现；
DictionaryInstrumentedPerfectImplementationPerfectHashTableObj；
//用于保存插入的随机数据的数组
字符串数据数组[]；
//$
//对于每个试验，设置哈希表实现的输入
//生成R