MÔN TIN HỌC - MÃ CHẤM: Ti05a

1.
Các thu t toán tìm ki m trên các c u trúc d li
nh n l c th c hi n b ng cách so sánh các ph n t c a
c u trúc, do v y th i gian truy xu t không nhanh và
ph thu c vào c c a c u trúc. V y c nào
cho phép th c hi n tìm ki m v i hi u su ph c t p
h ng s )?
Các phép toán trên m giúp h n ch s l n so sánh, gi m
thi u th i gian truy xu t. ph c t p các phép toán trên m ng
là O(1) và không ph thu c c a m ng V

C
Ta myItem = myarray [3].

m
3
C

M c s d ng khi x cd
li u l n. Tuy nhiên trong quá trình gi ng d y tôi th y h c sinh v
trong vi c hi u và tm gi i quy t bài toán. Vì v y trong chuyên
này tôi mong mu n giúp h c sinh có cái nhìn t m và
ng d ng c a m trong gi i m t s bài toán c th .
2.

và

1
 .
B. N I DUNG
I. Lý thuy t
1. ( : Hash function)

Khóa có

khác nhau.
nguyên g.
(Division).

2.

chi phí tính

toán

a. Mô t d li u
Gi s
p các khoá (set of keys)
a ch (set of addresses)
ánh x m t khoá k t t p các khoá K thành m a ch
ng trong t p A.
b. M t s phép toán trên m ng
i t o (Initialize)
val new : int -> hashtable

2
(* New(N) t o ra m t b i n ph n t *)
cc am
val sizetable : hashtab
m (Search)
val Search : hashtable * key -> value option
(* Search(ht,key) tr v ng m t s giá tr n c tìm th y trong
hashtable, n u không tr v NONE *)
i ph n t (Insert)
val insert : hashtable * key * value -> unit
i b (remove)
val remove : hashtable * key -> unit
(* remove(ht,key) lo i b khóa và giá tr c a nó n u có, N u không thì không
có tác d ng *)
c. Phân lo i m
i khóa ng v i m a ch , th i gian truy xu t là h ng s
:m ts a ch , lúc này m i m a ch s là
m t danh sách liên k t các ph n t a ch , th i gian truy xu t có th b
suy gi
3. P
các khóa sau
123456
123467
123450

123456 % 10 = 6 ( )
123.467 là 7)
123.450 là 0)

3
 chia là các
.
-
Ta
ó hai hàm :
1.
2.

M-1. .
khác modular trên

Strings C
H

4
 a ch c a khoá "AB" : hashfunc("AB",2) là 131
a ch c a khoá "BA" : hashfunc("BA",2) là 131
Khi t a ch thì g (Collision)
t th u ki n sau:

c phân b u trong b ng.

Khóa là
Sarah Jones
Tony Balognie
Tom Katz

Sarah Jones -> 1038

Tony Balognie -> 1259
Tom Katz -> 746

Bây

Sarah Jones -> 1038% 10 -> 8

Tony Balognie -> 1259% 10 -> 9
Tom Katz -> 746% 10 -> 6
M

ang .
-> 948% 10 -> 8

5
 Chúng ta (collision) vì Sarah Jones
8. Các
là
1. i k t (chaining) t o ra m t c u trúc d li u t tc
các d li u có cùng v u trúc d li u này vào v
trong m ng
2. a ch m (open addressing/probing): m i khi x y ra
va ch m, ti tìm m t v trí còn tr ng trong m t
d li u m Gi s v trí ng v i khoá k là i, i=h(k). T v trí này
chúng ta l t xem xét các v trí i0 , i1 , i2 m 0= i, im
l n th m. Dãy các v trí này s cg i
th sau:
Linear Probing)
P
Double hashing)
n ik t
Chaining là m t cách gi i quy t . M i ô c a m ng có ch a
m t liên k n m t danh sách liên k t có ch a c p khóa-giá tr . C p khóa-giá
tr m c thêm vào cu i danh sách. Thu t toán tìm ki m thông qua danh
tìm khóa phù
h p. u m i ô
c a m ng c kh i
t o null. Danh sách
c t o ra khi giá tr
c thêm
vào l u tiên.
Xem ví
(hình bên). Có

Sarah Jones và John Smith. rah Jones.

6
 m : S d li thu c vào c c a m ng
m: Chèn ch m
tm n i k t:

define M 100
struct nodes
{
int key;
struct nodes *next
};
//khai bao kieu con tro chi nut
typedef struct nodes *NODEPTR
/*
khai bao mang bucket chua M con tro dau cua M bucket
*/
NODEPTR bucket[M];
Các phép toán

int hashfunc (int key)

{
return (key % M);
}
Phép toán kh i t o
void initbuckets( )
{
int b;
for (b=0;b<M;b++);
bucket[b]=NULL;
}
Phép toán empty:

7
 int empty( )
{
int b;
for (b = 0;b<M;b++)
if(bucket[b] !=NULL) return(FALSE);
return(TRUE);
}
Phép toán insert
void insert(int k)
{
int b;
b= hashfunc(k)
place(b,k); //tac vu place cua danh sach lien ket
}
Phép toán remove
void remove ( int k)
{
int b;
NODEPTR q, p;
b = hashfunc(k);
p = hashbucket(k);
q=p;
while(p !=NULL && p->key !=k)
{
q=p;
p=p->next;
}
if (p == NULL)
printf("\n khong co nut co khoa %d" ,k);
else

8
 if (p == bucket [b]) pop(b);
//Tac vu pop cua danh sach lien ket
else
delafter(q);
/*tac vu delafter cua danh sach lien ket*/
}
Phép toán traversebucket:

void traversebucket (int b)

{
NODEPTR p;
p= bucket[b];
while (p !=NULL)
{
printf("%3d", p->key);
p= p->next;
}
}
Phép toán traverse:
Duy
void traverse( )
{
int b;
for (b = 0;n<M; b++)
{
printf("\nButket %d:",b);
traversebucket(b);
}
}

9
Phép toán search:
trong m

NODEPTR search(int k)
{
NODEPTR p;
int b;
b = hashfunc (k);
p = bucket[b];
while(k > p->key && p !=NULL)
p=p->next;
if (p == NULL | | k !=p->key)// khong tim thay
return(NULL);
else//tim thay
// else //tim thay
return(p);
}
a ch m
Linear Probing là c u trúc d li u ch a m t t p các c p khóa-giá tr . M i ô
c am m t c p khóa-giá tr duy nh t. Khi gây ra
m tv b ng cách ánh x m t khóa m i cho m t ô c a m
c chi m gi b i m t khóa, Linear Probing tìm ki m m ng cho v trí tr ng
ti p theo g n nh t và chèn khóa m i t
Thu t toán tìm ki c th c hi , b ng cách tìm ki m m ng tu n
t b u t i v trí nh nh b n khi tìm ra m t ô v i m t
khóa kh p ho c m t ô tr ng. F(i) = i, F(i) là hàm tuy n tính c a i ho c ta có th
vi t:
hi(k) = (h(k) + i) mod size. C th :
h(k) mod size
h(k)+1 mod size

10
h(k)+2 mod size

Bool findEntry(const Key &k, Entry *& entry) {

int probePoint = hash1(k);
do {
entry = &table[probePoint];
probePoint = (probePoint+1) % size;
} while (!entry->isEmpty() && entry->key !=k);
return !entry->isEmpty();
}
: 76, 93, 40, 47, 10, 55

n, cho phép xét t t c các v trí trong m ng, phép

i c th c hi n tr khi m y.

11
 m: ph n t t m l i u t p trung thành các
n, s d c a chu i ch s a ch , tìm ki m tu n
t trong t n
B c hai (Quadratic Probing Method)
c hai ho ng b ng cách l y ch s c và truy
xu t các ch s k ti p b ng m cb n khi tìm th y m t ch
s c a ô tr ng. N n cu i m ng thì tr l i dò t u m ng. Gi s h(k)
là m ánh x m t ph n t k vào m t t p s nguyên [0,m-1], m là
c c a m ng. Dò v trí th i cho giá tr k b i hàm: hi(k) = (h(k)+i2)
mod m. m nên ch n là s nguyên t
i v i m t giá tr c, các ch s c t o ra b i dò tuy n
c tìm ki m nh ng giá tr
nên kém hi u qu
Các ch s c t o ra b c hai: h, h+12, h+22, h+32,
2
. Ví d chu
n mã tìm ô tr ng ti p theo b ng cách s d
Quadratic probing:
bool findEntry(const Key & k, Entry *& entry) {
int probePoint = hash1(k), numProbes = 0;
do {
entry = &table[probePoint];
numProbes++;
probePoint = (probePoint+2*numProbes - 1) % size;
} while (!entry->isEmpty() && entry->key !=k);
return !entry->isEmpty();
}
1 : 76, 40, 48, 5, 55
Quadratic
Probing

12
 : 76, 93, 40, 35, 47
Quadratic
Probing

13
 m va
. . dò ,
là
ch
toàn m tính
m là ).
C hai h1 và h2 , ô chèn giá
k là: h(i,k) = (h1(k) + i.h2

h1(k) mod m
(h1(k)+1.h2(x)) mod m
(h1(k)+2.h2(x)) mod m

m .

h2(x) = R (x mod R). Double hasing:

bool findEntry(const Key & k, Entry *& entry) {
int probePoint = hash1(k), hashIncr = hash2(k);
do {
entry = &table[probePoint];
probePoint = (probePoint + hashIncr) % size;
} while (!entry->isEmpty() && entry->key != k);
return !entry->isEmpty();
}
: 76, 93, 40, 47, 10, 55

Double hasing h1(key) = key mod m, h2(key) = 5- (key

mod 5), h(k,i) = (h1(k) + ih2(k)) mod m.

14
 s

không gian.
).

e.

phép.

u nhanh chóng

15
 t T m

M phép nhanh chóng

-45-
. các mà s
c
tiên là 214 cá
nhân.
chúng ta
S
o
.
5 và xóa
khóa k t hàm (v =
hash (k)), k là trong .
k trong
.
, O(1).

.
khóa k :
tiên, thêm [v].
k vì

16
 . chèn là
gian
chèn k vào .N k vào
m (1) và O
khóa k , sau
.T tìm
óa.

-
T : O(1+1/(1-
-
- Chaining:

T
n/m , m n (khóa)

Bài 1. Cho
67 46 88 91 123 141 152 155 178 288 390 399 465 572 621
734

. Linear Probing

chaining

sion l
67% 20 = 7
46% 20 = 6
88% 20 = 8

17
91% 20 = 11
...
734% 20 = 14
linear probing
(hình bên)

67% 10 = 7
46% 10 = 6
88% 10 = 8
91% 10 = 1
...
734% 10 = 4
p pháp Chaining

Bài 2
h2:
h1(key) = key mod m
h2(key) = {key mod (m-1)} + 1

18
Chèn các khóa {22, 1, 13, 11, 24,

a. Chaining v i h1 h(k) =
h1(k)
b. Linear-Probing v i h1
h(k,i) = (h1(k)+i) mod m
c. Double-Hashing v i h1 là hàm
và h2 là hàm th hai h(k,i)
= (h1(k) + ih2(k)) mod m

Bài 3.

b. T n là gì?

O(nlogn+mlogn)=O(nlogn)

19
 Chèn t t c các ph n t ti vào HT: nO(1) = O(n)
N uS T thì có m tìm ki m thành công:

N uS T ng h p x u
ph c t p: O(n+m) = O(n)
Bài 4.

b
này có
không?

cho

Bài 5. Password

p máy tính usernames and passwords.

c m t kh u nh c chính:

20
 usernames and passwords
tin password.dat
usernames and passwords

usernames passwords
Authentication successful" hay "
Authentication failure". ày:
Login: mary
Password: contrary
Authentication successful

Login: jim
Password: contrary
Authentication failure

Login: bopeep
Password: sheeplost
Authentication failure

nguyên là: 109('m') + 97('a') + 114('r') + 121('y')=441

21
int hash(const string str) const
{
int val = 0;

for (int i=0; i<str.length(); i++)

val += str[i];
return val;
}
Chúng ta

ta có mã sau: int index = dataItem.hash (SearchKey)% 10;

441% 10 = 1.

hashtbl.cpp và hashtble.h -
listlnk.cpp và listlnk.h -
login.cpp - C

password.dat -

Côn
C
L
S
"Authentication successful" hay " Authentication failure".

22
 n tôi có
sau:

phá .

ôi chút.

ngoài. b tl ic a
m d th c hi n in t t c các giá tr trong th
t s px p
Trong th i gian ng n v a tìm hi u và v a vi này nên không
th tránh kh i thi u sót mong s góp ý c a th y cô và các em h
này hoàn thi

23
1. Algorithms, 4th Edition
2. CS 312, Introdution to programming, fall 2015 version
3. wikipedia.org
4. Centre for intelligent Machines (CMI), Michal Langer
5. CS210, Fundamentals of computer science II, Richard Doscelman
6. M t s tài li u khác c ng nghi p

24