teratail
回答率
85.36%
teratail header banner
teratail header banner
質問するログイン新規登録
トップに関する質問c言語でハッシュ表を実装したいです

編集履歴

質問編集履歴

13

エラーをなくしました

2021/01/12 15:05

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -276,6 +276,8 @@
276
276
 
277
277
  }
278
278
 
279
+ //構造体配列の場合、ここからの文がなくても削除できる
280
+
279
281
  /* リストの二番目以降のセルについて順番にチェックする */
280
282
 
281
283
  for(q=&table[h],p=q->next; p!=NULL; q=p,p=p->next){

12

エラーをなくしました

2021/01/12 15:05

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -10,22 +10,14 @@
10
10
 
11
11
  ### 発生している問題・エラーメッセージ
12
12
 
13
+
14
+
15
+
16
+
17
+ ### 該当のソースコード
18
+
13
19
  ```ここに言語を入力
14
20
 
15
- コード
16
-
17
-
18
-
19
-
20
-
21
- ### 該当のソースコード
22
-
23
- ```ここに言語を入力
24
-
25
-
26
-
27
- コード
28
-
29
21
  #include <stdio.h>
30
22
 
31
23
  #include <stdlib.h>
@@ -496,6 +488,8 @@
496
488
 
497
489
  ```
498
490
 
491
+
492
+
499
493
  3つの警告と1つのエラーが出ています
500
494
 
501
495
  ### 補足情報（FW/ツールのバージョンなど）

11

エラー処理をしました

2021/01/12 14:51

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -16,502 +16,486 @@
16
16
 
17
17
 
18
18
 
19
- Main.c:24:19: error: expression is not assignable
20
-
21
- &table[i] = NULL;
22
-
23
- ~~~~~~~~~ ^
24
-
25
- Main.c:130:18: error: expression is not assignable
26
-
27
- &table[h]=p->next;
28
-
29
- ~~~~~~~~~^
30
-
31
- 2 errors generated.
19
+
20
+
21
+ ### 該当のソースコード
22
+
23
+ ```ここに言語を入力
24
+
25
+
26
+
27
+ コード
28
+
29
+ #include <stdio.h>
30
+
31
+ #include <stdlib.h>
32
+
33
+
34
+
35
+ /* ハッシュ法の定義 */
36
+
37
+ #define BUCKET_SIZE 10 /* ハッシュ表の大きさ */
38
+
39
+
40
+
41
+ typedef struct cell{
42
+
43
+ int key;
44
+
45
+ double data;
46
+
47
+ struct cell *next;
48
+
49
+ } CELL;
50
+
51
+ /* ハッシュ表の本体はCELL型ポインタの配列として実現している */
52
+
53
+ CELL table[BUCKET_SIZE];
54
+
55
+
56
+
57
+ /* init --ハッシュ表を初期化する
58
+
59
+ ハッシュ表に含まれる全てのパケットにNULLをセット
60
+
61
+ ハッシュ表を使う前に必ずセットしなければならない */
62
+
63
+ void init()
64
+
65
+ {
66
+
67
+ int i;
68
+
69
+ /* BCKET_SIZEだけ繰り返して
70
+
71
+ table[i]の中をNULLにして空にする */
72
+
73
+ for(i=0; i<BUCKET_SIZE; i++)
74
+
75
+ table->next = NULL;
76
+
77
+ }
78
+
79
+
80
+
81
+ /* エラーメッセージをプリントしてexitする関数 */
82
+
83
+ /* ポインタ(アドレス)の先のデータを読み取り専用にする */
84
+
85
+ void fatal_error(char *s)
86
+
87
+ {
88
+
89
+ /* fprintf関数を使ってstderrで標準エラーを出力する*/
90
+
91
+ fprintf(stderr,"%s\n",s);
92
+
93
+ exit(1); /* 異常終了 */
94
+
95
+
96
+
97
+ }
98
+
99
+ /* ハッシュ値を計算する関数
100
+
101
+ パラメータとしてキーを与えると
102
+
103
+ そのキーに対するハッシュ値(int型)を返す*/
104
+
105
+ int hash(int s) //修正
106
+
107
+ {
108
+
109
+ /* キーの値を二乗してその中央値をとることで均等にしている */
110
+
111
+ 　　return(s % BUCKET_SIZE);
112
+
113
+ }
114
+
115
+
116
+
117
+ /* find -- ハッシュ表を探索する
118
+
119
+ 探したいキーの値をパラメータとして受け取る
120
+
121
+ 成功したらキーを持つDATAへのポインタを返す
122
+
123
+ (構造体CELL型のメンバdataへのポインタ)
124
+
125
+ 見つからなければNULLを返す */
126
+
127
+
128
+
129
+ CELL *find(int key)
130
+
131
+ {
132
+
133
+ CELL *p;
134
+
135
+ /* p=table[hash(key)]でそのキーが所属しているべきバケットから
136
+
137
+ 連結リストへのポインタを取り出している
138
+
139
+ for文本体では連結リストをたどりながら線形探索する */
140
+
141
+ for(p=&table[hash(key)]; p!=NULL; p=p->next)
142
+
143
+ /* もし2つのキーが等しければ成功 */
144
+
145
+ if(key==p->key)
146
+
147
+ /* キーを持つDATAへのポインタを返す */
148
+
149
+ return p;//&p->data;
150
+
151
+ else
152
+
153
+ /* 等しくなければ見つからないとしてNULLを返す*/
154
+
155
+ return NULL;
156
+
157
+ }
158
+
159
+ return NULL;
160
+
161
+ }
162
+
163
+
164
+
165
+ /* insert -- ハッシュ表にデータを挿入する
166
+
167
+ 2つのパラメータを受け取る
168
+
169
+ ①keyは挿入されるデータ持っているキーの値
170
+
171
+ ②dataはDATA *型で挿入されるデータへのポインタ
172
+
173
+ データを登録する際に同じキーを持つデータがすでに登録されているかどうかをチェックする
174
+
175
+ キーが重複していない場合、登録に成功したら1を返す
176
+
177
+ 登録に失敗(すでに同じキーを持つデータがある)
178
+
179
+ したら0を返す */
180
+
181
+
182
+
183
+ int insert(int key,double data)
184
+
185
+ {
186
+
187
+ CELL *p;
188
+
189
+ int h;
190
+
191
+
192
+
193
+ /* キーが重複していないか関数findを呼び出してチェックする
194
+
195
+ 重複していたら0を返す
196
+
197
+ もしNULLでないなら重複していない */
198
+
199
+ if(find(key) != NULL)
200
+
201
+ return 0;
202
+
203
+ /* もし重複していないなら関数mallocを呼び出し、
204
+
205
+ データを格納するセルを割り当てる */
206
+
207
+ if((p=malloc(sizeof(CELL))) == NULL){
208
+
209
+ /* もしセルの割り当てに失敗したらプログラムの実行を中止する */
210
+
211
+ fprintf(stderr,"out of momory\n");
212
+
213
+ exit(2);
214
+
215
+ }
216
+
217
+ /* セルを割り当てたらセルにキーとデータをセットして
218
+
219
+ キーの値に対応するバケットに連結する*/
220
+
221
+ h=hash(key);
222
+
223
+ p->key=key;
224
+
225
+ p->data=data;//*dataだった
226
+
227
+ p->next=&table[h];
228
+
229
+ table[h]=*p;
230
+
231
+ return 1;
232
+
233
+ }
234
+
235
+
236
+
237
+ /* delete -- ハッシュ表から削除する
238
+
239
+ 削除したいキーを受け取る
240
+
241
+ 該当するキーを持ったデータが存在し、
242
+
243
+ 削除に成功したら1を返す
244
+
245
+ 該当するキーを持ったデータが見つからなければ何もしないで、
246
+
247
+ 0を返す */
248
+
249
+ /* 最初にバケットを決め、
250
+
251
+ そのバケットに属する連結リストに対して削除の処理を行う */
252
+
253
+ int delete(int key)
254
+
255
+ {
256
+
257
+ int h;
258
+
259
+ CELL *p,*q;
260
+
261
+
262
+
263
+ h=hash(key);
264
+
265
+ /* そのバケットは空か */
266
+
267
+ if(&table[h] == NULL)
268
+
269
+ return 0;
270
+
271
+ /* リストの先頭のセルが削除すべきデータか？ */
272
+
273
+ if(key==table[h].key){
274
+
275
+ p=&table[h];
276
+
277
+ table->next=p->next;//&table[h]=p->next;
278
+
279
+ free(p);
280
+
281
+ /* 削除に成功したら1を返す */
282
+
283
+ return 1;
284
+
285
+ }
286
+
287
+ /* リストの二番目以降のセルについて順番にチェックする */
288
+
289
+ for(q=&table[h],p=q->next; p!=NULL; q=p,p=p->next){
290
+
291
+ if(key==p->key){
292
+
293
+ q->next=p->next;
294
+
295
+ free(p);
296
+
297
+ /* 削除に成功したら1を返す */
298
+
299
+ return 1;
300
+
301
+ }
302
+
303
+ }
304
+
305
+ /* 該当するキーを持ったデータが見つからなければ
306
+
307
+ 削除に失敗したとして0を返す */
308
+
309
+ return 0;
310
+
311
+ }
312
+
313
+
314
+
315
+
316
+
317
+
318
+
319
+ static void hash_print(void)
320
+
321
+ {
322
+
323
+ int i;
324
+
325
+ CELL *current = NULL;
326
+
327
+ /* バケットの数だけ繰り返す */
328
+
329
+ for(i = 0; i < BUCKET_SIZE; i++){
330
+
331
+ if(&table[i] != NULL){
332
+
333
+ printf("table[%d]",i);
334
+
335
+ /* currentをi番目にしておく */
336
+
337
+ current = &table[i];
338
+
339
+ /* currentがNULLでない間、次々表示させる*/
340
+
341
+ for(; current != NULL; current = current->next){
342
+
343
+ printf(" key=%d", (current->key));
344
+
345
+ printf(" data=%f", (current->data));
346
+
347
+ }
348
+
349
+ printf("\n");
350
+
351
+ }
352
+
353
+ }
354
+
355
+ }
356
+
357
+
358
+
359
+ int main(void)
360
+
361
+ {
362
+
363
+ /* ハッシュ表を初期化する */
364
+
365
+ init();
366
+
367
+ int key; /* 数字を入力するための配列変数 */
368
+
369
+ double data;
370
+
371
+ int hashval; /* hash関数のハッシュ値を受け取る変数 */
372
+
373
+ int mn=0; /* メニュー選択の数字を入れる変数 */
374
+
375
+ int a; /* insert関数の戻り値を受け取る変数 */
376
+
377
+ int c; /* delete関数の戻り値を受け取る変数 */
378
+
379
+ CELL *fp; /* find関数の戻り値を受け取る変数 */
380
+
381
+
382
+
383
+ printf("チェイン法をします\n");
384
+
385
+ do{
386
+
387
+ printf("メニューを選んでください\n1=追加 2=検索 3=削除 4＝ひょうじ 9=終了\n");
388
+
389
+ scanf("%d",&mn);
390
+
391
+ switch(mn){
392
+
393
+
394
+
395
+ case 1:
396
+
397
+ printf("8桁の数字を入力してください\n");
398
+
399
+ scanf("%d",&key);
400
+
401
+ printf("データを入力してください\n");
402
+
403
+ scanf("%lf",&data);
404
+
405
+ /* ハッシュ値を得る */
406
+
407
+ hashval=hash(key);
408
+
409
+ printf("数字＝%d ハッシュ値＝%d\n",key,hashval);
410
+
411
+ a=insert(key,data);
412
+
413
+ if(a==1)
414
+
415
+ printf("Done\n");
416
+
417
+ else
418
+
419
+ printf("AlreadyExsits\n");
420
+
421
+ break;
422
+
423
+
424
+
425
+ case 2:
426
+
427
+ printf("検索する8桁の数字を入力してください\n");
428
+
429
+ scanf("%d",&key);
430
+
431
+ fp=find(key);
432
+
433
+ if(fp==NULL)
434
+
435
+ printf("NotExsits\n");
436
+
437
+ else
438
+
439
+ printf("key=%d 検索した値＝%f\n",fp->key,fp->data);
440
+
441
+ break;
442
+
443
+
444
+
445
+ case 3:
446
+
447
+ printf("削除する8桁数字を入力してください\n");
448
+
449
+ scanf("%d",&key);
450
+
451
+ c=delete(key);
452
+
453
+ if(c==1)
454
+
455
+ printf("Done\n");
456
+
457
+ else
458
+
459
+ printf("NotExsits\n");
460
+
461
+ break;
462
+
463
+
464
+
465
+ case 4:
466
+
467
+ printf("ひょうじします\n");
468
+
469
+ /* リストの要素の値を表示する */
470
+
471
+ hash_print();
472
+
473
+ break;
474
+
475
+
476
+
477
+ case 9:
478
+
479
+ printf("終了します\n");
480
+
481
+ break;
482
+
483
+
484
+
485
+ default:
486
+
487
+ printf("エラー：メニューの中の数字を入力してください\n");
488
+
489
+ }
490
+
491
+ }while (mn !=9);
492
+
493
+ return 0;
494
+
495
+ }
32
496
 
33
497
  ```
34
498
 
35
-
36
-
37
- ### 該当のソースコード
38
-
39
- ```ここに言語を入力
40
-
41
-
42
-
43
- コード
44
-
45
- #include <stdio.h>
46
-
47
- #include <stdlib.h>
48
-
49
-
50
-
51
- /* ハッシュ法の定義 */
52
-
53
- #define BUCKET_SIZE 10 /* ハッシュ表の大きさ */
54
-
55
-
56
-
57
- typedef struct cell{
58
-
59
- int key;
60
-
61
- double data;
62
-
63
- struct cell *next;
64
-
65
- } CELL;
66
-
67
- /* ハッシュ表の本体はCELL型ポインタの配列として実現している */
68
-
69
- CELL table[BUCKET_SIZE];
70
-
71
-
72
-
73
- /* init --ハッシュ表を初期化する
74
-
75
- ハッシュ表に含まれる全てのパケットにNULLをセット
76
-
77
- ハッシュ表を使う前に必ずセットしなければならない */
78
-
79
- void init()
80
-
81
- {
82
-
83
- int i;
84
-
85
- /* BCKET_SIZEだけ繰り返して
86
-
87
- table[i]の中をNULLにして空にする */
88
-
89
- for(i=0; i<BUCKET_SIZE; i++)
90
-
91
- &table[i] = NULL;
92
-
93
- }
94
-
95
-
96
-
97
- /* エラーメッセージをプリントしてexitする関数 */
98
-
99
- /* ポインタ(アドレス)の先のデータを読み取り専用にする */
100
-
101
- void fatal_error(char *s)
102
-
103
- {
104
-
105
- /* fprintf関数を使ってstderrで標準エラーを出力する*/
106
-
107
- fprintf(stderr,"%s\n",s);
108
-
109
- exit(1); /* 異常終了 */
110
-
111
-
112
-
113
- }
114
-
115
- /* ハッシュ値を計算する関数
116
-
117
- パラメータとしてキーを与えると
118
-
119
- そのキーに対するハッシュ値(int型)を返す*/
120
-
121
- int hash(int s) //修正
122
-
123
- {
124
-
125
- /* キーの値を二乗してその中央値をとることで均等にしている */
126
-
127
- 　　return(s % BUCKET_SIZE);
128
-
129
- }
130
-
131
-
132
-
133
- /* find -- ハッシュ表を探索する
134
-
135
- 探したいキーの値をパラメータとして受け取る
136
-
137
- 成功したらキーを持つDATAへのポインタを返す
138
-
139
- (構造体CELL型のメンバdataへのポインタ)
140
-
141
- 見つからなければNULLを返す */
142
-
143
-
144
-
145
- CELL *find(int key)
146
-
147
- {
148
-
149
- CELL *p;
150
-
151
- /* p=table[hash(key)]でそのキーが所属しているべきバケットから
152
-
153
- 連結リストへのポインタを取り出している
154
-
155
- for文本体では連結リストをたどりながら線形探索する */
156
-
157
- for(p=&table[hash(key)]; p!=NULL; p=p->next)
158
-
159
- /* もし2つのキーが等しければ成功 */
160
-
161
- if(key==p->key)
162
-
163
- /* キーを持つDATAへのポインタを返す */
164
-
165
- return p;//&p->data;
166
-
167
- else
168
-
169
- /* 等しくなければ見つからないとしてNULLを返す*/
170
-
171
- return NULL;
172
-
173
- }
174
-
175
- return NULL;
176
-
177
- }
178
-
179
-
180
-
181
- /* insert -- ハッシュ表にデータを挿入する
182
-
183
- 2つのパラメータを受け取る
184
-
185
- ①keyは挿入されるデータ持っているキーの値
186
-
187
- ②dataはDATA *型で挿入されるデータへのポインタ
188
-
189
- データを登録する際に同じキーを持つデータがすでに登録されているかどうかをチェックする
190
-
191
- キーが重複していない場合、登録に成功したら1を返す
192
-
193
- 登録に失敗(すでに同じキーを持つデータがある)
194
-
195
- したら0を返す */
196
-
197
-
198
-
199
- int insert(int key,double data)
200
-
201
- {
202
-
203
- CELL *p;
204
-
205
- int h;
206
-
207
-
208
-
209
- /* キーが重複していないか関数findを呼び出してチェックする
210
-
211
- 重複していたら0を返す
212
-
213
- もしNULLでないなら重複していない */
214
-
215
- if(find(key) != NULL)
216
-
217
- return 0;
218
-
219
- /* もし重複していないなら関数mallocを呼び出し、
220
-
221
- データを格納するセルを割り当てる */
222
-
223
- if((p=malloc(sizeof(CELL))) == NULL){
224
-
225
- /* もしセルの割り当てに失敗したらプログラムの実行を中止する */
226
-
227
- fprintf(stderr,"out of momory\n");
228
-
229
- exit(2);
230
-
231
- }
232
-
233
- /* セルを割り当てたらセルにキーとデータをセットして
234
-
235
- キーの値に対応するバケットに連結する*/
236
-
237
- h=hash(key);
238
-
239
- p->key=key;
240
-
241
- p->data=data;//*dataだった
242
-
243
- p->next=&table[h];
244
-
245
- table[h]=*p;
246
-
247
- return 1;
248
-
249
- }
250
-
251
-
252
-
253
- /* delete -- ハッシュ表から削除する
254
-
255
- 削除したいキーを受け取る
256
-
257
- 該当するキーを持ったデータが存在し、
258
-
259
- 削除に成功したら1を返す
260
-
261
- 該当するキーを持ったデータが見つからなければ何もしないで、
262
-
263
- 0を返す */
264
-
265
- /* 最初にバケットを決め、
266
-
267
- そのバケットに属する連結リストに対して削除の処理を行う */
268
-
269
- int delete(int key)
270
-
271
- {
272
-
273
- int h;
274
-
275
- CELL *p,*q;
276
-
277
-
278
-
279
- h=hash(key);
280
-
281
- /* そのバケットは空か */
282
-
283
- if(&table[h] == NULL)
284
-
285
- return 0;
286
-
287
- /* リストの先頭のセルが削除すべきデータか？ */
288
-
289
- if(key==table[h].key){
290
-
291
- p=&table[h];
292
-
293
- &table[h]=p->next;
294
-
295
- free(p);
296
-
297
- /* 削除に成功したら1を返す */
298
-
299
- return 1;
300
-
301
- }
302
-
303
- /* リストの二番目以降のセルについて順番にチェックする */
304
-
305
- for(q=&table[h],p=q->next; p!=NULL; q=p,p=p->next){
306
-
307
- if(key==p->key){
308
-
309
- q->next=p->next;
310
-
311
- free(p);
312
-
313
- /* 削除に成功したら1を返す */
314
-
315
- return 1;
316
-
317
- }
318
-
319
- }
320
-
321
- /* 該当するキーを持ったデータが見つからなければ
322
-
323
- 削除に失敗したとして0を返す */
324
-
325
- return 0;
326
-
327
- }
328
-
329
-
330
-
331
-
332
-
333
-
334
-
335
- static void hash_print(void)
336
-
337
- {
338
-
339
- int i;
340
-
341
- CELL *current = NULL;
342
-
343
- /* バケットの数だけ繰り返す */
344
-
345
- for(i = 0; i < BUCKET_SIZE; i++){
346
-
347
- if(&table[i] != NULL){
348
-
349
- printf("table[%d]",i);
350
-
351
- /* currentをi番目にしておく */
352
-
353
- current = &table[i];
354
-
355
- /* currentがNULLでない間、次々表示させる*/
356
-
357
- for(; current != NULL; current = current->next){
358
-
359
- printf(" key=%d", (current->key));
360
-
361
- printf(" data=%f", (current->data));
362
-
363
- }
364
-
365
- printf("\n");
366
-
367
- }
368
-
369
- }
370
-
371
- }
372
-
373
-
374
-
375
- int main(void)
376
-
377
- {
378
-
379
- /* ハッシュ表を初期化する */
380
-
381
- init();
382
-
383
- int key; /* 数字を入力するための配列変数 */
384
-
385
- double data;
386
-
387
- int hashval; /* hash関数のハッシュ値を受け取る変数 */
388
-
389
- int mn=0; /* メニュー選択の数字を入れる変数 */
390
-
391
- int a; /* insert関数の戻り値を受け取る変数 */
392
-
393
- int c; /* delete関数の戻り値を受け取る変数 */
394
-
395
- CELL *fp; /* find関数の戻り値を受け取る変数 */
396
-
397
-
398
-
399
- printf("チェイン法をします\n");
400
-
401
- do{
402
-
403
- printf("メニューを選んでください\n1=追加 2=検索 3=削除 4＝ひょうじ 9=終了\n");
404
-
405
- scanf("%d",&mn);
406
-
407
- switch(mn){
408
-
409
-
410
-
411
- case 1:
412
-
413
- printf("8桁の数字を入力してください\n");
414
-
415
- scanf("%d",&key);
416
-
417
- printf("データを入力してください\n");
418
-
419
- scanf("%lf",&data);
420
-
421
- /* ハッシュ値を得る */
422
-
423
- hashval=hash(key);
424
-
425
- printf("数字＝%d ハッシュ値＝%d\n",key,hashval);
426
-
427
- a=insert(key,data);
428
-
429
- if(a==1)
430
-
431
- printf("Done\n");
432
-
433
- else
434
-
435
- printf("AlreadyExsits\n");
436
-
437
- break;
438
-
439
-
440
-
441
- case 2:
442
-
443
- printf("検索する8桁の数字を入力してください\n");
444
-
445
- scanf("%d",&key);
446
-
447
- fp=find(key);
448
-
449
- if(fp==NULL)
450
-
451
- printf("NotExsits\n");
452
-
453
- else
454
-
455
- printf("key=%d 検索した値＝%f\n",fp->key,fp->data);
456
-
457
- break;
458
-
459
-
460
-
461
- case 3:
462
-
463
- printf("削除する8桁数字を入力してください\n");
464
-
465
- scanf("%d",&key);
466
-
467
- c=delete(key);
468
-
469
- if(c==1)
470
-
471
- printf("Done\n");
472
-
473
- else
474
-
475
- printf("NotExsits\n");
476
-
477
- break;
478
-
479
-
480
-
481
- case 4:
482
-
483
- printf("ひょうじします\n");
484
-
485
- /* リストの要素の値を表示する */
486
-
487
- hash_print();
488
-
489
- break;
490
-
491
-
492
-
493
- case 9:
494
-
495
- printf("終了します\n");
496
-
497
- break;
498
-
499
-
500
-
501
- default:
502
-
503
- printf("エラー：メニューの中の数字を入力してください\n");
504
-
505
- }
506
-
507
- }while (mn !=9);
508
-
509
- return 0;
510
-
511
- }
512
-
513
- ```
514
-
515
499
  3つの警告と1つのエラーが出ています
516
500
 
517
501
  ### 補足情報（FW/ツールのバージョンなど）

10

エラー処理です

2021/01/12 14:50

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -170,6 +170,10 @@
170
170
 
171
171
  return NULL;
172
172
 
173
+ }
174
+
175
+ return NULL;
176
+
173
177
  }
174
178
 
175
179
 

9

インデント直しました

2021/01/12 14:38

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -10,7 +10,27 @@
10
10
 
11
11
  ### 発生している問題・エラーメッセージ
12
12
 
13
-
13
+ ```ここに言語を入力
14
+
15
+ コード
16
+
17
+
18
+
19
+ Main.c:24:19: error: expression is not assignable
20
+
21
+ &table[i] = NULL;
22
+
23
+ ~~~~~~~~~ ^
24
+
25
+ Main.c:130:18: error: expression is not assignable
26
+
27
+ &table[h]=p->next;
28
+
29
+ ~~~~~~~~~^
30
+
31
+ 2 errors generated.
32
+
33
+ ```
14
34
 
15
35
 
16
36
 
@@ -44,7 +64,7 @@
44
64
 
45
65
  } CELL;
46
66
 
47
- /* ハッシュ表の本体は構造体配列配列 */
67
+ /* ハッシュ表の本体はCELL型ポインタの配列として実現している */
48
68
 
49
69
  CELL table[BUCKET_SIZE];
50
70
 
@@ -68,7 +88,7 @@
68
88
 
69
89
  for(i=0; i<BUCKET_SIZE; i++)
70
90
 
71
- table[i]=NULL;
91
+ &table[i] = NULL;
72
92
 
73
93
  }
74
94
 
@@ -98,13 +118,13 @@
98
118
 
99
119
  そのキーに対するハッシュ値(int型)を返す*/
100
120
 
101
- int hash(int s)
121
+ int hash(int s) //修正
102
122
 
103
123
  {
104
124
 
105
125
  /* キーの値を二乗してその中央値をとることで均等にしている */
106
126
 
107
- return(s % BUCKET_SIZE);
127
+ 　　return(s % BUCKET_SIZE);
108
128
 
109
129
  }
110
130
 
@@ -134,7 +154,7 @@
134
154
 
135
155
  for文本体では連結リストをたどりながら線形探索する */
136
156
 
137
- for(p=table[hash(key)]; p!=NULL; p=p->next)
157
+ for(p=&table[hash(key)]; p!=NULL; p=p->next)
138
158
 
139
159
  /* もし2つのキーが等しければ成功 */
140
160
 
@@ -142,7 +162,7 @@
142
162
 
143
163
  /* キーを持つDATAへのポインタを返す */
144
164
 
145
- return p; //&p->data;
165
+ return p;//&p->data;
146
166
 
147
167
  else
148
168
 
@@ -214,11 +234,11 @@
214
234
 
215
235
  p->key=key;
216
236
 
217
- p->data=data;
237
+ p->data=data;//*dataだった
218
-
238
+
219
- p->next=table[h];
239
+ p->next=&table[h];
220
-
240
+
221
- table[h]=p;
241
+ table[h]=*p;
222
242
 
223
243
  return 1;
224
244
 
@@ -256,17 +276,17 @@
256
276
 
257
277
  /* そのバケットは空か */
258
278
 
259
- if(table[h] == NULL)
279
+ if(&table[h] == NULL)
260
280
 
261
281
  return 0;
262
282
 
263
283
  /* リストの先頭のセルが削除すべきデータか？ */
264
284
 
265
- if(key==table[h]->key){
285
+ if(key==table[h].key){
266
-
286
+
267
- p=table[h];
287
+ p=&table[h];
268
-
288
+
269
- table[h]=p->next;
289
+ &table[h]=p->next;
270
290
 
271
291
  free(p);
272
292
 
@@ -278,7 +298,7 @@
278
298
 
279
299
  /* リストの二番目以降のセルについて順番にチェックする */
280
300
 
281
- for(q=table[h],p=q->next; p!=NULL; q=p,p=p->next){
301
+ for(q=&table[h],p=q->next; p!=NULL; q=p,p=p->next){
282
302
 
283
303
  if(key==p->key){
284
304
 
@@ -320,13 +340,13 @@
320
340
 
321
341
  for(i = 0; i < BUCKET_SIZE; i++){
322
342
 
323
- if(table[i] != NULL){
343
+ if(&table[i] != NULL){
324
344
 
325
345
  printf("table[%d]",i);
326
346
 
327
347
  /* currentをi番目にしておく */
328
348
 
329
- current = table[i];
349
+ current = &table[i];
330
350
 
331
351
  /* currentがNULLでない間、次々表示させる*/
332
352
 

8

インデントを直しました

2021/01/12 11:02

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -12,546 +12,482 @@
12
12
 
13
13
 
14
14
 
15
+
16
+
17
+ ### 該当のソースコード
18
+
19
+ ```ここに言語を入力
20
+
21
+
22
+
23
+ コード
24
+
25
+ #include <stdio.h>
26
+
27
+ #include <stdlib.h>
28
+
29
+
30
+
31
+ /* ハッシュ法の定義 */
32
+
33
+ #define BUCKET_SIZE 10 /* ハッシュ表の大きさ */
34
+
35
+
36
+
37
+ typedef struct cell{
38
+
39
+ int key;
40
+
41
+ double data;
42
+
43
+ struct cell *next;
44
+
45
+ } CELL;
46
+
47
+ /* ハッシュ表の本体は構造体配列配列 */
48
+
49
+ CELL table[BUCKET_SIZE];
50
+
51
+
52
+
53
+ /* init --ハッシュ表を初期化する
54
+
55
+ ハッシュ表に含まれる全てのパケットにNULLをセット
56
+
57
+ ハッシュ表を使う前に必ずセットしなければならない */
58
+
59
+ void init()
60
+
61
+ {
62
+
63
+ int i;
64
+
65
+ /* BCKET_SIZEだけ繰り返して
66
+
67
+ table[i]の中をNULLにして空にする */
68
+
69
+ for(i=0; i<BUCKET_SIZE; i++)
70
+
71
+ table[i]=NULL;
72
+
73
+ }
74
+
75
+
76
+
77
+ /* エラーメッセージをプリントしてexitする関数 */
78
+
79
+ /* ポインタ(アドレス)の先のデータを読み取り専用にする */
80
+
81
+ void fatal_error(char *s)
82
+
83
+ {
84
+
85
+ /* fprintf関数を使ってstderrで標準エラーを出力する*/
86
+
87
+ fprintf(stderr,"%s\n",s);
88
+
89
+ exit(1); /* 異常終了 */
90
+
91
+
92
+
93
+ }
94
+
95
+ /* ハッシュ値を計算する関数
96
+
97
+ パラメータとしてキーを与えると
98
+
99
+ そのキーに対するハッシュ値(int型)を返す*/
100
+
101
+ int hash(int s)
102
+
103
+ {
104
+
105
+ /* キーの値を二乗してその中央値をとることで均等にしている */
106
+
107
+ return(s % BUCKET_SIZE);
108
+
109
+ }
110
+
111
+
112
+
113
+ /* find -- ハッシュ表を探索する
114
+
115
+ 探したいキーの値をパラメータとして受け取る
116
+
117
+ 成功したらキーを持つDATAへのポインタを返す
118
+
119
+ (構造体CELL型のメンバdataへのポインタ)
120
+
121
+ 見つからなければNULLを返す */
122
+
123
+
124
+
125
+ CELL *find(int key)
126
+
127
+ {
128
+
129
+ CELL *p;
130
+
131
+ /* p=table[hash(key)]でそのキーが所属しているべきバケットから
132
+
133
+ 連結リストへのポインタを取り出している
134
+
135
+ for文本体では連結リストをたどりながら線形探索する */
136
+
137
+ for(p=table[hash(key)]; p!=NULL; p=p->next)
138
+
139
+ /* もし2つのキーが等しければ成功 */
140
+
141
+ if(key==p->key)
142
+
143
+ /* キーを持つDATAへのポインタを返す */
144
+
145
+ return p; //&p->data;
146
+
147
+ else
148
+
149
+ /* 等しくなければ見つからないとしてNULLを返す*/
150
+
151
+ return NULL;
152
+
153
+ }
154
+
155
+
156
+
157
+ /* insert -- ハッシュ表にデータを挿入する
158
+
159
+ 2つのパラメータを受け取る
160
+
161
+ ①keyは挿入されるデータ持っているキーの値
162
+
163
+ ②dataはDATA *型で挿入されるデータへのポインタ
164
+
165
+ データを登録する際に同じキーを持つデータがすでに登録されているかどうかをチェックする
166
+
167
+ キーが重複していない場合、登録に成功したら1を返す
168
+
169
+ 登録に失敗(すでに同じキーを持つデータがある)
170
+
171
+ したら0を返す */
172
+
173
+
174
+
175
+ int insert(int key,double data)
176
+
177
+ {
178
+
179
+ CELL *p;
180
+
181
+ int h;
182
+
183
+
184
+
185
+ /* キーが重複していないか関数findを呼び出してチェックする
186
+
187
+ 重複していたら0を返す
188
+
189
+ もしNULLでないなら重複していない */
190
+
191
+ if(find(key) != NULL)
192
+
193
+ return 0;
194
+
195
+ /* もし重複していないなら関数mallocを呼び出し、
196
+
197
+ データを格納するセルを割り当てる */
198
+
199
+ if((p=malloc(sizeof(CELL))) == NULL){
200
+
201
+ /* もしセルの割り当てに失敗したらプログラムの実行を中止する */
202
+
203
+ fprintf(stderr,"out of momory\n");
204
+
205
+ exit(2);
206
+
207
+ }
208
+
209
+ /* セルを割り当てたらセルにキーとデータをセットして
210
+
211
+ キーの値に対応するバケットに連結する*/
212
+
213
+ h=hash(key);
214
+
215
+ p->key=key;
216
+
217
+ p->data=data;
218
+
219
+ p->next=table[h];
220
+
221
+ table[h]=p;
222
+
223
+ return 1;
224
+
225
+ }
226
+
227
+
228
+
229
+ /* delete -- ハッシュ表から削除する
230
+
231
+ 削除したいキーを受け取る
232
+
233
+ 該当するキーを持ったデータが存在し、
234
+
235
+ 削除に成功したら1を返す
236
+
237
+ 該当するキーを持ったデータが見つからなければ何もしないで、
238
+
239
+ 0を返す */
240
+
241
+ /* 最初にバケットを決め、
242
+
243
+ そのバケットに属する連結リストに対して削除の処理を行う */
244
+
245
+ int delete(int key)
246
+
247
+ {
248
+
249
+ int h;
250
+
251
+ CELL *p,*q;
252
+
253
+
254
+
255
+ h=hash(key);
256
+
257
+ /* そのバケットは空か */
258
+
259
+ if(table[h] == NULL)
260
+
261
+ return 0;
262
+
263
+ /* リストの先頭のセルが削除すべきデータか？ */
264
+
265
+ if(key==table[h]->key){
266
+
267
+ p=table[h];
268
+
269
+ table[h]=p->next;
270
+
271
+ free(p);
272
+
273
+ /* 削除に成功したら1を返す */
274
+
275
+ return 1;
276
+
277
+ }
278
+
279
+ /* リストの二番目以降のセルについて順番にチェックする */
280
+
281
+ for(q=table[h],p=q->next; p!=NULL; q=p,p=p->next){
282
+
283
+ if(key==p->key){
284
+
285
+ q->next=p->next;
286
+
287
+ free(p);
288
+
289
+ /* 削除に成功したら1を返す */
290
+
291
+ return 1;
292
+
293
+ }
294
+
295
+ }
296
+
297
+ /* 該当するキーを持ったデータが見つからなければ
298
+
299
+ 削除に失敗したとして0を返す */
300
+
301
+ return 0;
302
+
303
+ }
304
+
305
+
306
+
307
+
308
+
309
+
310
+
311
+ static void hash_print(void)
312
+
313
+ {
314
+
315
+ int i;
316
+
317
+ CELL *current = NULL;
318
+
319
+ /* バケットの数だけ繰り返す */
320
+
321
+ for(i = 0; i < BUCKET_SIZE; i++){
322
+
323
+ if(table[i] != NULL){
324
+
325
+ printf("table[%d]",i);
326
+
327
+ /* currentをi番目にしておく */
328
+
329
+ current = table[i];
330
+
331
+ /* currentがNULLでない間、次々表示させる*/
332
+
333
+ for(; current != NULL; current = current->next){
334
+
335
+ printf(" key=%d", (current->key));
336
+
337
+ printf(" data=%f", (current->data));
338
+
339
+ }
340
+
341
+ printf("\n");
342
+
343
+ }
344
+
345
+ }
346
+
347
+ }
348
+
349
+
350
+
351
+ int main(void)
352
+
353
+ {
354
+
355
+ /* ハッシュ表を初期化する */
356
+
357
+ init();
358
+
359
+ int key; /* 数字を入力するための配列変数 */
360
+
361
+ double data;
362
+
363
+ int hashval; /* hash関数のハッシュ値を受け取る変数 */
364
+
365
+ int mn=0; /* メニュー選択の数字を入れる変数 */
366
+
367
+ int a; /* insert関数の戻り値を受け取る変数 */
368
+
369
+ int c; /* delete関数の戻り値を受け取る変数 */
370
+
371
+ CELL *fp; /* find関数の戻り値を受け取る変数 */
372
+
373
+
374
+
375
+ printf("チェイン法をします\n");
376
+
377
+ do{
378
+
379
+ printf("メニューを選んでください\n1=追加 2=検索 3=削除 4＝ひょうじ 9=終了\n");
380
+
381
+ scanf("%d",&mn);
382
+
383
+ switch(mn){
384
+
385
+
386
+
387
+ case 1:
388
+
389
+ printf("8桁の数字を入力してください\n");
390
+
391
+ scanf("%d",&key);
392
+
393
+ printf("データを入力してください\n");
394
+
395
+ scanf("%lf",&data);
396
+
397
+ /* ハッシュ値を得る */
398
+
399
+ hashval=hash(key);
400
+
401
+ printf("数字＝%d ハッシュ値＝%d\n",key,hashval);
402
+
403
+ a=insert(key,data);
404
+
405
+ if(a==1)
406
+
407
+ printf("Done\n");
408
+
409
+ else
410
+
411
+ printf("AlreadyExsits\n");
412
+
413
+ break;
414
+
415
+
416
+
417
+ case 2:
418
+
419
+ printf("検索する8桁の数字を入力してください\n");
420
+
421
+ scanf("%d",&key);
422
+
423
+ fp=find(key);
424
+
425
+ if(fp==NULL)
426
+
427
+ printf("NotExsits\n");
428
+
429
+ else
430
+
431
+ printf("key=%d 検索した値＝%f\n",fp->key,fp->data);
432
+
433
+ break;
434
+
435
+
436
+
437
+ case 3:
438
+
439
+ printf("削除する8桁数字を入力してください\n");
440
+
441
+ scanf("%d",&key);
442
+
443
+ c=delete(key);
444
+
445
+ if(c==1)
446
+
447
+ printf("Done\n");
448
+
449
+ else
450
+
451
+ printf("NotExsits\n");
452
+
453
+ break;
454
+
455
+
456
+
457
+ case 4:
458
+
459
+ printf("ひょうじします\n");
460
+
461
+ /* リストの要素の値を表示する */
462
+
463
+ hash_print();
464
+
465
+ break;
466
+
467
+
468
+
469
+ case 9:
470
+
471
+ printf("終了します\n");
472
+
473
+ break;
474
+
475
+
476
+
477
+ default:
478
+
479
+ printf("エラー：メニューの中の数字を入力してください\n");
480
+
481
+ }
482
+
483
+ }while (mn !=9);
484
+
485
+ return 0;
486
+
487
+ }
488
+
15
489
  ```
16
490
 
17
- エラーメッセージ
18
-
19
- `Main.c:72:1: warning: non-void function does not return a value in all control paths [-Wreturn-type]
20
-
21
- }
22
-
23
- ^
24
-
25
- Main.c:104:10: error: indirection requires pointer operand ('double' invalid)
26
-
27
- p->data=*data;
28
-
29
- ^~~~~
30
-
31
- Main.c:210:14: warning: incompatible pointer to integer conversion assigning to 'int' from 'double *' [-Wint-conversion]
32
-
33
- f=find(key);
34
-
35
- ^~~~~~~~~~
36
-
37
- Main.c:211:17: warning: comparison between pointer and integer ('int' and 'void *') [-Wpointer-integer-compare]
38
-
39
- if(f==NULL)
40
-
41
- ~^ ~~~~
42
-
43
- 3 warnings and 1 error generated.
44
-
45
- ``
46
-
47
-
48
-
49
- ### 該当のソースコード
50
-
51
- ```ｃ
52
-
53
- ```ｃ
54
-
55
- ```#include <stdio.h>
56
-
57
- #include <stdlib.h>
58
-
59
-
60
-
61
- /* ハッシュ法の定義 */
62
-
63
- #define BUCKET_SIZE 10 /* ハッシュ表の大きさ */
64
-
65
-
66
-
67
- typedef struct cell{
68
-
69
- int key;
70
-
71
- double data;
72
-
73
- struct cell *next;
74
-
75
- } CELL;
76
-
77
- /* ハッシュ表の本体はCELL型ポインタの配列として実現している */
78
-
79
- CELL *table[BUCKET_SIZE];
80
-
81
-
82
-
83
- /* init --ハッシュ表を初期化する
84
-
85
- ハッシュ表に含まれる全てのパケットにNULLをセット
86
-
87
- ハッシュ表を使う前に必ずセットしなければならない */
88
-
89
- void init()
90
-
91
- {
92
-
93
- int i;
94
-
95
- /* BCKET_SIZEだけ繰り返して
96
-
97
- table[i]の中をNULLにして空にする */
98
-
99
- for(i=0; i<BUCKET_SIZE; i++)
100
-
101
- table[i]=NULL;
102
-
103
- }
104
-
105
-
106
-
107
- /* エラーメッセージをプリントしてexitする関数 */
108
-
109
- /* ポインタ(アドレス)の先のデータを読み取り専用にする */
110
-
111
- void fatal_error(char *s)
112
-
113
- {
114
-
115
- /* fprintf関数を使ってstderrで標準エラーを出力する*/
116
-
117
- fprintf(stderr,"%s\n",s);
118
-
119
- exit(1); /* 異常終了 */
120
-
121
-
122
-
123
- }
124
-
125
- /* ハッシュ値を計算する関数
126
-
127
- パラメータとしてキーを与えると
128
-
129
- そのキーに対するハッシュ値(int型)を返す*/
130
-
131
- int hash(int s)
132
-
133
- {
134
-
135
- /* キーの値を二乗してその中央値をとることで均等にしている */
136
-
137
- //int i= 0;
138
-
139
- /* *sの値が0以外の時に繰り返す
140
-
141
- C言語では、0が偽、0以外が真という意味を持つ
142
-
143
- whileは、()の中の式を見ているのではなく、その値が0かどうかだけしか見ていない。
144
-
145
- 値が0になると、偽と見なしてループを抜ける。*/
146
-
147
- //while(*s)
148
-
149
- //i += *s++;
150
-
151
- return(s % BUCKET_SIZE);
152
-
153
- }
154
-
155
-
156
-
157
- /* find -- ハッシュ表を探索する
158
-
159
- 探したいキーの値をパラメータとして受け取る
160
-
161
- 成功したらキーを持つDATAへのポインタを返す
162
-
163
- (構造体CELL型のメンバdataへのポインタ)
164
-
165
- 見つからなければNULLを返す */
166
-
167
-
168
-
169
- double *find(int key)
170
-
171
- {
172
-
173
- CELL *p;
174
-
175
- /* p=table[hash(key)]でそのキーが所属しているべきバケットから
176
-
177
- 連結リストへのポインタを取り出している
178
-
179
- for文本体では連結リストをたどりながら線形探索する */
180
-
181
- for(p=table[hash(key)]; p!=NULL; p=p->next)
182
-
183
- /* もし2つのキーが等しければ成功 */
184
-
185
- if(key==p->key)
186
-
187
- /* キーを持つDATAへのポインタを返す */
188
-
189
- return &p->data;
190
-
191
- else
192
-
193
- /* 等しくなければ見つからないとしてNULLを返す*/
194
-
195
- return NULL;
196
-
197
- }
198
-
199
-
200
-
201
- /* insert -- ハッシュ表にデータを挿入する
202
-
203
- 2つのパラメータを受け取る
204
-
205
- ①keyは挿入されるデータ持っているキーの値
206
-
207
- ②dataはDATA *型で挿入されるデータへのポインタ
208
-
209
- データを登録する際に同じキーを持つデータがすでに登録されているかどうかをチェックする
210
-
211
- キーが重複していない場合、登録に成功したら1を返す
212
-
213
- 登録に失敗(すでに同じキーを持つデータがある)
214
-
215
- したら0を返す */
216
-
217
-
218
-
219
- int insert(int key,double data)
220
-
221
- {
222
-
223
- CELL *p;
224
-
225
- int h;
226
-
227
-
228
-
229
- /* キーが重複していないか関数findを呼び出してチェックする
230
-
231
- 重複していたら0を返す
232
-
233
- もしNULLでないなら重複していない */
234
-
235
- if(find(key) != NULL)
236
-
237
- return 0;
238
-
239
- /* もし重複していないなら関数mallocを呼び出し、
240
-
241
- データを格納するセルを割り当てる */
242
-
243
- if((p=malloc(sizeof(CELL))) == NULL){
244
-
245
- /* もしセルの割り当てに失敗したらプログラムの実行を中止する */
246
-
247
- fprintf(stderr,"out of momory\n");
248
-
249
- exit(2);
250
-
251
- }
252
-
253
- /* セルを割り当てたらセルにキーとデータをセットして
254
-
255
- キーの値に対応するバケットに連結する*/
256
-
257
- h=hash(key);
258
-
259
- p->key=key;
260
-
261
- p->data=*data;
262
-
263
- p->next=table[h];
264
-
265
- table[h]=p;
266
-
267
- return 1;
268
-
269
- }
270
-
271
-
272
-
273
- /* delete -- ハッシュ表から削除する
274
-
275
- 削除したいキーを受け取る
276
-
277
- 該当するキーを持ったデータが存在し、
278
-
279
- 削除に成功したら1を返す
280
-
281
- 該当するキーを持ったデータが見つからなければ何もしないで、
282
-
283
- 0を返す */
284
-
285
- /* 最初にバケットを決め、
286
-
287
- そのバケットに属する連結リストに対して削除の処理を行う */
288
-
289
- int delete(int key)
290
-
291
- {
292
-
293
- int h;
294
-
295
- CELL *p,*q;
296
-
297
-
298
-
299
- h=hash(key);
300
-
301
- /* そのバケットは空か */
302
-
303
- if(table[h] == NULL)
304
-
305
- return 0;
306
-
307
- /* リストの先頭のセルが削除すべきデータか？ */
308
-
309
- if(key==table[h]->key){
310
-
311
- p=table[h];
312
-
313
- table[h]=p->next;
314
-
315
- free(p);
316
-
317
- /* 削除に成功したら1を返す */
318
-
319
- return 1;
320
-
321
- }
322
-
323
- /* リストの二番目以降のセルについて順番にチェックする */
324
-
325
- for(q=table[h],p=q->next; p!=NULL; q=p,p=p->next){
326
-
327
- if(key==p->key){
328
-
329
- q->next=p->next;
330
-
331
- free(p);
332
-
333
- /* 削除に成功したら1を返す */
334
-
335
- return 1;
336
-
337
- }
338
-
339
- }
340
-
341
- /* 該当するキーを持ったデータが見つからなければ
342
-
343
- 削除に失敗したとして0を返す */
344
-
345
- return 0;
346
-
347
- }
348
-
349
-
350
-
351
-
352
-
353
-
354
-
355
- static void hash_print(double data)
356
-
357
- {
358
-
359
- int i;
360
-
361
- struct cell *current = NULL;
362
-
363
- /* バケットの数だけ繰り返す */
364
-
365
- for(i = 0; i < BUCKET_SIZE; i++){
366
-
367
- if(table[i] != NULL){
368
-
369
- printf("%d番目",i);
370
-
371
- /* currentをi番目にしておく */
372
-
373
- current = table[i];
374
-
375
- /* currentがNULLでない間、次々表示させる*/
376
-
377
- for(current=table[i]; current!= NULL; current = current->next){
378
-
379
- printf(" key=%d", (current->key));
380
-
381
- printf(" data=%lf", (current->data));
382
-
383
- }
384
-
385
- printf("\n");
386
-
387
- }
388
-
389
- }
390
-
391
- }
392
-
393
-
394
-
395
- int main(void)
396
-
397
- {
398
-
399
- int key; /* 数字を入力するための配列変数 */
400
-
401
- double data;
402
-
403
- int hashval; /* hash関数のハッシュ値を受け取る変数 */
404
-
405
- int mn=0; /* メニュー選択の数字を入れる変数 */
406
-
407
- int a; /* insert関数の戻り値を受け取る変数 */
408
-
409
- int c; /* delete関数の戻り値を受け取る変数 */
410
-
411
- //int p; /* hash_print関数の戻り値を受け取る変数 */
412
-
413
- int f; /* find関数の戻り値を受け取る変数 */
414
-
415
-
416
-
417
- /* ハッシュ表を初期化する */
418
-
419
- init();
420
-
421
-
422
-
423
- printf("チェイン法をします\n");
424
-
425
- do{
426
-
427
- printf("メニューを選んでください\n1=追加 2=検索 3=削除 4＝ひょうじ 9=終了\n");
428
-
429
- scanf("%d",&mn);
430
-
431
- switch(mn){
432
-
433
-
434
-
435
- case 1:
436
-
437
- printf("8桁の数字を入力してください\n");
438
-
439
- scanf("%d",&key);
440
-
441
- printf("データを入力してください\n");
442
-
443
- scanf("%lf",&data);
444
-
445
-
446
-
447
- /* ハッシュ値を得る */
448
-
449
- hashval=hash(key);
450
-
451
- printf("数字＝%d ハッシュ値＝%d\n",n,hashval);
452
-
453
- a=insert(key,data);
454
-
455
- if(a==1)
456
-
457
- printf("Done\n");
458
-
459
- else
460
-
461
- printf("AlreadyExsits\n");
462
-
463
- break;
464
-
465
-
466
-
467
- case 2:
468
-
469
- printf("検索する8桁の数字を入力してください\n");
470
-
471
- scanf("%d",&key);
472
-
473
- f=find(key);
474
-
475
- if(f==NULL)
476
-
477
- printf("NotExsits\n");
478
-
479
- else
480
-
481
- printf("検索した値＝%d\n",f);
482
-
483
- break;
484
-
485
-
486
-
487
- case 3:
488
-
489
- printf("削除する8桁数字を入力してください\n");
490
-
491
- scanf("%d",&key);
492
-
493
- c=delete(key);
494
-
495
- if(c==1)
496
-
497
- printf("Done\n");
498
-
499
- else
500
-
501
- printf("NotExsits\n");
502
-
503
- break;
504
-
505
-
506
-
507
- case 4:
508
-
509
- printf("ひょうじします\n");
510
-
511
- /* リストの要素の値を表示する */
512
-
513
- hash_print(data);
514
-
515
- break;
516
-
517
-
518
-
519
- case 9:
520
-
521
- printf("終了します\n");
522
-
523
- break;
524
-
525
-
526
-
527
- default:
528
-
529
- printf("エラー：メニューの中の数字を入力してください\n");
530
-
531
- }
532
-
533
- }while (mn !=9);
534
-
535
-
536
-
537
- return 0;
538
-
539
- }
540
-
541
-
542
-
543
- コード
544
-
545
- ```ｃ
546
-
547
-
548
-
549
- コード
550
-
551
- ```
552
-
553
-
554
-
555
491
  3つの警告と1つのエラーが出ています
556
492
 
557
493
  ### 補足情報（FW/ツールのバージョンなど）

7

インデントをなおしました

2021/01/12 10:41

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -48,9 +48,11 @@
48
48
 
49
49
  ### 該当のソースコード
50
50
 
51
- c言語です```ここに言語を入力
51
+ ```ｃ
52
+
52
-
53
+ ```ｃ
54
+
53
- #include <stdio.h>
55
+ ```#include <stdio.h>
54
56
 
55
57
  #include <stdlib.h>
56
58
 
@@ -538,7 +540,13 @@
538
540
 
539
541
 
540
542
 
541
-
543
+ コード
544
+
545
+ ```ｃ
546
+
547
+
548
+
549
+ コード
542
550
 
543
551
  ```
544
552
 

6

ソースコードの書き方を見直しました

2021/01/10 05:21

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -48,13 +48,7 @@
48
48
 
49
49
  ### 該当のソースコード
50
50
 
51
- c言語です
52
-
53
- ```ここに言語名を入力
51
+ c言語です```ここに言語を入力
54
-
55
- ソースコード
56
-
57
- ソースコード
58
52
 
59
53
  #include <stdio.h>
60
54
 
@@ -514,9 +508,9 @@
514
508
 
515
509
  /* リストの要素の値を表示する */
516
510
 
517
- 　　hash_print(data);
511
+ hash_print(data);
518
-
512
+
519
- 　　 break;
513
+ break;
520
514
 
521
515
 
522
516
 
@@ -544,16 +538,12 @@
544
538
 
545
539
 
546
540
 
541
+
542
+
547
543
  ```
548
544
 
549
545
 
550
546
 
551
- ### 試したこと
552
-
553
- エラー関数の書き方を直しました
554
-
555
-
556
-
557
547
  3つの警告と1つのエラーが出ています
558
548
 
559
549
  ### 補足情報（FW/ツールのバージョンなど）

5

エラーを減らしました

2021/01/10 05:03

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -16,29 +16,531 @@
16
16
 
17
17
  エラーメッセージ
18
18
 
19
- Main.c:32:20: warning: format string is not a string literal (potentially insecure) [-Wformat-security]
20
-
21
- fprintf(stderr,s);
22
-
23
- ^
24
-
25
- Main.c:32:20: note: treat the string as an argument to avoid this
26
-
27
- fprintf(stderr,s);
28
-
29
- ^
30
-
31
- "%s",
32
-
33
- Main.c:58:12: error: expected ';' after top level declarator
34
-
35
- double data *find(int key)
36
-
37
- ^
38
-
39
- ;
40
-
41
- 1 warning and 1 error generated.
19
+ `Main.c:72:1: warning: non-void function does not return a value in all control paths [-Wreturn-type]
20
+
21
+ }
22
+
23
+ ^
24
+
25
+ Main.c:104:10: error: indirection requires pointer operand ('double' invalid)
26
+
27
+ p->data=*data;
28
+
29
+ ^~~~~
30
+
31
+ Main.c:210:14: warning: incompatible pointer to integer conversion assigning to 'int' from 'double *' [-Wint-conversion]
32
+
33
+ f=find(key);
34
+
35
+ ^~~~~~~~~~
36
+
37
+ Main.c:211:17: warning: comparison between pointer and integer ('int' and 'void *') [-Wpointer-integer-compare]
38
+
39
+ if(f==NULL)
40
+
41
+ ~^ ~~~~
42
+
43
+ 3 warnings and 1 error generated.
44
+
45
+ ``
46
+
47
+
48
+
49
+ ### 該当のソースコード
50
+
51
+ c言語です
52
+
53
+ ```ここに言語名を入力
54
+
55
+ ソースコード
56
+
57
+ ソースコード
58
+
59
+ #include <stdio.h>
60
+
61
+ #include <stdlib.h>
62
+
63
+
64
+
65
+ /* ハッシュ法の定義 */
66
+
67
+ #define BUCKET_SIZE 10 /* ハッシュ表の大きさ */
68
+
69
+
70
+
71
+ typedef struct cell{
72
+
73
+ int key;
74
+
75
+ double data;
76
+
77
+ struct cell *next;
78
+
79
+ } CELL;
80
+
81
+ /* ハッシュ表の本体はCELL型ポインタの配列として実現している */
82
+
83
+ CELL *table[BUCKET_SIZE];
84
+
85
+
86
+
87
+ /* init --ハッシュ表を初期化する
88
+
89
+ ハッシュ表に含まれる全てのパケットにNULLをセット
90
+
91
+ ハッシュ表を使う前に必ずセットしなければならない */
92
+
93
+ void init()
94
+
95
+ {
96
+
97
+ int i;
98
+
99
+ /* BCKET_SIZEだけ繰り返して
100
+
101
+ table[i]の中をNULLにして空にする */
102
+
103
+ for(i=0; i<BUCKET_SIZE; i++)
104
+
105
+ table[i]=NULL;
106
+
107
+ }
108
+
109
+
110
+
111
+ /* エラーメッセージをプリントしてexitする関数 */
112
+
113
+ /* ポインタ(アドレス)の先のデータを読み取り専用にする */
114
+
115
+ void fatal_error(char *s)
116
+
117
+ {
118
+
119
+ /* fprintf関数を使ってstderrで標準エラーを出力する*/
120
+
121
+ fprintf(stderr,"%s\n",s);
122
+
123
+ exit(1); /* 異常終了 */
124
+
125
+
126
+
127
+ }
128
+
129
+ /* ハッシュ値を計算する関数
130
+
131
+ パラメータとしてキーを与えると
132
+
133
+ そのキーに対するハッシュ値(int型)を返す*/
134
+
135
+ int hash(int s)
136
+
137
+ {
138
+
139
+ /* キーの値を二乗してその中央値をとることで均等にしている */
140
+
141
+ //int i= 0;
142
+
143
+ /* *sの値が0以外の時に繰り返す
144
+
145
+ C言語では、0が偽、0以外が真という意味を持つ
146
+
147
+ whileは、()の中の式を見ているのではなく、その値が0かどうかだけしか見ていない。
148
+
149
+ 値が0になると、偽と見なしてループを抜ける。*/
150
+
151
+ //while(*s)
152
+
153
+ //i += *s++;
154
+
155
+ return(s % BUCKET_SIZE);
156
+
157
+ }
158
+
159
+
160
+
161
+ /* find -- ハッシュ表を探索する
162
+
163
+ 探したいキーの値をパラメータとして受け取る
164
+
165
+ 成功したらキーを持つDATAへのポインタを返す
166
+
167
+ (構造体CELL型のメンバdataへのポインタ)
168
+
169
+ 見つからなければNULLを返す */
170
+
171
+
172
+
173
+ double *find(int key)
174
+
175
+ {
176
+
177
+ CELL *p;
178
+
179
+ /* p=table[hash(key)]でそのキーが所属しているべきバケットから
180
+
181
+ 連結リストへのポインタを取り出している
182
+
183
+ for文本体では連結リストをたどりながら線形探索する */
184
+
185
+ for(p=table[hash(key)]; p!=NULL; p=p->next)
186
+
187
+ /* もし2つのキーが等しければ成功 */
188
+
189
+ if(key==p->key)
190
+
191
+ /* キーを持つDATAへのポインタを返す */
192
+
193
+ return &p->data;
194
+
195
+ else
196
+
197
+ /* 等しくなければ見つからないとしてNULLを返す*/
198
+
199
+ return NULL;
200
+
201
+ }
202
+
203
+
204
+
205
+ /* insert -- ハッシュ表にデータを挿入する
206
+
207
+ 2つのパラメータを受け取る
208
+
209
+ ①keyは挿入されるデータ持っているキーの値
210
+
211
+ ②dataはDATA *型で挿入されるデータへのポインタ
212
+
213
+ データを登録する際に同じキーを持つデータがすでに登録されているかどうかをチェックする
214
+
215
+ キーが重複していない場合、登録に成功したら1を返す
216
+
217
+ 登録に失敗(すでに同じキーを持つデータがある)
218
+
219
+ したら0を返す */
220
+
221
+
222
+
223
+ int insert(int key,double data)
224
+
225
+ {
226
+
227
+ CELL *p;
228
+
229
+ int h;
230
+
231
+
232
+
233
+ /* キーが重複していないか関数findを呼び出してチェックする
234
+
235
+ 重複していたら0を返す
236
+
237
+ もしNULLでないなら重複していない */
238
+
239
+ if(find(key) != NULL)
240
+
241
+ return 0;
242
+
243
+ /* もし重複していないなら関数mallocを呼び出し、
244
+
245
+ データを格納するセルを割り当てる */
246
+
247
+ if((p=malloc(sizeof(CELL))) == NULL){
248
+
249
+ /* もしセルの割り当てに失敗したらプログラムの実行を中止する */
250
+
251
+ fprintf(stderr,"out of momory\n");
252
+
253
+ exit(2);
254
+
255
+ }
256
+
257
+ /* セルを割り当てたらセルにキーとデータをセットして
258
+
259
+ キーの値に対応するバケットに連結する*/
260
+
261
+ h=hash(key);
262
+
263
+ p->key=key;
264
+
265
+ p->data=*data;
266
+
267
+ p->next=table[h];
268
+
269
+ table[h]=p;
270
+
271
+ return 1;
272
+
273
+ }
274
+
275
+
276
+
277
+ /* delete -- ハッシュ表から削除する
278
+
279
+ 削除したいキーを受け取る
280
+
281
+ 該当するキーを持ったデータが存在し、
282
+
283
+ 削除に成功したら1を返す
284
+
285
+ 該当するキーを持ったデータが見つからなければ何もしないで、
286
+
287
+ 0を返す */
288
+
289
+ /* 最初にバケットを決め、
290
+
291
+ そのバケットに属する連結リストに対して削除の処理を行う */
292
+
293
+ int delete(int key)
294
+
295
+ {
296
+
297
+ int h;
298
+
299
+ CELL *p,*q;
300
+
301
+
302
+
303
+ h=hash(key);
304
+
305
+ /* そのバケットは空か */
306
+
307
+ if(table[h] == NULL)
308
+
309
+ return 0;
310
+
311
+ /* リストの先頭のセルが削除すべきデータか？ */
312
+
313
+ if(key==table[h]->key){
314
+
315
+ p=table[h];
316
+
317
+ table[h]=p->next;
318
+
319
+ free(p);
320
+
321
+ /* 削除に成功したら1を返す */
322
+
323
+ return 1;
324
+
325
+ }
326
+
327
+ /* リストの二番目以降のセルについて順番にチェックする */
328
+
329
+ for(q=table[h],p=q->next; p!=NULL; q=p,p=p->next){
330
+
331
+ if(key==p->key){
332
+
333
+ q->next=p->next;
334
+
335
+ free(p);
336
+
337
+ /* 削除に成功したら1を返す */
338
+
339
+ return 1;
340
+
341
+ }
342
+
343
+ }
344
+
345
+ /* 該当するキーを持ったデータが見つからなければ
346
+
347
+ 削除に失敗したとして0を返す */
348
+
349
+ return 0;
350
+
351
+ }
352
+
353
+
354
+
355
+
356
+
357
+
358
+
359
+ static void hash_print(double data)
360
+
361
+ {
362
+
363
+ int i;
364
+
365
+ struct cell *current = NULL;
366
+
367
+ /* バケットの数だけ繰り返す */
368
+
369
+ for(i = 0; i < BUCKET_SIZE; i++){
370
+
371
+ if(table[i] != NULL){
372
+
373
+ printf("%d番目",i);
374
+
375
+ /* currentをi番目にしておく */
376
+
377
+ current = table[i];
378
+
379
+ /* currentがNULLでない間、次々表示させる*/
380
+
381
+ for(current=table[i]; current!= NULL; current = current->next){
382
+
383
+ printf(" key=%d", (current->key));
384
+
385
+ printf(" data=%lf", (current->data));
386
+
387
+ }
388
+
389
+ printf("\n");
390
+
391
+ }
392
+
393
+ }
394
+
395
+ }
396
+
397
+
398
+
399
+ int main(void)
400
+
401
+ {
402
+
403
+ int key; /* 数字を入力するための配列変数 */
404
+
405
+ double data;
406
+
407
+ int hashval; /* hash関数のハッシュ値を受け取る変数 */
408
+
409
+ int mn=0; /* メニュー選択の数字を入れる変数 */
410
+
411
+ int a; /* insert関数の戻り値を受け取る変数 */
412
+
413
+ int c; /* delete関数の戻り値を受け取る変数 */
414
+
415
+ //int p; /* hash_print関数の戻り値を受け取る変数 */
416
+
417
+ int f; /* find関数の戻り値を受け取る変数 */
418
+
419
+
420
+
421
+ /* ハッシュ表を初期化する */
422
+
423
+ init();
424
+
425
+
426
+
427
+ printf("チェイン法をします\n");
428
+
429
+ do{
430
+
431
+ printf("メニューを選んでください\n1=追加 2=検索 3=削除 4＝ひょうじ 9=終了\n");
432
+
433
+ scanf("%d",&mn);
434
+
435
+ switch(mn){
436
+
437
+
438
+
439
+ case 1:
440
+
441
+ printf("8桁の数字を入力してください\n");
442
+
443
+ scanf("%d",&key);
444
+
445
+ printf("データを入力してください\n");
446
+
447
+ scanf("%lf",&data);
448
+
449
+
450
+
451
+ /* ハッシュ値を得る */
452
+
453
+ hashval=hash(key);
454
+
455
+ printf("数字＝%d ハッシュ値＝%d\n",n,hashval);
456
+
457
+ a=insert(key,data);
458
+
459
+ if(a==1)
460
+
461
+ printf("Done\n");
462
+
463
+ else
464
+
465
+ printf("AlreadyExsits\n");
466
+
467
+ break;
468
+
469
+
470
+
471
+ case 2:
472
+
473
+ printf("検索する8桁の数字を入力してください\n");
474
+
475
+ scanf("%d",&key);
476
+
477
+ f=find(key);
478
+
479
+ if(f==NULL)
480
+
481
+ printf("NotExsits\n");
482
+
483
+ else
484
+
485
+ printf("検索した値＝%d\n",f);
486
+
487
+ break;
488
+
489
+
490
+
491
+ case 3:
492
+
493
+ printf("削除する8桁数字を入力してください\n");
494
+
495
+ scanf("%d",&key);
496
+
497
+ c=delete(key);
498
+
499
+ if(c==1)
500
+
501
+ printf("Done\n");
502
+
503
+ else
504
+
505
+ printf("NotExsits\n");
506
+
507
+ break;
508
+
509
+
510
+
511
+ case 4:
512
+
513
+ printf("ひょうじします\n");
514
+
515
+ /* リストの要素の値を表示する */
516
+
517
+ 　　hash_print(data);
518
+
519
+ 　　 break;
520
+
521
+
522
+
523
+ case 9:
524
+
525
+ printf("終了します\n");
526
+
527
+ break;
528
+
529
+
530
+
531
+ default:
532
+
533
+ printf("エラー：メニューの中の数字を入力してください\n");
534
+
535
+ }
536
+
537
+ }while (mn !=9);
538
+
539
+
540
+
541
+ return 0;
542
+
543
+ }
42
544
 
43
545
 
44
546
 
@@ -46,539 +548,13 @@
46
548
 
47
549
 
48
550
 
49
- ### 該当のソースコード
50
-
51
- c言語です
52
-
53
- ```ここに言語名を入力
54
-
55
- ソースコード
56
-
57
- ソースコード
58
-
59
- #include <stdio.h>
60
-
61
- #include <stdlib.h>
62
-
63
-
64
-
65
- /* ハッシュ法の定義 */
66
-
67
- #define BUCKET_SIZE 10 /* ハッシュ表の大きさ */
68
-
69
-
70
-
71
- typedef struct cell{
72
-
73
- int key;
74
-
75
- double data;
76
-
77
- struct cell *next;
78
-
79
- } CELL;
80
-
81
- /* ハッシュ表の本体はCELL型ポインタの配列として実現している */
82
-
83
- CELL *table[BUCKET_SIZE];
84
-
85
-
86
-
87
- /* init --ハッシュ表を初期化する
88
-
89
- ハッシュ表に含まれる全てのパケットにNULLをセット
90
-
91
- ハッシュ表を使う前に必ずセットしなければならない */
92
-
93
- void init()
94
-
95
- {
96
-
97
- int i;
98
-
99
- /* BCKET_SIZEだけ繰り返して
100
-
101
- table[i]の中をNULLにして空にする */
102
-
103
- for(i=0; i<BUCKET_SIZE; i++)
104
-
105
- table[i]=NULL;
106
-
107
- }
108
-
109
-
110
-
111
- /* エラーメッセージをプリントしてexitする関数 */
112
-
113
- /* ポインタ(アドレス)の先のデータを読み取り専用にする */
114
-
115
- void fatal_error(char *s)
116
-
117
- {
118
-
119
- /* fprintf関数を使ってstderrで標準エラーを出力する*/
120
-
121
- fprintf(stderr,%s,s);
122
-
123
- exit(1); /* 異常終了 */
124
-
125
-
126
-
127
- }
128
-
129
- /* ハッシュ値を計算する関数
130
-
131
- パラメータとしてキーを与えると
132
-
133
- そのキーに対するハッシュ値(int型)を返す*/
134
-
135
- int hash(int *s)
136
-
137
- {
138
-
139
- /* キーの値を二乗してその中央値をとることで均等にしている */
140
-
141
- int i= 0;
142
-
143
- /* *sの値が0以外の時に繰り返す
144
-
145
- C言語では、0が偽、0以外が真という意味を持つ
146
-
147
- whileは、()の中の式を見ているのではなく、その値が0かどうかだけしか見ていない。
148
-
149
- 値が0になると、偽と見なしてループを抜ける。*/
150
-
151
- while(*s)
152
-
153
- i += *s++;
154
-
155
- return(i % BUCKET_SIZE);
156
-
157
- }
158
-
159
-
160
-
161
- /* find -- ハッシュ表を探索する
162
-
163
- 探したいキーの値をパラメータとして受け取る
164
-
165
- 成功したらキーを持つDATAへのポインタを返す
166
-
167
- (構造体CELL型のメンバdataへのポインタ)
168
-
169
- 見つからなければNULLを返す */
170
-
171
-
172
-
173
- double data *find(int key)
174
-
175
- {
176
-
177
- CELL *p;
178
-
179
- /* p=table[hash(key)]でそのキーが所属しているべきバケットから
180
-
181
- 連結リストへのポインタを取り出している
182
-
183
- for文本体では連結リストをたどりながら線形探索する */
184
-
185
- for(p=table[hash(key)]; p!=NULL; p=p->next)
186
-
187
- /* もし2つのキーが等しければ成功 */
188
-
189
- if(key==p->key)
190
-
191
- /* キーを持つDATAへのポインタを返す */
192
-
193
- return &p->data;
194
-
195
- else
196
-
197
- /* 等しくなければ見つからないとしてNULLを返す*/
198
-
199
- return NULL;
200
-
201
- }
202
-
203
-
204
-
205
- /* insert -- ハッシュ表にデータを挿入する
206
-
207
- 2つのパラメータを受け取る
208
-
209
- ①keyは挿入されるデータ持っているキーの値
210
-
211
- ②dataはDATA *型で挿入されるデータへのポインタ
212
-
213
- データを登録する際に同じキーを持つデータがすでに登録されているかどうかをチェックする
214
-
215
- キーが重複していない場合、登録に成功したら1を返す
216
-
217
- 登録に失敗(すでに同じキーを持つデータがある)
218
-
219
- したら0を返す */
220
-
221
-
222
-
223
- int insert(int key,double data)
224
-
225
- {
226
-
227
- CELL *p;
228
-
229
- int h;
230
-
231
-
232
-
233
- /* キーが重複していないか関数findを呼び出してチェックする
234
-
235
- 重複していたら0を返す
236
-
237
- もしNULLでないなら重複していない */
238
-
239
- if(find(key) != NULL)
240
-
241
- return 0;
242
-
243
- /* もし重複していないなら関数mallocを呼び出し、
244
-
245
- データを格納するセルを割り当てる */
246
-
247
- if((p=malloc(sizeof(CELL))) == NULL){
248
-
249
- /* もしセルの割り当てに失敗したらプログラムの実行を中止する */
250
-
251
- fprintf(stderr,"out of momory\n");
252
-
253
- exit(2);
254
-
255
- }
256
-
257
- /* セルを割り当てたらセルにキーとデータをセットして
258
-
259
- キーの値に対応するバケットに連結する*/
260
-
261
- h=hash(key);
262
-
263
- p->key=key;
264
-
265
- p->data=*data;
266
-
267
- p->next=table[h];
268
-
269
- table[h]=p;
270
-
271
- return 1;
272
-
273
- }
274
-
275
-
276
-
277
- /* delete -- ハッシュ表から削除する
278
-
279
- 削除したいキーを受け取る
280
-
281
- 該当するキーを持ったデータが存在し、
282
-
283
- 削除に成功したら1を返す
284
-
285
- 該当するキーを持ったデータが見つからなければ何もしないで、
286
-
287
- 0を返す */
288
-
289
- /* 最初にバケットを決め、
290
-
291
- そのバケットに属する連結リストに対して削除の処理を行う */
292
-
293
- int delete(int key)
294
-
295
- {
296
-
297
- int h;
298
-
299
- CELL *p,*q;
300
-
301
-
302
-
303
- h=hash(key);
304
-
305
- /* そのバケットは空か */
306
-
307
- if(table[h] == NULL)
308
-
309
- return 0;
310
-
311
- /* リストの先頭のセルが削除すべきデータか？ */
312
-
313
- if(key==table[h]->key){
314
-
315
- p=table[h];
316
-
317
- table[h]=p->next;
318
-
319
- free(p);
320
-
321
- /* 削除に成功したら1を返す */
322
-
323
- return 1;
324
-
325
- }
326
-
327
- /* リストの二番目以降のセルについて順番にチェックする */
328
-
329
- for(q==table[h],p=q->next; p!=NULL; q=p,p=p->next){
330
-
331
- if(key==p->key){
332
-
333
- q->next=p->next;
334
-
335
- free(p);
336
-
337
- /* 削除に成功したら1を返す */
338
-
339
- return 1;
340
-
341
- }
342
-
343
- }
344
-
345
- /* 該当するキーを持ったデータが見つからなければ
346
-
347
- 削除に失敗したとして0を返す */
348
-
349
- return 0;
350
-
351
- }
352
-
353
-
354
-
355
-
356
-
357
-
358
-
359
- static void hash_print(double data)
360
-
361
- {
362
-
363
- int i;
364
-
365
- cell_t *current = NULL;
366
-
367
- /* バケットの数だけ繰り返す */
368
-
369
- for(i = 0; cnt < BUCKET_SIZE; i++){
370
-
371
- if(table[i] != NULL){
372
-
373
- printf("table[%s]:{",i);
374
-
375
- /* currentをi番目にしておく */
376
-
377
- current = table[i];
378
-
379
- /* currentがNULLでない間、次々表示させる*/
380
-
381
- for(; current != NULL; current = current->next){
382
-
383
- printf("{%s:", (current->key));
384
-
385
- printf("%s}", (current->data));
386
-
387
- }
388
-
389
- printf("}\n");
390
-
391
- }
392
-
393
- }
394
-
395
- }
396
-
397
-
398
-
399
- int main(void)
400
-
401
- {
402
-
403
- /* ハッシュ表を初期化する */
404
-
405
- init(table);
406
-
407
- char n[9]; /* 数字を入力するための配列変数 */
408
-
409
- double data；
410
-
411
- int hashval; /* hash関数のハッシュ値を受け取る変数 */
412
-
413
- int mn=0; /* メニュー選択の数字を入れる変数 */
414
-
415
- int a; /* insert関数の戻り値を受け取る変数 */
416
-
417
- int c; /* delete関数の戻り値を受け取る変数 */
418
-
419
- int p; /* hash_print関数の戻り値を受け取る変数 */
420
-
421
- int f; /* find関数の戻り値を受け取る変数 */
422
-
423
-
424
-
425
- printf("チェイン法をします\n");
426
-
427
- do{
428
-
429
- printf("メニューを選んでください\n1=追加 2=検索 3=削除 4＝ひょうじ 9=終了\n");
430
-
431
- scanf("%d",&mn);
432
-
433
- switch(mn){
434
-
435
-
436
-
437
- case 1:
438
-
439
- printf("8桁の数字を入力してください\n");
440
-
441
- scanf("%s",&n);
442
-
443
- printf("データをを入力してください\n");
444
-
445
- scanf("%lf",&data);
446
-
447
- /* ハッシュ値を得る */
448
-
449
- hashval=hash(n);
450
-
451
- printf("数字＝%d ハッシュ値＝%d\n",n,hashval);
452
-
453
- a=insert(n);
454
-
455
- if(a==1)
456
-
457
- printf("Done\n");
458
-
459
- else
460
-
461
- printf("AlreadyExsits\n");
462
-
463
- break;
464
-
465
-
466
-
467
- case 2:
468
-
469
- printf("検索する8桁の数字を入力してください\n");
470
-
471
- scanf("%s",&n);
472
-
473
- f=find(n);
474
-
475
- if(f==NULL);
476
-
477
- printf("NotExsits\n");
478
-
479
- else
480
-
481
- printf("検索した値＝%d\n",f);
482
-
483
- break;
484
-
485
-
486
-
487
- case 3:
488
-
489
- printf("削除する8桁数字を入力してください\n");
490
-
491
- scanf("%s",&n);
492
-
493
- c=delete(n);
494
-
495
- if(c==1)
496
-
497
- printf("Done\n");
498
-
499
- else
500
-
501
- printf("NotExsits\n");
502
-
503
- break;
504
-
505
-
506
-
507
- case 4:
508
-
509
- printf("ひょうじします\n");
510
-
511
- /* リストの要素の値を表示する */
512
-
513
- hash_print();
514
-
515
- break;
516
-
517
-
518
-
519
- case 9:
520
-
521
- printf("終了します\n");
522
-
523
- break;
524
-
525
-
526
-
527
- default:
528
-
529
- printf("エラー：メニューの中の数字を入力してください\n");
530
-
531
- }
532
-
533
- }while (mn !=9);
534
-
535
- return 0;
536
-
537
- }
538
-
539
-
540
-
541
- ```
542
-
543
-
544
-
545
551
  ### 試したこと
546
552
 
547
- void fatal_error(char *s)
548
-
549
- {
550
-
551
- /* fprintf関数を使ってstderrで標準エラーを出力する*/
552
-
553
- fprintf(stderr,s);
554
-
555
- exit(1); /* 異常終了 */
556
-
557
-
558
-
559
- }
560
-
561
- ここでエラーがでてしまうのはなぜでしょううか、EasyIDECだとエラーが出ないのにpaizaだとエラーが出てしまいます
562
-
563
- const charとか％Sつけたりもしてみたのですがだめでした
564
-
565
- typedef struct cell{
566
-
567
- int key;
568
-
569
- double data;
570
-
571
- struct cell *next;
572
-
573
- } CELL;
574
-
575
- 宣言のところでもともとDATA data　　関数の所をDATA *find
576
-
577
- だったのを　double dataにかえて、find関数の宣言もどのように変更すれば良いか困惑しています
578
-
579
- アドバイスお願いいたします。
553
+ エラー関数の書き方を直しました
554
+
555
+
556
+
580
-
557
+ 3つの警告と1つのエラーが出ています
581
-
582
558
 
583
559
  ### 補足情報（FW/ツールのバージョンなど）
584
560
 

4

2021/01/10 04:59

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
File without changes

3

2021/01/09 06:48

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -448,7 +448,7 @@
448
448
 
449
449
  hashval=hash(n);
450
450
 
451
- printf("学籍番号＝%d ハッシュ値＝%d\n",n,hashval);
451
+ printf("数字＝%d ハッシュ値＝%d\n",n,hashval);
452
452
 
453
453
  a=insert(n);
454
454
 

2

2021/01/09 06:48

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -406,6 +406,8 @@
406
406
 
407
407
  char n[9]; /* 数字を入力するための配列変数 */
408
408
 
409
+ double data；
410
+
409
411
  int hashval; /* hash関数のハッシュ値を受け取る変数 */
410
412
 
411
413
  int mn=0; /* メニュー選択の数字を入れる変数 */
@@ -438,7 +440,9 @@
438
440
 
439
441
  scanf("%s",&n);
440
442
 
441
-
443
+ printf("データをを入力してください\n");
444
+
445
+ scanf("%lf",&data);
442
446
 
443
447
  /* ハッシュ値を得る */
444
448
 

1

エラー関数の書き方を変えました

2021/01/09 06:47

投稿

kyapi
kyapi

スコア5

test CHANGED
File without changes
test CHANGED
@@ -54,6 +54,8 @@
54
54
 
55
55
  ソースコード
56
56
 
57
+ ソースコード
58
+
57
59
  #include <stdio.h>
58
60
 
59
61
  #include <stdlib.h>
@@ -68,6 +70,496 @@
68
70
 
69
71
  typedef struct cell{
70
72
 
73
+ int key;
74
+
75
+ double data;
76
+
77
+ struct cell *next;
78
+
79
+ } CELL;
80
+
81
+ /* ハッシュ表の本体はCELL型ポインタの配列として実現している */
82
+
83
+ CELL *table[BUCKET_SIZE];
84
+
85
+
86
+
87
+ /* init --ハッシュ表を初期化する
88
+
89
+ ハッシュ表に含まれる全てのパケットにNULLをセット
90
+
91
+ ハッシュ表を使う前に必ずセットしなければならない */
92
+
93
+ void init()
94
+
95
+ {
96
+
97
+ int i;
98
+
99
+ /* BCKET_SIZEだけ繰り返して
100
+
101
+ table[i]の中をNULLにして空にする */
102
+
103
+ for(i=0; i<BUCKET_SIZE; i++)
104
+
105
+ table[i]=NULL;
106
+
107
+ }
108
+
109
+
110
+
111
+ /* エラーメッセージをプリントしてexitする関数 */
112
+
113
+ /* ポインタ(アドレス)の先のデータを読み取り専用にする */
114
+
115
+ void fatal_error(char *s)
116
+
117
+ {
118
+
119
+ /* fprintf関数を使ってstderrで標準エラーを出力する*/
120
+
121
+ fprintf(stderr,%s,s);
122
+
123
+ exit(1); /* 異常終了 */
124
+
125
+
126
+
127
+ }
128
+
129
+ /* ハッシュ値を計算する関数
130
+
131
+ パラメータとしてキーを与えると
132
+
133
+ そのキーに対するハッシュ値(int型)を返す*/
134
+
135
+ int hash(int *s)
136
+
137
+ {
138
+
139
+ /* キーの値を二乗してその中央値をとることで均等にしている */
140
+
141
+ int i= 0;
142
+
143
+ /* *sの値が0以外の時に繰り返す
144
+
145
+ C言語では、0が偽、0以外が真という意味を持つ
146
+
147
+ whileは、()の中の式を見ているのではなく、その値が0かどうかだけしか見ていない。
148
+
149
+ 値が0になると、偽と見なしてループを抜ける。*/
150
+
151
+ while(*s)
152
+
153
+ i += *s++;
154
+
155
+ return(i % BUCKET_SIZE);
156
+
157
+ }
158
+
159
+
160
+
161
+ /* find -- ハッシュ表を探索する
162
+
163
+ 探したいキーの値をパラメータとして受け取る
164
+
165
+ 成功したらキーを持つDATAへのポインタを返す
166
+
167
+ (構造体CELL型のメンバdataへのポインタ)
168
+
169
+ 見つからなければNULLを返す */
170
+
171
+
172
+
173
+ double data *find(int key)
174
+
175
+ {
176
+
177
+ CELL *p;
178
+
179
+ /* p=table[hash(key)]でそのキーが所属しているべきバケットから
180
+
181
+ 連結リストへのポインタを取り出している
182
+
183
+ for文本体では連結リストをたどりながら線形探索する */
184
+
185
+ for(p=table[hash(key)]; p!=NULL; p=p->next)
186
+
187
+ /* もし2つのキーが等しければ成功 */
188
+
189
+ if(key==p->key)
190
+
191
+ /* キーを持つDATAへのポインタを返す */
192
+
193
+ return &p->data;
194
+
195
+ else
196
+
197
+ /* 等しくなければ見つからないとしてNULLを返す*/
198
+
199
+ return NULL;
200
+
201
+ }
202
+
203
+
204
+
205
+ /* insert -- ハッシュ表にデータを挿入する
206
+
207
+ 2つのパラメータを受け取る
208
+
209
+ ①keyは挿入されるデータ持っているキーの値
210
+
211
+ ②dataはDATA *型で挿入されるデータへのポインタ
212
+
213
+ データを登録する際に同じキーを持つデータがすでに登録されているかどうかをチェックする
214
+
215
+ キーが重複していない場合、登録に成功したら1を返す
216
+
217
+ 登録に失敗(すでに同じキーを持つデータがある)
218
+
219
+ したら0を返す */
220
+
221
+
222
+
223
+ int insert(int key,double data)
224
+
225
+ {
226
+
227
+ CELL *p;
228
+
229
+ int h;
230
+
231
+
232
+
233
+ /* キーが重複していないか関数findを呼び出してチェックする
234
+
235
+ 重複していたら0を返す
236
+
237
+ もしNULLでないなら重複していない */
238
+
239
+ if(find(key) != NULL)
240
+
241
+ return 0;
242
+
243
+ /* もし重複していないなら関数mallocを呼び出し、
244
+
245
+ データを格納するセルを割り当てる */
246
+
247
+ if((p=malloc(sizeof(CELL))) == NULL){
248
+
249
+ /* もしセルの割り当てに失敗したらプログラムの実行を中止する */
250
+
251
+ fprintf(stderr,"out of momory\n");
252
+
253
+ exit(2);
254
+
255
+ }
256
+
257
+ /* セルを割り当てたらセルにキーとデータをセットして
258
+
259
+ キーの値に対応するバケットに連結する*/
260
+
261
+ h=hash(key);
262
+
263
+ p->key=key;
264
+
265
+ p->data=*data;
266
+
267
+ p->next=table[h];
268
+
269
+ table[h]=p;
270
+
271
+ return 1;
272
+
273
+ }
274
+
275
+
276
+
277
+ /* delete -- ハッシュ表から削除する
278
+
279
+ 削除したいキーを受け取る
280
+
281
+ 該当するキーを持ったデータが存在し、
282
+
283
+ 削除に成功したら1を返す
284
+
285
+ 該当するキーを持ったデータが見つからなければ何もしないで、
286
+
287
+ 0を返す */
288
+
289
+ /* 最初にバケットを決め、
290
+
291
+ そのバケットに属する連結リストに対して削除の処理を行う */
292
+
293
+ int delete(int key)
294
+
295
+ {
296
+
297
+ int h;
298
+
299
+ CELL *p,*q;
300
+
301
+
302
+
303
+ h=hash(key);
304
+
305
+ /* そのバケットは空か */
306
+
307
+ if(table[h] == NULL)
308
+
309
+ return 0;
310
+
311
+ /* リストの先頭のセルが削除すべきデータか？ */
312
+
313
+ if(key==table[h]->key){
314
+
315
+ p=table[h];
316
+
317
+ table[h]=p->next;
318
+
319
+ free(p);
320
+
321
+ /* 削除に成功したら1を返す */
322
+
323
+ return 1;
324
+
325
+ }
326
+
327
+ /* リストの二番目以降のセルについて順番にチェックする */
328
+
329
+ for(q==table[h],p=q->next; p!=NULL; q=p,p=p->next){
330
+
331
+ if(key==p->key){
332
+
333
+ q->next=p->next;
334
+
335
+ free(p);
336
+
337
+ /* 削除に成功したら1を返す */
338
+
339
+ return 1;
340
+
341
+ }
342
+
343
+ }
344
+
345
+ /* 該当するキーを持ったデータが見つからなければ
346
+
347
+ 削除に失敗したとして0を返す */
348
+
349
+ return 0;
350
+
351
+ }
352
+
353
+
354
+
355
+
356
+
357
+
358
+
359
+ static void hash_print(double data)
360
+
361
+ {
362
+
363
+ int i;
364
+
365
+ cell_t *current = NULL;
366
+
367
+ /* バケットの数だけ繰り返す */
368
+
369
+ for(i = 0; cnt < BUCKET_SIZE; i++){
370
+
371
+ if(table[i] != NULL){
372
+
373
+ printf("table[%s]:{",i);
374
+
375
+ /* currentをi番目にしておく */
376
+
377
+ current = table[i];
378
+
379
+ /* currentがNULLでない間、次々表示させる*/
380
+
381
+ for(; current != NULL; current = current->next){
382
+
383
+ printf("{%s:", (current->key));
384
+
385
+ printf("%s}", (current->data));
386
+
387
+ }
388
+
389
+ printf("}\n");
390
+
391
+ }
392
+
393
+ }
394
+
395
+ }
396
+
397
+
398
+
399
+ int main(void)
400
+
401
+ {
402
+
403
+ /* ハッシュ表を初期化する */
404
+
405
+ init(table);
406
+
407
+ char n[9]; /* 数字を入力するための配列変数 */
408
+
409
+ int hashval; /* hash関数のハッシュ値を受け取る変数 */
410
+
411
+ int mn=0; /* メニュー選択の数字を入れる変数 */
412
+
413
+ int a; /* insert関数の戻り値を受け取る変数 */
414
+
415
+ int c; /* delete関数の戻り値を受け取る変数 */
416
+
417
+ int p; /* hash_print関数の戻り値を受け取る変数 */
418
+
419
+ int f; /* find関数の戻り値を受け取る変数 */
420
+
421
+
422
+
423
+ printf("チェイン法をします\n");
424
+
425
+ do{
426
+
427
+ printf("メニューを選んでください\n1=追加 2=検索 3=削除 4＝ひょうじ 9=終了\n");
428
+
429
+ scanf("%d",&mn);
430
+
431
+ switch(mn){
432
+
433
+
434
+
435
+ case 1:
436
+
437
+ printf("8桁の数字を入力してください\n");
438
+
439
+ scanf("%s",&n);
440
+
441
+
442
+
443
+ /* ハッシュ値を得る */
444
+
445
+ hashval=hash(n);
446
+
447
+ printf("学籍番号＝%d ハッシュ値＝%d\n",n,hashval);
448
+
449
+ a=insert(n);
450
+
451
+ if(a==1)
452
+
453
+ printf("Done\n");
454
+
455
+ else
456
+
457
+ printf("AlreadyExsits\n");
458
+
459
+ break;
460
+
461
+
462
+
463
+ case 2:
464
+
465
+ printf("検索する8桁の数字を入力してください\n");
466
+
467
+ scanf("%s",&n);
468
+
469
+ f=find(n);
470
+
471
+ if(f==NULL);
472
+
473
+ printf("NotExsits\n");
474
+
475
+ else
476
+
477
+ printf("検索した値＝%d\n",f);
478
+
479
+ break;
480
+
481
+
482
+
483
+ case 3:
484
+
485
+ printf("削除する8桁数字を入力してください\n");
486
+
487
+ scanf("%s",&n);
488
+
489
+ c=delete(n);
490
+
491
+ if(c==1)
492
+
493
+ printf("Done\n");
494
+
495
+ else
496
+
497
+ printf("NotExsits\n");
498
+
499
+ break;
500
+
501
+
502
+
503
+ case 4:
504
+
505
+ printf("ひょうじします\n");
506
+
507
+ /* リストの要素の値を表示する */
508
+
509
+ hash_print();
510
+
511
+ break;
512
+
513
+
514
+
515
+ case 9:
516
+
517
+ printf("終了します\n");
518
+
519
+ break;
520
+
521
+
522
+
523
+ default:
524
+
525
+ printf("エラー：メニューの中の数字を入力してください\n");
526
+
527
+ }
528
+
529
+ }while (mn !=9);
530
+
531
+ return 0;
532
+
533
+ }
534
+
535
+
536
+
537
+ ```
538
+
539
+
540
+
541
+ ### 試したこと
542
+
543
+ void fatal_error(char *s)
544
+
545
+ {
546
+
547
+ /* fprintf関数を使ってstderrで標準エラーを出力する*/
548
+
549
+ fprintf(stderr,s);
550
+
551
+ exit(1); /* 異常終了 */
552
+
553
+
554
+
555
+ }
556
+
557
+ ここでエラーがでてしまうのはなぜでしょううか、EasyIDECだとエラーが出ないのにpaizaだとエラーが出てしまいます
558
+
559
+ const charとか％Sつけたりもしてみたのですがだめでした
560
+
561
+ typedef struct cell{
562
+
71
563
  int key;
72
564
 
73
565
  double data;
@@ -76,494 +568,6 @@
76
568
 
77
569
  } CELL;
78
570
 
79
- /* ハッシュ表の本体はCELL型ポインタの配列として実現している */
80
-
81
- CELL *table[BUCKET_SIZE];
82
-
83
-
84
-
85
- /* init --ハッシュ表を初期化する
86
-
87
- ハッシュ表に含まれる全てのパケットにNULLをセット
88
-
89
- ハッシュ表を使う前に必ずセットしなければならない */
90
-
91
- void init()
92
-
93
- {
94
-
95
- int i;
96
-
97
- /* BCKET_SIZEだけ繰り返して
98
-
99
- table[i]の中をNULLにして空にする */
100
-
101
- for(i=0; i<BUCKET_SIZE; i++)
102
-
103
- table[i]=NULL;
104
-
105
- }
106
-
107
-
108
-
109
- /* エラーメッセージをプリントしてexitする関数 */
110
-
111
- /* ポインタ(アドレス)の先のデータを読み取り専用にする */
112
-
113
- void fatal_error(char *s)
114
-
115
- {
116
-
117
- /* fprintf関数を使ってstderrで標準エラーを出力する*/
118
-
119
- fprintf(stderr,s);
120
-
121
- exit(1); /* 異常終了 */
122
-
123
-
124
-
125
- }
126
-
127
- /* ハッシュ値を計算する関数
128
-
129
- パラメータとしてキーを与えると
130
-
131
- そのキーに対するハッシュ値(int型)を返す*/
132
-
133
- int hash(int *s)
134
-
135
- {
136
-
137
- /* キーの値を二乗してその中央値をとることで均等にしている */
138
-
139
- int i= 0;
140
-
141
- /* *sの値が0以外の時に繰り返す
142
-
143
- C言語では、0が偽、0以外が真という意味を持つ
144
-
145
- whileは、()の中の式を見ているのではなく、その値が0かどうかだけしか見ていない。
146
-
147
- 値が0になると、偽と見なしてループを抜ける。*/
148
-
149
- while(*s)
150
-
151
- i += *s++;
152
-
153
- return(i % BUCKET_SIZE);
154
-
155
- }
156
-
157
-
158
-
159
- /* find -- ハッシュ表を探索する
160
-
161
- 探したいキーの値をパラメータとして受け取る
162
-
163
- 成功したらキーを持つDATAへのポインタを返す
164
-
165
- (構造体CELL型のメンバdataへのポインタ)
166
-
167
- 見つからなければNULLを返す */
168
-
169
-
170
-
171
- double data *find(int key)
172
-
173
- {
174
-
175
- CELL *p;
176
-
177
- /* p=table[hash(key)]でそのキーが所属しているべきバケットから
178
-
179
- 連結リストへのポインタを取り出している
180
-
181
- for文本体では連結リストをたどりながら線形探索する */
182
-
183
- for(p=table[hash(key)]; p!=NULL; p=p->next)
184
-
185
- /* もし2つのキーが等しければ成功 */
186
-
187
- if(key==p->key)
188
-
189
- /* キーを持つDATAへのポインタを返す */
190
-
191
- return &p->data;
192
-
193
- else
194
-
195
- /* 等しくなければ見つからないとしてNULLを返す*/
196
-
197
- return NULL;
198
-
199
- }
200
-
201
-
202
-
203
- /* insert -- ハッシュ表にデータを挿入する
204
-
205
- 2つのパラメータを受け取る
206
-
207
- ①keyは挿入されるデータ持っているキーの値
208
-
209
- ②dataはDATA *型で挿入されるデータへのポインタ
210
-
211
- データを登録する際に同じキーを持つデータがすでに登録されているかどうかをチェックする
212
-
213
- キーが重複していない場合、登録に成功したら1を返す
214
-
215
- 登録に失敗(すでに同じキーを持つデータがある)
216
-
217
- したら0を返す */
218
-
219
-
220
-
221
- int insert(int key,double data)
222
-
223
- {
224
-
225
- CELL *p;
226
-
227
- int h;
228
-
229
-
230
-
231
- /* キーが重複していないか関数findを呼び出してチェックする
232
-
233
- 重複していたら0を返す
234
-
235
- もしNULLでないなら重複していない */
236
-
237
- if(find(key) != NULL)
238
-
239
- return 0;
240
-
241
- /* もし重複していないなら関数mallocを呼び出し、
242
-
243
- データを格納するセルを割り当てる */
244
-
245
- if((p=malloc(sizeof(CELL))) == NULL){
246
-
247
- /* もしセルの割り当てに失敗したらプログラムの実行を中止する */
248
-
249
- fprintf(stderr,"out of momory\n");
250
-
251
- exit(2);
252
-
253
- }
254
-
255
- /* セルを割り当てたらセルにキーとデータをセットして
256
-
257
- キーの値に対応するバケットに連結する*/
258
-
259
- h=hash(key);
260
-
261
- p->key=key;
262
-
263
- p->data=*data;
264
-
265
- p->next=table[h];
266
-
267
- table[h]=p;
268
-
269
- return 1;
270
-
271
- }
272
-
273
-
274
-
275
- /* delete -- ハッシュ表から削除する
276
-
277
- 削除したいキーを受け取る
278
-
279
- 該当するキーを持ったデータが存在し、
280
-
281
- 削除に成功したら1を返す
282
-
283
- 該当するキーを持ったデータが見つからなければ何もしないで、
284
-
285
- 0を返す */
286
-
287
- /* 最初にバケットを決め、
288
-
289
- そのバケットに属する連結リストに対して削除の処理を行う */
290
-
291
- int delete(int key)
292
-
293
- {
294
-
295
- int h;
296
-
297
- CELL *p,*q;
298
-
299
-
300
-
301
- h=hash(key);
302
-
303
- /* そのバケットは空か */
304
-
305
- if(table[h] == NULL)
306
-
307
- return 0;
308
-
309
- /* リストの先頭のセルが削除すべきデータか？ */
310
-
311
- if(key==table[h]->key){
312
-
313
- p=table[h];
314
-
315
- table[h]=p->next;
316
-
317
- free(p);
318
-
319
- /* 削除に成功したら1を返す */
320
-
321
- return 1;
322
-
323
- }
324
-
325
- /* リストの二番目以降のセルについて順番にチェックする */
326
-
327
- for(q==table[h],p=q->next; p!=NULL; q=p,p=p->next){
328
-
329
- if(key==p->key){
330
-
331
- q->next=p->next;
332
-
333
- free(p);
334
-
335
- /* 削除に成功したら1を返す */
336
-
337
- return 1;
338
-
339
- }
340
-
341
- }
342
-
343
- /* 該当するキーを持ったデータが見つからなければ
344
-
345
- 削除に失敗したとして0を返す */
346
-
347
- return 0;
348
-
349
- }
350
-
351
-
352
-
353
-
354
-
355
-
356
-
357
- static void hash_print(double data)
358
-
359
- {
360
-
361
- int i;
362
-
363
- cell_t *current = NULL;
364
-
365
- /* バケットの数だけ繰り返す */
366
-
367
- for(i = 0; cnt < BUCKET_SIZE; i++){
368
-
369
- if(table[i] != NULL){
370
-
371
- printf("table[%s]:{",i);
372
-
373
- /* currentをi番目にしておく */
374
-
375
- current = table[i];
376
-
377
- /* currentがNULLでない間、次々表示させる*/
378
-
379
- for(; current != NULL; current = current->next){
380
-
381
- printf("{%s:", (current->key));
382
-
383
- printf("%s}", (current->data));
384
-
385
- }
386
-
387
- printf("}\n");
388
-
389
- }
390
-
391
- }
392
-
393
- }
394
-
395
-
396
-
397
- int main(void)
398
-
399
- {
400
-
401
- /* ハッシュ表を初期化する */
402
-
403
- init(table);
404
-
405
- char n[9]; /* 数字を入力するための配列変数 */
406
-
407
- int hashval; /* hash関数のハッシュ値を受け取る変数 */
408
-
409
- int mn=0; /* メニュー選択の数字を入れる変数 */
410
-
411
- int a; /* insert関数の戻り値を受け取る変数 */
412
-
413
- int c; /* delete関数の戻り値を受け取る変数 */
414
-
415
- int p; /* hash_print関数の戻り値を受け取る変数 */
416
-
417
- int f; /* find関数の戻り値を受け取る変数 */
418
-
419
-
420
-
421
- printf("チェイン法をします\n");
422
-
423
- do{
424
-
425
- printf("メニューを選んでください\n1=追加 2=検索 3=削除 4＝ひょうじ 9=終了\n");
426
-
427
- scanf("%d",&mn);
428
-
429
- switch(mn){
430
-
431
-
432
-
433
- case 1:
434
-
435
- printf("8桁の数字を入力してください\n");
436
-
437
- scanf("%s",&n);
438
-
439
-
440
-
441
- /* ハッシュ値を得る */
442
-
443
- hashval=hash(n);
444
-
445
- printf("学籍番号＝%d ハッシュ値＝%d\n",n,hashval);
446
-
447
- a=insert(n);
448
-
449
- if(a==1)
450
-
451
- printf("Done\n");
452
-
453
- else
454
-
455
- printf("AlreadyExsits\n");
456
-
457
- break;
458
-
459
-
460
-
461
- case 2:
462
-
463
- printf("検索する8桁の数字を入力してください\n");
464
-
465
- scanf("%s",&n);
466
-
467
- f=find(n);
468
-
469
- if(f==NULL);
470
-
471
- printf("NotExsits\n");
472
-
473
- else
474
-
475
- printf("検索した値＝%d\n",f);
476
-
477
- break;
478
-
479
-
480
-
481
- case 3:
482
-
483
- printf("削除する8桁数字を入力してください\n");
484
-
485
- scanf("%s",&n);
486
-
487
- c=delete(n);
488
-
489
- if(c==1)
490
-
491
- printf("Done\n");
492
-
493
- else
494
-
495
- printf("NotExsits\n");
496
-
497
- break;
498
-
499
-
500
-
501
- case 4:
502
-
503
- printf("ひょうじします\n");
504
-
505
- /* リストの要素の値を表示する */
506
-
507
- hash_print();
508
-
509
- break;
510
-
511
-
512
-
513
- case 9:
514
-
515
- printf("終了します\n");
516
-
517
- break;
518
-
519
-
520
-
521
- default:
522
-
523
- printf("エラー：メニューの中の数字を入力してください\n");
524
-
525
- }
526
-
527
- }while (mn !=9);
528
-
529
- return 0;
530
-
531
- }
532
-
533
- ```
534
-
535
-
536
-
537
- ### 試したこと
538
-
539
- void fatal_error(char *s)
540
-
541
- {
542
-
543
- /* fprintf関数を使ってstderrで標準エラーを出力する*/
544
-
545
- fprintf(stderr,s);
546
-
547
- exit(1); /* 異常終了 */
548
-
549
-
550
-
551
- }
552
-
553
- ここでエラーがでてしまうのはなぜでしょううか、EasyIDECだとエラーが出ないのにpaizaだとエラーが出てしまいます
554
-
555
- const charとか％Sつけたりもしてみたのですがだめでした
556
-
557
- typedef struct cell{
558
-
559
- int key;
560
-
561
- double data;
562
-
563
- struct cell *next;
564
-
565
- } CELL;
566
-
567
571
  宣言のところでもともとDATA data　　関数の所をDATA *find
568
572
 
569
573
  だったのを　double dataにかえて、find関数の宣言もどのように変更すれば良いか困惑しています