Java 中的哈希结构问题

Question

这是硬件问题：

此时，你决定为参与者数据实现哈希结构以准备搜索。您将从提供的文件中读取贡献者信息;它是一个逗号分隔 (CSV( 文件。读取每条记录时，为 ID 字段创建一个哈希表。哈希表的限制是它的大小为 5，因此您需要能够处理冲突。应通过使用 ID 值的链表来解决冲突(使用堆栈实现(。您的设计应包括以下内容：

指向仅包含以下信息的链接列表结构的哈希表：

每个哈希桶冲突项将具有以下信息：

ID：整数;//标识符键以备将来使用 哈希桶函数/方法：

输入构造函数：//接受每个贡献者的名称和附加信息的字符串(您只需要输入数据的 ID 部分( 哈希函数构造函数：(提示：您只有 5 个哈希桶，因此该函数可以是一个非常简单的计算。 流行构造函数 推送构造函数 打印构造函数：//显示哈希桶的内容 交付：

一个完整记录的程序，用于加载哈希表，冲突作为链表处理，作为堆栈实现 显示程序如何运行和执行的测试计划 显示程序加载数据并在加载所有数据后显示第一个哈希存储桶的内容的屏幕截图(理想情况下，这是存储桶 0(

我相信我已经非常接近了，但是我已经习惯了Python，所以Java语法是我正在努力学习的东西。无论哪种方式，请检查下面的代码以查看我做了什么。

我相信问题与我声明哈希表大小的方式有关。在python中，我可以索引数组并将给定的对象添加到数组中的该位置。似乎我不能在 java 中做到这一点。我考虑过尝试 for 循环，但它不起作用

我觉得我很接近。大部分代码都是由教授给出的，但我自己开发了 Stack(( 类和方法。当我运行它们时，它们确实有效，我在那部分得到了 100%。

通过我完成的调试，我可以看到我正在初始化一个大小为"size"的数组(在本例中为 5(。但是，我不知道如何将键值对分配给给定的 Stack(( 索引。

同样，我习惯了Python，不太了解Java，所以我真的认为是我不理解Java语法。

在python中，我只会按照array[index].append[node]的行做一些事情。然后，我可以弹出数组[索引]并一次显示一个节点。

import java.util.Scanner;
import java.io.File;
import java.util.regex.Pattern;
public class ContributorManager {
public static void main(String [] args) {
Scanner inputFile = null;
String name = null;
String city = null;
String country = null;
String phone = null;
double contribution = 0;
int id = 0;
Contributor c = null;
Node node = null;
HashTable h = new HashTable(5); 
//open contributors file
try {
inputFile = new Scanner(new File("/Users/Dan/Desktop/contributors.csv"));
System.out.println("AsdasdfaDSF");
inputFile.useDelimiter(Pattern.compile("(\n)|(\r)|,"));
}
catch (Exception e) {
System.err.println("Error opening file.");
}
//create contributors object for each row, and add to the stack
while (inputFile.hasNext()) {
name = inputFile.next();
city = inputFile.next();
country = inputFile.next();
phone = inputFile.next();
contribution = inputFile.nextDouble();
id = inputFile.nextInt();
inputFile.nextLine(); //advance to the next line
c = new Contributor(name, city, country, phone, contribution, id); 
node = new Node(c);
//System.out.println(c.hashFunction());
h.insert(node); //insert node into the hash table
}
h.print(); //print the entire hash table
}
}

---

public class Contributor {
private String name;
private String city;
private String country;
private String phone;
private double contribution;
private int id;
public Contributor(String name, String city, String country, String phone, double contribution, int id) {
this.name = name;
this.city = city;
this.country = country;
this.phone = phone;
this.contribution = contribution;
this.id = id;
}
public int hashFunction() {
//calculate the hash key value using the id member variable in this object
//the key must always return a value between 0 and 4
int key = this.id % 5;
return key;
//return the hash key value
}
public void printContributor() {
System.out.println("Name: " + name);
System.out.println("City: " + city);
System.out.println("Country: " + country);
System.out.println("Phone: " + phone);
System.out.println("Contribution: " + contribution);
System.out.println("ID: " + id);
System.out.println();
}
}

---

import java.util.LinkedList;
public class HashTable {
Stack[] table;
private int size;
private int top;
//declaring array
public HashTable(int size) {
//initialize the table array with empty Stack objects
table = new Stack[size];
System.out.println(table.length);

}
public void insert(Node n) {
//determine the hash key of Node n
System.out.println(n);
int key = n.c.hashFunction();
System.out.println(key);
//using the key to determine the table location, 
//push Node n onto the stack
System.out.println(table.length);
table[key].push(n);

}
public void print() {
//display the contents of the entire table in order
for (int i=0; i < table.length; i++) {
System.out.println("===== Position " + i + " ======n");
table[i].print();
System.out.println("========= End ==========");
System.out.println();
}
}
}

---

public class Node {
Contributor c;
Node next;
public Node(Contributor data){
//initialize member variables
c=data;
next=null;
}
public void displayNode() {
//display the contents of this node
c.printContributor();
}
}

---

public class Stack {
Node first; 
public Stack(){
//initialize the empty stack
first = null;
}
public void push(Node newNode){
//if the stack is empty, make first point to new Node.
if(first==null)
first=newNode;  
//if the stack is not empty, loop until we get to the end of the list,
//then make the last Node point to new Node
else
{
first=newNode;
newNode = newNode.next;
}
}
public Node pop() { 
//if the stack is empty, return null
if(first==null)
return null;
//Handle the case where there is only one Node in the stack  
else if(first.next==null)
{
Node t=first;
return t;   
}
//Handle the case where there are at Least two (or more) elements in the stack
else
{
Node t=first;
return t;   
}  
}
public void print() {
//display the entire stack
Node tempDisplay = first; // start at the beginning of linkedList
while (tempDisplay != null){ // Executes until we don't find end of list.
tempDisplay.displayNode();
tempDisplay = tempDisplay.next;
}  
System.out.println();
}
}

---

贡献者.csv

Tim,Murphy,USA,8285557865,200,25
Gordon,Miner,USA,8285551008,150,32
Jean,Bell,USA,8285557503,225,33
Mike,Prather,USA,8285558497,155,34
George ,Pipps,USA,8285557777,100,35

Answer 1

但是，我不知道如何将键值对分配给给定的 Stack(( 索引。

堆栈不是数组。不支持索引分配的操作，只能从结构的一端推送和弹出。

---

看起来您在推送和弹出操作方面遇到了问题？代码注释指示需要执行的操作。如果堆栈不为空，则循环到最后

您没有循环，并且似乎正在向后插入堆栈。

相反，您可能需要如下所示的内容，与打印方法非常相似

Node n = first;
while (n.next != null) n = n.next;
n.next = newNode;

与弹出类似，您将在n.next != null && n.next.next == null时停止循环，以便您可以设置n.next = null并将其从列表中弹出

//TODO: loop logic 
Node toPop = n.next;
n.next = null;
return toPop;