如何通过函数在数组中进行更改 #包括 #包括 #包括 #定义尺寸10 //哈希表是链表和数组的混合体 typedef结构节点； 结构节点{ int值； 节点*下一步； }; int散列（int）； 无效插入（int，节点**）； int main（）{ 节点*哈希表[大小]； 插入（12，&哈希表[大小]）； printf（“%d\n”，哈希表[5]->值）； } 整数散列（整数数据）{ 返回数据%7； } 无效插入（int值，节点**表）{ int loc=散列（值）； NODE*temp=malloc（sizeof（NODE））； temp->next=NULL； 温度->值=值； *表[loc]=*温度； printf（“%d\n”，表[loc]->值）； }

上述代码打印： 12及 27475674（可能是位置的随机数。）

---

如何使其打印12和12，即如何在数组中进行更改。我想用为存储值而创建的节点的位置填充数组[5]。

表达式

*table[loc]

等于

*（table[loc]）

，这可能不是您想要的，因为您将取消对未初始化指针的引用

然后赋值将

*temp

的内容复制到一些看似随机的内存中

然后丢弃刚才分配的内存，导致内存泄漏

也没有人试图创建哈希桶的链接列表

尝试在

main

函数中创建

hashtable

数组，并初始化所有指向

NULL的指针：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define SIZE 10

// A hashtable is a mixture of a linked list and array

typedef struct node NODE;

struct node{
    int value;
    NODE* next;
};

int hash(int);                                                   
void insert(int,NODE **);                                       

int main(){

    NODE* hashtable[SIZE];
    insert(12,&hashtable[SIZE]); 
    printf("%d\n",hashtable[5]->value);  


}

int hash(int data){
return data%7;
}

void insert(int value,NODE **table){

    int loc = hash(value);
    NODE* temp = malloc(sizeof(NODE));
    temp->next = NULL;
    temp->value = value;
    *table[loc] = *temp;
    printf("%d\n",table[loc]->value);


}

然后在插入节点时，实际将其链接到bucket list中：

NODE* hashtable[SIZE] = { NULL };  // Will initialize all elements to NULL

表达式
*table[loc]
等于
*（table[loc]）
，这可能不是您想要的，因为您将取消对未初始化指针的引用

然后赋值将
*temp
的内容复制到一些看似随机的内存中

然后丢弃刚才分配的内存，导致内存泄漏

也没有人试图创建哈希桶的链接列表

相反，尝试在
main
函数中创建
hashtable
数组，并初始化，使所有指针指向
NULL
：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define SIZE 10

// A hashtable is a mixture of a linked list and array

typedef struct node NODE;

struct node{
    int value;
    NODE* next;
};

int hash(int);                                                   
void insert(int,NODE **);                                       

int main(){

    NODE* hashtable[SIZE];
    insert(12,&hashtable[SIZE]); 
    printf("%d\n",hashtable[5]->value);  


}

int hash(int data){
return data%7;
}

void insert(int value,NODE **table){

    int loc = hash(value);
    NODE* temp = malloc(sizeof(NODE));
    temp->next = NULL;
    temp->value = value;
    *table[loc] = *temp;
    printf("%d\n",table[loc]->value);


}

然后在插入节点时，实际将其链接到bucket list中：

NODE* hashtable[SIZE] = { NULL };  // Will initialize all elements to NULL

这只是我对你的程序所做的一个简单的修改，它会告诉你你到底做错了什么

temp->next = table[loc];
table[loc] = temp;

#包括
#包括
#包括
#定义尺寸10
//哈希表是链表和数组的混合体
typedef结构节点；
结构节点{
int值；
节点*下一步；
};
节点*哈希表[SIZE]={NULL}；
int散列（int）；
int插入（int）；/，节点**）；
内部主（空）
{
int loc=插入（12）；/，&哈希表[大小]；
如果（位置<尺寸）{
if（哈希表[loc]）{
printf（“%d\n”，哈希表[loc]->值）；
}否则{
printf（“错误：接收到无效指针\n”）；
}
}
返回0；
}
整数散列（整数数据）
{
返回数据%7；
}
int-insert（int-value）/，节点*表[]）
{
int loc=散列（值）；
printf（“loc=%d\n”，loc）；
如果（位置<尺寸）{
NODE*temp=（NODE*）malloc（sizeof（NODE））；
温度->值=值；
temp->next=NULL；
哈希表[loc]=温度；
printf（“%d\n”，哈希表[loc]->值）；
}
返回loc；
}

在这里，我全局声明了哈希表，以确保您尝试更新的值对这两个函数都可见。这就是代码中的问题。无论您为temp分配什么新地址，都有地址“x”，但您试图从主函数访问无效地址。我只是想给你个暗示。希望这对你有帮助。享受吧
 这只是我对你的程序所做的一个简单更改，它会告诉你你到底做错了什么

temp->next = table[loc];
table[loc] = temp;

#包括
#包括
#包括
#定义尺寸10
//哈希表是链表和数组的混合体
typedef结构节点；
结构节点{
int值；
节点*下一步；
};
节点*哈希表[SIZE]={NULL}；
int散列（int）；
int插入（int）；/，节点**）；
内部主（空）
{
int loc=插入（12）；/，&哈希表[大小]；
如果（位置<尺寸）{
if（哈希表[loc]）{
printf（“%d\n”，哈希表[loc]->值）；
}否则{
printf（“错误：接收到无效指针\n”）；
}
}
返回0；
}
整数散列（整数数据）
{
返回数据%7；
}
int-insert（int-value）/，节点*表[]）
{
int loc=散列（值）；
printf（“loc=%d\n”，loc）；
如果（位置<尺寸）{
NODE*temp=（NODE*）malloc（sizeof（NODE））；
温度->值=值；
temp->next=NULL；
哈希表[loc]=温度；
printf（“%d\n”，哈希表[loc]->值）；
}
返回loc；
}

在这里，我全局声明了哈希表，以确保您尝试更新的值对这两个函数都可见。这就是代码中的问题。无论您为temp分配什么新地址，都有地址“x”，但您试图从主函数访问无效地址。我只是想给你个暗示。希望这对你有帮助。享受吧