C中的映射数组-带键的链表：值
好的，我的问题是当我写节点时，它只会覆盖头部节点，所以当你调用map_get时，你只会得到一个包含数据的节点。我想把数据放在头上，或者把头节点推到前面挂起来，无论哪种方法都可以，最简单的方法就是谢谢你的帮助C中的映射数组-带键的链表：值,c,map,linked-list,associative-array,C,Map,Linked List,Associative Array,好的，我的问题是当我写节点时，它只会覆盖头部节点，所以当你调用map_get时，你只会得到一个包含数据的节点。我想把数据放在头上，或者把头节点推到前面挂起来，无论哪种方法都可以，最简单的方法就是谢谢你的帮助 #include <assert.h> #include<stdlib.h> #include "map.h" #include <string.h> int main(){ map_t* newList = malloc(sizeof(map_t));
#include <assert.h>
#include<stdlib.h>
#include "map.h"
#include <string.h>
int main(){
map_t* newList = malloc(sizeof(map_t));
map_init(newList);
const char* passString ="a";
const char* secondString="2";
map_put(newList,"3","3");
map_put(newList,"7","34");
map_put(newList,"a","45");
map_put(newList,passString,secondString);
map_get(newList,secondString);
}
void map_init(map_t* self) {
map_entry_t* newNode= malloc(sizeof(map_entry_t)); // allocate
self->size = 0;
self->entry = newNode; // link next
}
int map_put(map_t* self, const char* key, const char* val) {
assert(self != NULL);
map_entry_t* current;
//current = self->entry->key;
while(current->next != NULL){
current = current->next;
}
self->entry->key = key;
self->entry->value = val;
map_entry_t* newNode = malloc(sizeof(map_entry_t));
printf("\ntry printing the list \n");
printf(self->entry->key);
printf(" :was the key and the value is \n");
printf(self->entry->value);
printf("\n");
}
const char* map_get(map_t* self, const char* key) {
assert(self != NULL);
const char* target = key;
int i=0;
for(i; i<=self->size; i++)
{
printf("\n\ninside the list\n");
printf(self->entry->value);
printf("\n");
}
}
int map_size(map_t* self) {
assert(self != NULL);
}
int map_remove(map_t* self, const char* key) {
assert(self != NULL);
}
int map_serialize(map_t* self, FILE* stream) {
assert(self != NULL);
}
int map_deserialize(map_t* self, FILE* stream) {
assert(self != NULL);
}
void map_destroy(map_t* self) {
assert(self != NULL);
}
map.h
#ifndef __A1_MAP_H__
#define __A1_MAP_H__
#include <stdio.h>
#define SYS_ERROR -1
#define OK 0
#define KEY_EXISTS 1
#define NO_KEY_EXISTS 2
// Strange type definition due to the recursive nature
// of the struct. This technique is called 'forward
// declaration' and is necessary for compilation reasons.
typedef struct _map_entry map_entry_t;
struct _map_entry {
char* key;
char* value;
map_entry_t* next;
} ;
typedef struct _map {
map_entry_t* entry;
int size;
} map_t;
// Part one functions.
void map_init(map_t*);
int map_put(map_t*, const char*, const char*);
const char* map_get(map_t*, const char*);
int map_remove(map_t*, const char*);
int map_size(map_t*);
void map_destroy(map_t*);
// Part two functions.
int map_serialize(map_t*, FILE*);
int map_deserialize(map_t*, FILE*);
#endif
#包括
#包括
#包括“map.h”
#包括
int main（）{
map_t*newList=malloc（sizeof（map_t））；
映射初始化（新列表）；
const char*passString=“a”；
常量字符*secondString=“2”；
地图（新列表，“3”、“3”）；
地图（新列表，“7”、“34”）；
地图（新列表，“a”、“45”）；
map_put（newList、passString、secondString）；
map_get（newList，secondString）；
}
无效映射初始化（映射自身）{
map_entry_t*newNode=malloc（sizeof（map_entry_t））；//分配
自->大小=0；
self->entry=newNode；//链接下一步
}
int map_put（map_t*self，const char*key，const char*val）{
断言（self！=NULL）；
地图输入*当前；
//当前=自->输入->键；
while（当前->下一步！=NULL）{
当前=当前->下一步；
}
自->输入->键=键；
自->录入->价值=val；
map_entry_t*newNode=malloc（sizeof（map_entry_t））；
printf（“\n尝试打印列表”\n”）；
printf（自->输入->键）；
printf（“：是键，值为\n”）；
printf（自->输入->值）；
printf（“\n”）；
}
常量字符*映射获取（映射自身，常量字符*键）{
断言（self！=NULL）；
常量字符*目标=键；
int i=0；
for（i；isize；i++）
{
printf（“\n\n在列表中\n”）；
printf（自->输入->值）；
printf（“\n”）；
}
}
整数映射大小（映射自身）{
断言（self！=NULL）；
}
int map_remove（map_t*self，const char*key）{
断言（self！=NULL）；
}
int map_序列化（map_t*self，FILE*stream）{
断言（self！=NULL）；
}
int map_反序列化（map_t*self，FILE*stream）{
断言（self！=NULL）；
}
无效映射销毁（映射自身）{
断言（self！=NULL）；
}
地图.h
#ifndef uuu A1 u地图H__
#定义地图__
#包括
#定义系统错误-1
#定义OK 0
#定义密钥\u存在1
#定义不存在密钥2
//由于递归性质，类型定义很奇怪
//结构的一部分。这种技术被称为“前进”
//声明”，并且出于汇编的原因是必要的。
typedef结构映射条目映射条目；
结构映射项{
字符*键；
字符*值；
地图输入下一步；
} ;
typedef结构映射{
地图输入项；
整数大小；
}地图；
//第一部分功能。
void map_init（map_t*）；
int map_put（map_t*，const char*，const char*）；
常量字符*map\u get（map\u t*，常量字符*）；
int map_remove（map_t*，const char*）；
int map_size（map_t*）；
无效地图（地图*）；
//第二部分功能。
int map_序列化（map_t*，FILE*）；
int map_反序列化（map_t*，FILE*）；
#恩迪夫
map\u putcurrentselfselfnewNode=current=selfself->newNodecurrentnext