13장 테이블(Table)과 해쉬(Hash)

Posted on: 2019년 04월 08일 2019년 04월 08일
Categories: 강의자료, 자료구조

테이블 : 원하는 바를 단번에 찾아내는 방식
1. 키(Key)와 값(Value)의 한 쌍으로 저장되는 구조
2. 시간복잡도 : O(1)

테이블 소스 : S013_Table.c

#include <stdio.h>

int main(void)
{
	int i;
	int empInfoArr[1000]; //사번은 0~999번까지만 가능
	int num, age;

//	for(i = 0; i < 5; i++){
//		printf("사번(0~999)과 나이(0~) 입력: ");
//		scanf("%d %d", &num, &age);
//		empInfoArr[num] = age;    // 단번에 저장!
//	}
	int numArr[5] = {100, 300, 250, 450, 780};
	int ageArr[5] = {56, 45, 47, 35, 28};
	for(i = 0; i < 5; i++){
		empInfoArr[numArr[i]] = ageArr[i];
	}

	for(i = 0; i < 2; i++){
		printf("확인하고픈 직원의 사번(0~999) 입력: ");
		scanf("%d", &num);
		age = empInfoArr[num];    // 단번에 탐색!
		printf("사번 %d, 나이 %d \n", num, age);
	}

	return 0;
}

#include <stdio.h>

int main(void)

{

int i;

int empInfoArr[1000]; //사번은 0~999번까지만 가능

int num, age;

// for(i = 0; i < 5; i++){

// printf("사번(0~999)과 나이(0~) 입력: ");

// scanf("%d %d", &num, &age);

// empInfoArr[num] = age; // 단번에 저장!

// }

int numArr[5] = {100, 300, 250, 450, 780};

int ageArr[5] = {56, 45, 47, 35, 28};

for(i = 0; i < 5; i++){

empInfoArr[numArr[i]] = ageArr[i];

}

for(i = 0; i < 2; i++){

printf("확인하고픈 직원의 사번(0~999) 입력: ");

scanf("%d", &num);

age = empInfoArr[num]; // 단번에 탐색!

printf("사번 %d, 나이 %d \n", num, age);

}

return 0;

}

테이블의 문제점
1. 사원번호가 : 201900000 ~ 201900099으로 100명이 근무하는 회사에 대해 프로그래밍 한다면 위 코드를 어떻게 수정해야 하는가?

해쉬(Hash) 코드 사용 샘플 소스 : S013_TableHash.c

#include <stdio.h>

int getHashValue(int num){
	return num % 100;
}

int main(void)
{
	int i;
	int empInfoArr[100]; //사번은 0~99번까지만 가능
	int num, age;

	int numArr[5] = {201900010, 201900030, 201900025, 201900045, 201900078};
	int ageArr[5] = {56, 45, 47, 35, 28};
	for(i = 0; i < 5; i++){
		empInfoArr[getHashValue(numArr[i])] = ageArr[i];
	}

	for(i = 0; i < 2; i++){
		printf("확인하고픈 직원의 사번(0~999) 입력: ");
		scanf("%d", &num);
		age = empInfoArr[getHashValue(num)];    // 단번에 탐색!
		printf("사번 %d, 나이 %d \n", num, age);
	}

	return 0;
}

#include <stdio.h>

int getHashValue(int num){

return num % 100;

}

int main(void)

{

int i;

int empInfoArr[100]; //사번은 0~99번까지만 가능

int num, age;

int numArr[5] = {201900010, 201900030, 201900025, 201900045, 201900078};

int ageArr[5] = {56, 45, 47, 35, 28};

for(i = 0; i < 5; i++){

empInfoArr[getHashValue(numArr[i])] = ageArr[i];

}

for(i = 0; i < 2; i++){

printf("확인하고픈 직원의 사번(0~999) 입력: ");

scanf("%d", &num);

age = empInfoArr[getHashValue(num)]; // 단번에 탐색!

printf("사번 %d, 나이 %d \n", num, age);

}

return 0;

}

해쉬(Hash) 방법
1. 자릿수 선택(Digit Selection)
  1. 같은 학과 학생들로 구성된 학과 학생들의 학번
  2. 학과가 다른 학생들로 구성된 동아리 구성원들의 학번
2. 자릿수 폴딩(Digit Folding)
좋은 해쉬 함수의 조건
1. 슬롯의 사용 영역이 고르게 분포되어 있어야 한다.
충돌(Collision) 문제의 해결책
1. 열린 어드레싱 방법(open addressing method)
  1. 선형 조사법(Linear Probing) : 충돌이 발생하면 바로 다음 위치에 저장
  2. 이차 조사법(Quadratic Probing) : 충돌이 발생하면 제곱만큼 떨어진 위치에 저장
  3. 이중 해쉬(Double Hash) : 충돌이 발생하면 몇칸 뒤에 저장할 것인지를 다시 해쉬를 이용해서 구함
2. 닫힌 어드레싱 방법(closed addressing method)
  1. 체이닝(Chaining)
    1. 배열과 연결리스트로 구현 가능하지만 배열은 완전한 체이닝을 만들 수 없음
    2. 보통 연결리스트로 구현

단순 해쉬 완성 버전 : S013_SimpleHashTable.c

#include <stdio.h>
#include <stdlib.h>

////////// Person Start
#define STR_LEN    50

typedef struct _person
{
	int ssn;    // 주민등록번호
	char name[STR_LEN];    // 이름
	char addr[STR_LEN];    // 주소
} Person;

int GetSSN(Person * p)
{
	return p->ssn;
}

void ShowPerInfo(Person * p)
{
	printf("주민등록번호: %d \n", p->ssn);
	printf("이름: %s \n", p->name);
	printf("주소: %s \n\n", p->addr);
}
////////// Person End

////////// Slot Start
typedef int Key;
typedef Person * Value;

enum SlotStatus {EMPTY, DELETED, INUSE};

typedef struct _slot
{
	Key key;
	Value val;
	enum SlotStatus status;
}Slot;
////////// Slot End

////////// Table Start
#define MAX_TBL     100

typedef int HashFunc(Key k);

typedef struct _table
{
	Slot tbl[MAX_TBL];
	HashFunc * hf;
}Table;

void TBLInit(Table * pt, HashFunc * f)
{
	int i;

	for(i=0; i<MAX_TBL; i++)
		(pt->tbl[i]).status = EMPTY;

	pt->hf = f;
}

void TBLInsert(Table * pt, Key k, Value v)
{
	int hv = pt->hf(k);
	pt->tbl[hv].val = v;
	pt->tbl[hv].key = k;
	pt->tbl[hv].status = INUSE;
}

Value TBLDelete(Table * pt, Key k)
{
	int hv = pt->hf(k);

	if((pt->tbl[hv]).status != INUSE)
	{
		return NULL;
	}
	else
	{
		(pt->tbl[hv]).status = DELETED;
		return (pt->tbl[hv]).val;
	}
}

Value TBLSearch(Table * pt, Key k)
{
	int hv = pt->hf(k);

	if((pt->tbl[hv]).status != INUSE)
		return NULL;
	else
		return (pt->tbl[hv]).val;
}
////////// Table End

Person * MakePersonData(int ssn, char * name, char * addr)
{
	Person * newP = (Person*)malloc(sizeof(Person));

	newP->ssn = ssn;
	strcpy(newP->name, name);
	strcpy(newP->addr, addr);
	return newP;
}

int MyHashFunc(int k)
{
	return k % 100;    // 키를 부분적으로만 사용한 별로 좋지 않은 해쉬의 예!!!
}

int main(void)
{
	Table myTbl;
	Person * np;
	Person * sp;
	Person * rp;

	TBLInit(&myTbl, MyHashFunc);

	// 데이터 입력
	np = MakePersonData(20120003, "Lee", "Seoul");
	TBLInsert(&myTbl, GetSSN(np), np);

	np = MakePersonData(20130012, "KIM", "Jeju");
	TBLInsert(&myTbl, GetSSN(np), np);

	np = MakePersonData(20170049, "HAN", "Kangwon");
	TBLInsert(&myTbl, GetSSN(np), np);

	// 데이터 검색
	sp = TBLSearch(&myTbl, 20120003);
	if(sp != NULL)
		ShowPerInfo(sp);

	sp = TBLSearch(&myTbl, 20130012);
	if(sp != NULL)
		ShowPerInfo(sp);

	sp = TBLSearch(&myTbl, 20170049);
	if(sp != NULL)
		ShowPerInfo(sp);

	// 데이터 삭제
	rp = TBLDelete(&myTbl, 20120003);
	if(rp != NULL)
		free(rp);

	rp = TBLDelete(&myTbl, 20130012);
	if(rp != NULL)
		free(rp);

	rp = TBLDelete(&myTbl, 20170049);
	if(rp != NULL)
		free(rp);

	return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

#include <stdio.h>

#include <stdlib.h>

////////// Person Start

#define STR_LEN 50

typedef struct _person

{

int ssn; // 주민등록번호

char name[STR_LEN]; // 이름

char addr[STR_LEN]; // 주소

} Person;

int GetSSN(Person * p)

{

return p->ssn;

}

void ShowPerInfo(Person * p)

{

printf("주민등록번호: %d \n", p->ssn);

printf("이름: %s \n", p->name);

printf("주소: %s \n\n", p->addr);

}

////////// Person End

////////// Slot Start

typedef int Key;

typedef Person * Value;

enum SlotStatus {EMPTY, DELETED, INUSE};

typedef struct _slot

{

Key key;

Value val;

enum SlotStatus status;

}Slot;

////////// Slot End

////////// Table Start

#define MAX_TBL 100

typedef int HashFunc(Key k);

typedef struct _table

{

Slot tbl[MAX_TBL];

HashFunc * hf;

}Table;

void TBLInit(Table * pt, HashFunc * f)

{

int i;

for(i=0; i<MAX_TBL; i++)

(pt->tbl[i]).status = EMPTY;

pt->hf = f;

}

void TBLInsert(Table * pt, Key k, Value v)

{

int hv = pt->hf(k);

pt->tbl[hv].val = v;

pt->tbl[hv].key = k;

pt->tbl[hv].status = INUSE;

}

Value TBLDelete(Table * pt, Key k)

{

int hv = pt->hf(k);

if((pt->tbl[hv]).status != INUSE)

{

return NULL;

}

else

{

(pt->tbl[hv]).status = DELETED;

return (pt->tbl[hv]).val;

}

Value TBLSearch(Table * pt, Key k)

{

int hv = pt->hf(k);

if((pt->tbl[hv]).status != INUSE)

return NULL;

else

return (pt->tbl[hv]).val;

}

////////// Table End

Person * MakePersonData(int ssn, char * name, char * addr)

{

Person * newP = (Person*)malloc(sizeof(Person));

newP->ssn = ssn;

strcpy(newP->name, name);

strcpy(newP->addr, addr);

return newP;

}

int MyHashFunc(int k)

{

return k % 100; // 키를 부분적으로만 사용한 별로 좋지 않은 해쉬의 예!!!

}

int main(void)

{

Table myTbl;

Person * np;

Person * sp;

Person * rp;

TBLInit(&myTbl, MyHashFunc);

// 데이터 입력

np = MakePersonData(20120003, "Lee", "Seoul");

TBLInsert(&myTbl, GetSSN(np), np);

np = MakePersonData(20130012, "KIM", "Jeju");

TBLInsert(&myTbl, GetSSN(np), np);

np = MakePersonData(20170049, "HAN", "Kangwon");

TBLInsert(&myTbl, GetSSN(np), np);

// 데이터 검색

sp = TBLSearch(&myTbl, 20120003);

if(sp != NULL)

ShowPerInfo(sp);

sp = TBLSearch(&myTbl, 20130012);

if(sp != NULL)

ShowPerInfo(sp);

sp = TBLSearch(&myTbl, 20170049);

if(sp != NULL)

ShowPerInfo(sp);

// 데이터 삭제

rp = TBLDelete(&myTbl, 20120003);

if(rp != NULL)

free(rp);

rp = TBLDelete(&myTbl, 20130012);

if(rp != NULL)

free(rp);

rp = TBLDelete(&myTbl, 20170049);

if(rp != NULL)

free(rp);

return 0;

}

체이닝 해쉬 완성 버전 : S013_ChainedHashTable.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

////////// Person Start
#define STR_LEN    50

typedef struct _person
{
	int ssn;				// 주민등록번호
	char name[STR_LEN];		// 이름
	char addr[STR_LEN];		// 주소
} Person;

int GetSSN(Person * p)
{
	return p->ssn;
}

void ShowPerInfo(Person * p)
{
	printf("주민등록번호: %d \n", p->ssn);
	printf("이름: %s \n", p->name);
	printf("주소: %s \n\n", p->addr);
}

Person * MakePersonData(int ssn, char * name, char * addr)
{
	Person * newP = (Person*)malloc(sizeof(Person));

	newP->ssn = ssn;
	strcpy(newP->name, name);
	strcpy(newP->addr, addr);
	return newP;
}
////////// Person End


////////// Slot2 Start
typedef int Key;
typedef Person * Value;

typedef struct _slot
{
	Key key;
	Value val;
} Slot;
////////// Slot2 End


////////// DLinkedList Start
#define TRUE	1
#define FALSE	0

// typedef int LData;
typedef Slot LData;

typedef struct _node
{
	LData data;
	struct _node * next;
} Node;

typedef struct _linkedList
{
	Node * head;
	Node * cur;
	Node * before;
	int numOfData;
	int (*comp)(LData d1, LData d2);
} LinkedList;


typedef LinkedList List;

void ListInit(List * plist)
{
	plist->head = (Node*)malloc(sizeof(Node));
	plist->head->next = NULL;
	plist->comp = NULL;
	plist->numOfData = 0;
}

void FInsert(List * plist, LData data)
{
	Node * newNode = (Node*)malloc(sizeof(Node));
	newNode->data = data;

	newNode->next = plist->head->next;
	plist->head->next = newNode;

	(plist->numOfData)++;
}

void SInsert(List * plist, LData data)
{
	Node * newNode = (Node*)malloc(sizeof(Node));
	Node * pred = plist->head;
	newNode->data = data;

	while(pred->next != NULL &&
		plist->comp(data, pred->next->data) != 0)
	{
		pred = pred->next;
	}

	newNode->next = pred->next;
	pred->next = newNode;

	(plist->numOfData)++;
}

void LInsert(List * plist, LData data)
{
	if(plist->comp == NULL)
		FInsert(plist, data);
	else
		SInsert(plist, data);
}

int LFirst(List * plist, LData * pdata)
{
	if(plist->head->next == NULL)
		return FALSE;

	plist->before = plist->head;
	plist->cur = plist->head->next;

	*pdata = plist->cur->data;
	return TRUE;
}

int LNext(List * plist, LData * pdata)
{
	if(plist->cur->next == NULL)
		return FALSE;

	plist->before = plist->cur;
	plist->cur = plist->cur->next;

	*pdata = plist->cur->data;
	return TRUE;
}

LData LRemove(List * plist)
{
	Node * rpos = plist->cur;
	LData rdata = rpos->data;

	plist->before->next = plist->cur->next;
	plist->cur = plist->before;

	free(rpos);
	(plist->numOfData)--;
	return rdata;
}

int LCount(List * plist)
{
	return plist->numOfData;
}

void SetSortRule(List * plist, int (*comp)(LData d1, LData d2))
{
	plist->comp = comp;
}
////////// DLinkedList End

////////// Table2 Start
#define MAX_TBL     100

typedef int HashFunc(Key k);

typedef struct _table
{
//	Slot tbl[MAX_TBL];
	List tbl[MAX_TBL];
	HashFunc * hf;
} Table;

void TBLInit(Table * pt, HashFunc * f);
void TBLInsert(Table * pt, Key k, Value v);
Value TBLDelete(Table * pt, Key k);
Value TBLSearch(Table * pt, Key k);

void TBLInit(Table * pt, HashFunc * f)
{
	int i;

	for(i=0; i<MAX_TBL; i++)
		ListInit(&(pt->tbl[i]));

	pt->hf = f;
}

void TBLInsert(Table * pt, Key k, Value v)
{
	int hv = pt->hf(k);
	Slot ns = {k, v};

	if(TBLSearch(pt, k) != NULL)       // 키가 중복되었다면
	{
		printf("키 중복 오류 발생 \n");
		return;
	}
	else
	{
		LInsert(&(pt->tbl[hv]), ns);
	}
}

Value TBLDelete(Table * pt, Key k)
{
	int hv = pt->hf(k);
	Slot cSlot;

	if(LFirst(&(pt->tbl[hv]), &cSlot))
	{
		if(cSlot.key == k)
		{
			LRemove(&(pt->tbl[hv]));
			return cSlot.val;
		}
		else
		{
			while(LNext(&(pt->tbl[hv]), &cSlot))
			{
				if(cSlot.key == k)
				{
					LRemove(&(pt->tbl[hv]));
					return cSlot.val;
				}
			}
		}
	}

	return NULL;
}

Value TBLSearch(Table * pt, Key k)
{
	int hv = pt->hf(k);
	Slot cSlot;

	if(LFirst(&(pt->tbl[hv]), &cSlot))
	{
		if(cSlot.key == k)
		{
			return cSlot.val;
		}
		else
		{
			while(LNext(&(pt->tbl[hv]), &cSlot))
			{
				if(cSlot.key == k)
					return cSlot.val;
			}
		}
	}

	return NULL;
}
////////// Table2 End

int MyHashFunc(int k)
{
	return k % 100;
}

int main(void)
{
	Table myTbl;
	Person * np;
	Person * sp;
	Person * rp;

	TBLInit(&myTbl, MyHashFunc);

	// 데이터 입력 ///////
	np = MakePersonData(900254, "Lee", "Seoul");
	TBLInsert(&myTbl, GetSSN(np), np);

	np = MakePersonData(900139, "KIM", "Jeju");
	TBLInsert(&myTbl, GetSSN(np), np);

	np = MakePersonData(900827, "HAN", "Kangwon");
	TBLInsert(&myTbl, GetSSN(np), np);

	// 데이터 탐색 ///////
	sp = TBLSearch(&myTbl, 900254);
	if(sp != NULL)
		ShowPerInfo(sp);

	sp = TBLSearch(&myTbl, 900139);
	if(sp != NULL)
		ShowPerInfo(sp);

	sp = TBLSearch(&myTbl, 900827);
	if(sp != NULL)
		ShowPerInfo(sp);

	// 데이터 삭제 ///////
	rp = TBLDelete(&myTbl, 900254);
	if(rp != NULL)
		free(rp);

	rp = TBLDelete(&myTbl, 900139);
	if(rp != NULL)
		free(rp);

	rp = TBLDelete(&myTbl, 900827);
	if(rp != NULL)
		free(rp);

	return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

////////// Person Start

#define STR_LEN 50

typedef struct _person

{

int ssn; // 주민등록번호

char name[STR_LEN]; // 이름

char addr[STR_LEN]; // 주소

} Person;

int GetSSN(Person * p)

{

return p->ssn;

}

void ShowPerInfo(Person * p)

{

printf("주민등록번호: %d \n", p->ssn);

printf("이름: %s \n", p->name);

printf("주소: %s \n\n", p->addr);

}

Person * MakePersonData(int ssn, char * name, char * addr)

{

Person * newP = (Person*)malloc(sizeof(Person));

newP->ssn = ssn;

strcpy(newP->name, name);

strcpy(newP->addr, addr);

return newP;

}

////////// Person End

////////// Slot2 Start

typedef int Key;

typedef Person * Value;

typedef struct _slot

{

Key key;

Value val;

} Slot;

////////// Slot2 End

////////// DLinkedList Start

#define TRUE 1

#define FALSE 0

// typedef int LData;

typedef Slot LData;

typedef struct _node

{

LData data;

struct _node * next;

} Node;

typedef struct _linkedList

{

Node * head;

Node * cur;

Node * before;

int numOfData;

int (*comp)(LData d1, LData d2);

} LinkedList;

typedef LinkedList List;

void ListInit(List * plist)

{

plist->head = (Node*)malloc(sizeof(Node));

plist->head->next = NULL;

plist->comp = NULL;

plist->numOfData = 0;

}

void FInsert(List * plist, LData data)

{

Node * newNode = (Node*)malloc(sizeof(Node));

newNode->data = data;

newNode->next = plist->head->next;

plist->head->next = newNode;

(plist->numOfData)++;

}

void SInsert(List * plist, LData data)

{

Node * newNode = (Node*)malloc(sizeof(Node));

Node * pred = plist->head;

newNode->data = data;

while(pred->next != NULL &&

plist->comp(data, pred->next->data) != 0)

{

pred = pred->next;

}

newNode->next = pred->next;

pred->next = newNode;

(plist->numOfData)++;

}

void LInsert(List * plist, LData data)

{

if(plist->comp == NULL)

FInsert(plist, data);

else

SInsert(plist, data);

}

int LFirst(List * plist, LData * pdata)

{

if(plist->head->next == NULL)

return FALSE;

plist->before = plist->head;

plist->cur = plist->head->next;

*pdata = plist->cur->data;

return TRUE;

}

int LNext(List * plist, LData * pdata)

{

if(plist->cur->next == NULL)

return FALSE;

plist->before = plist->cur;

plist->cur = plist->cur->next;

*pdata = plist->cur->data;

return TRUE;

}

LData LRemove(List * plist)

{

Node * rpos = plist->cur;

LData rdata = rpos->data;

plist->before->next = plist->cur->next;

plist->cur = plist->before;

free(rpos);

(plist->numOfData)--;

return rdata;

}

int LCount(List * plist)

{

return plist->numOfData;

}

void SetSortRule(List * plist, int (*comp)(LData d1, LData d2))

{

plist->comp = comp;

}

////////// DLinkedList End

////////// Table2 Start

#define MAX_TBL 100

typedef int HashFunc(Key k);

typedef struct _table

{

// Slot tbl[MAX_TBL];

List tbl[MAX_TBL];

HashFunc * hf;

} Table;

void TBLInit(Table * pt, HashFunc * f);

void TBLInsert(Table * pt, Key k, Value v);

Value TBLDelete(Table * pt, Key k);

Value TBLSearch(Table * pt, Key k);

void TBLInit(Table * pt, HashFunc * f)

{

int i;

for(i=0; i<MAX_TBL; i++)

ListInit(&(pt->tbl[i]));

pt->hf = f;

}

void TBLInsert(Table * pt, Key k, Value v)

{

int hv = pt->hf(k);

Slot ns = {k, v};

if(TBLSearch(pt, k) != NULL) // 키가 중복되었다면

{

printf("키 중복 오류 발생 \n");

return;

}

else

{

LInsert(&(pt->tbl[hv]), ns);

}

Value TBLDelete(Table * pt, Key k)

{

int hv = pt->hf(k);

Slot cSlot;

if(LFirst(&(pt->tbl[hv]), &cSlot))

{

if(cSlot.key == k)

{

LRemove(&(pt->tbl[hv]));

return cSlot.val;

}

else

{

while(LNext(&(pt->tbl[hv]), &cSlot))

{

if(cSlot.key == k)

{

LRemove(&(pt->tbl[hv]));

return cSlot.val;

}

return NULL;

}

Value TBLSearch(Table * pt, Key k)

{

int hv = pt->hf(k);

Slot cSlot;

if(LFirst(&(pt->tbl[hv]), &cSlot))

{

if(cSlot.key == k)

{

return cSlot.val;

}

else

{

while(LNext(&(pt->tbl[hv]), &cSlot))

{

if(cSlot.key == k)

return cSlot.val;

}

return NULL;

}

////////// Table2 End

int MyHashFunc(int k)

{

return k % 100;

}

int main(void)

{

Table myTbl;

Person * np;

Person * sp;

Person * rp;

TBLInit(&myTbl, MyHashFunc);

// 데이터 입력 ///////

np = MakePersonData(900254, "Lee", "Seoul");

TBLInsert(&myTbl, GetSSN(np), np);

np = MakePersonData(900139, "KIM", "Jeju");

TBLInsert(&myTbl, GetSSN(np), np);

np = MakePersonData(900827, "HAN", "Kangwon");

TBLInsert(&myTbl, GetSSN(np), np);

// 데이터 탐색 ///////

sp = TBLSearch(&myTbl, 900254);

if(sp != NULL)

ShowPerInfo(sp);

sp = TBLSearch(&myTbl, 900139);

if(sp != NULL)

ShowPerInfo(sp);

sp = TBLSearch(&myTbl, 900827);

if(sp != NULL)

ShowPerInfo(sp);

// 데이터 삭제 ///////

rp = TBLDelete(&myTbl, 900254);

if(rp != NULL)

free(rp);

rp = TBLDelete(&myTbl, 900139);

if(rp != NULL)

free(rp);

rp = TBLDelete(&myTbl, 900827);

if(rp != NULL)

free(rp);

return 0;

}

whan0623

517