Bai Giang Cau Truc Du Lieu

8/4/2019 Bai Giang Cau Truc Du Lieu

http://slidepdf.com/reader/full/bai-giang-cau-truc-du-lieu 1/80

BỘ GIAO THÔNG VẬN TẢITRƢỜNG ĐẠI HỌC HÀNG HẢI BỘ MÔN: KHOA HO C MA Y TI NH

KHOA: CÔNG NGHỆ THÔNG TIN

BÀI GIẢNG

CẤU TRÚC DỮ LIỆU

TÊN HỌC PHẦN : CẤU TRÚC DỮ LIỆU MÃ HỌC PHẦN : 17207TRÌNH ĐỘ ĐÀO TẠO : ĐẠI HỌC CHÍNH QUY DÙNG CHO SV NGÀNH : CÔNG NGHỆ THÔNG TIN

HẢI PHÒNG - 2008



i

MỤC LỤC CHƢƠNG 1. CÁC KHÁI NIỆM MỞ ĐẦU .............................................................................. 1

1.1. Giải thuật và cấu trúc dữ liệu. ......................................................................................... 11.2. Cấu trúc dữ liệu và các vấn đề liên quan. ....................................................................... 11.3. Ngôn ngữ diễn đạt giải thuật........................................................................................... 2

1.4. Kiểu dữ liệu, cấu trúc dữ liệu, kiểu dữ liệu trừu tƣợng................................................... 3CHƢƠNG 2. CÁC KIỂU DỮ LIỆU TRỪU TƢỢNG CƠ BẢN............................................... 6

2. 1. Ngăn xêp - Stack ............................................................................................................ 62.1.1 Khái niệm .................................................................................................................. 62.1.2 Các thao tác ca ngăn xp ......................................................................................... 62.1.3 V d về hoạt động ca một stack ............................................................................. 72.1.4 Cài đt stack bng mảng ............................................................................................ 72.1.5 Ưng dng ca stack ................................................................................................. 10

2.2. Hàng đợi - Queue .......................................................................................................... 122.2.1 Khái niệm ................................................................................................................ 12

2.2.2 Các thao tác cơ bản ca một hàng đợi ..................................................................... 132.2.3 Cài đt hàng đợi sư dng mảng ............................................................................... 132.2.4 V d về hoạt động ca hàng đợi vi cài đt bng mảng vng trn ........................ 162.2.5 Ưng dng cu a ha ng đơ i ........................................................................................... 16

2.3. Danh sa ch liên kêt – Linked list .................................................................................... 172.3.1 Đi nh ngh a ............................................................................................................... 172.3.2 Các thao ta c trên danh sa ch liên kêt. ....................................................................... 172.3.3 Cài đt danh sách liên kt sư dng con tr .............................................................. 182.3.4 Các kiểu danh sách liên kt khác............................................................................. 252.3.5 Mô t số v du sƣ du ng cấu tru c danh sa ch liên kêt .................................................... 262.3.6. Cài đt stack và queue bng con tr ....................................................................... 26

2.4. Bài tập áp dng ............................................................................................................. 26CHƢƠNG 3. CÂY (TREE)...................................................................................................... 28

3.1. Đi nh ngha..................................................................................................................... 283.1.1. Đ th (Graph) ........................................................................................................ 283.1.2. Cây (tree) ................................................................................................................ 29

3.3. Cây t m kiêm nhi phân (Binary Search Tree - BST) .................................................... 313.3.1. Đi nh ngh a .............................................................................................................. 313.3.2. Khơ i ta o cây rô ng ................................................................................................... 323.3.3. Chn thêm một nút mi vào cây............................................................................. 323.3.4. Xa b khi cây một nút ........................................................................................ 33

3.3.5. Tm kim trên cây ................................................................................................... 343.3.6. Duyê t cây ................................................................................................................ 353.3.7. Cài đt cây BST ...................................................................................................... 36

3.4.Cây cân bng – AVL ..................................................................................................... 39CHƢƠNG 4. BẢNG BĂM (HASH TABLE) .......................................................................... 54

4. 1. Đnh ngha bảng băm ................................................................................................... 544.1.1.Đnh ngha : ............................................................................................................. 544.1.2.Kch thƣc ca bảng băm : ...................................................................................... 554.1.3. Phân loại : ............................................................................................................... 554.1.4.Các phép toán trên bảng băm : ................................................................................ 57

4.2.Hàm băm và các loại hàm băm : .................................................................................... 574.2.1.Hàm băm (Hash Function): ..................................................................................... 574.2.2.Một số loại hàm băm : ............................................................................................. 58



ii

4.3.Xung đột và cách xư lý xung đột ................................................................................... 614.3.1. Đnh ngha : ............................................................................................................ 614.3.2.Hệ số tải (Load Factor - ) : .................................................................................... 614.3.3.Một số phƣơng pháp xư lý xung đột : ..................................................................... 614.3.4. Đánh giá : ............................................................................................................... 71

4.4.4.Kt luận : ..................................................................................................................... 72

4.5. Bài tập áp dng ............................................................................................................. 72TÀI LIỆU THAM KHẢO. ....................................................................................................... 75



iii

Tên học phần: Cấu trúc dữ liệu Loại học phần: 2Bộ môn phụ trách giảng dạy: Khoa học Máy tnh Khoa phụ trách: CNTTMã học phần: 17207 Tổng số TC: 3

TS tit Lý thuyt Thực hành/Xemina Tự học Bài tập ln Đ án môn học 60 30 30 0 0 0

Điều kiện tiên quyết: Sinh viên phải học xong các học phần sau mi đƣợc đăng ký học phần này: Toán cao cấp, Toán rời rạc, Ngôn ngữ C, Tin học đại cƣơng.

Mục tiêu của học phần: Cung cấp kin thức và rn luyện kỹ năng thực hành cấu trúc dữ liệu cho sinh viên.

Nội dung chủ yếu - Những vấn đề cơ bản về cấu trúc dữ liệu; - Các cấu trúc dữ liệu cơ bản

- Danh sách liên kt; - Ngăn xp, hàng đợi; - Cấu trúc cây; - Bảng băm, ...

Nội dung chi tiết của học phần:

TÊN CHƢƠNG MỤC PHÂN PHỐI SỐ TIẾT

TS LT TH/Xemina BT KTChƣơng I : Khái niệm liên quan đến CTDL 2 2 0

1.1. Giải thuật và cấu trúc dữ liệu. 1.2. Giải thuật và các vấn đề liên quan.1.3. Ngôn ngữ diễn đạt giải thuật. 1.4. Kiểu dữ liệu, cấu trúc dữ liệu, kiểu dữ liệu trừutƣợng. Chƣơng II : Các kiểu dữ liệu trừu tƣợng cơ bản 12 6 62.1. Danh sách2.1.1. Khái niệm danh sách 2.1.2. Các phép toán trên danh sách2.1.3. Cài đt danh sách 2.1.4. Các dạng danh sách liên kt (DSLK): DSLK

đơn, vng, kép, … 2.2. Ngăn xp (stack) 2.2.1. Khái niệm 2.2.2. Cài đt ngăn xp bởi mảng, DSLK 2.2.3. Ưng dng 2.3. Hàng đợi (queue) 2.3.1. Khái niệm 2.3.2. Cài đt hàng đợi bởi mảng, DSLK 2.3.3. Ưng dng 2.4. Bài tập áp dng

Chƣơng III: Cây (tree). 18 9 8 13.1. Khái niệm. 3.2. Cây tổng quát.



iv

TÊN CHƢƠNG MỤC PHÂN PHỐI SỐ TIẾT

TS LT TH/Xemina BT KT3.2.1. Biểu diễn cây tổng quát. 3.2.2. Duyệt cây tổng quát. 3.2.3. Vài v d áp dng. 3.3. Cây nh phân.

3.3.1. Đnh ngha và tnh chất 3.3.2. Lƣu trữ cây. 3.3.3. Duyệt cây. 3.3.4. Cây nh phân nối vng. 3.4. Các phép toán thực hiện trên cây nh phân. 3.4.1. Dựng cây 3.4.2. Duyệt cây để tm kim 3.4.3. Sắp xp cây nh phân 3.5. Cây tm kim nh phân (binary search tree) 3.5.1. Khái niệm, cài đt.

3.5.2. Cây AVL3.6. Bài tập

Chƣơng IV: Bảng băm (hash table) 14 7 6 14.1. Khái niệm 4.2. Các loại hàm băm 4.3. Các phƣơng pháp giải quyt xung đột 4.4. Đánh giá hiệu quả các phƣơng pháp băm 4.5. Bài tập áp dng

Nhiệm vụ của sinh viên : Tham dự các buổi thuyt trnh ca giáo viên, tự học, tự làm bài tập do giáo viên giao,

tham dự các bài kiểm tra đnh kỳ và cuối kỳ.

Tài liệu học tập : 1. Đinh Mạnh Tƣờng, Cấu trúc dữ liệu và thuật toán, Nhà xuất bản ĐH QG Hà Nội,2004.2. Đỗ Xuân Lôi, Cấu trúc dữ liệu và giải thuật , Nhà xuất bản ĐH QG Hà Nội, 2004. 3. Robert Sedgewick, Cẩm nang thuật toán, NXB Khoa học kỹ thuật, 2000.

Hình thức và tiêu chuẩn đánh giá sinh viên:- Hnh thức thi cuối kỳ : Thi vit. - Sinh viên phải đảm bảo các điều kiện theo Quy ch ca Nhà trƣờng và ca Bộ

Thang điểm: Thang điểm chữ A, B, C, D, F

Điểm đánh giá học phần: Z = 0,3X + 0,7Y. Bài giảng này là tài liệu chính thức và thống nhất ca Bộ môn Khoa học máy tnh,

Khoa Công nghệ thông tin và đƣợc dùng để giảng dạy cho sinh viên.Ngày phê duyệt: / /20

Trƣởng Bộ môn: ThS. Nguyễn Hữu Tuân (ký và ghi rõ họ tên)



1

CHƢƠNG 1. CÁC KHÁI NIỆM MỞ ĐẦU

1.1. Giải thuật và cấu trúc dữ liệu.

Ðể giải một bài toán trong thực t bng máy tnh ta phải bắt đầu từ việc xác đnh bàitoán. Nhiều thời gian và công sức b ra để xác đnh bài toán cần giải quyt, tức là phải trả lờirõ ràng câu hi "phải làm g?" sau đ là "làm nhƣ th nào?". Thông thƣờng, khi khởi đầu, hầu

ht các bài toán là không đon giản, không rõ ràng. Ðể giảm bt sự phức tạp ca bài toán thựct, ta phải hnh thức ha n, ngha là phát biểu lại bài toán thực t thành một bài toán hnhthức (hay cn gọi là mô hnh toán). C thể c rất nhiều bài toán thực t c cùng một mô h ìnhtoán.

V d : Tô màu bản đ th gii. Ta cần phải tô màu cho các nƣc trên bản đ th gii. Trong đ mỗi nƣc đều đƣợc tô

một màu và hai nƣc láng giềng (cùng biên gii) th phải đƣợc tô bng hai màu khác nhau.Hãy tm một phƣơng án tô màu sao cho số màu sư dng là t nhất.

Ta c thể xem mỗi nƣc trên bản đ th gii là một đỉnh ca đ th, hai nƣc lánggiềng ca nhau th hai đỉnh ứng vi n đƣợc nối vi nhau bng một cạnh. Bài toán lúc này trở thành bài toán tô màu cho đ th nhƣ sau: Mỗi đỉnh đều phải đƣợc tô màu, hai đỉnh c cạnhnối th phải tô bng hai màu khác nhau và ta cần tm một phƣơng án tô màu sao cho số màuđƣợc sư dng là t nhất.

Ðối vi một bài toán đã đƣợc hnh thức hoá, chúng ta c thể tm kim cách giải trongthuật ngữ ca mô hnh đ và xác đnh c hay không một chƣong trnh c sẵn để giải. Nukhông c một chƣơng trnh nhƣ vậy th t nhất chúng ta cũng c thể tm đƣợc những g đã bitvề mô hnh và dùng các tnh chất ca mô hnh để xây dựng một giải thuật tốt.

Khi đã c mô hnh thch hợp cho một bài toán ta cần cố gắng tm cách giải quyt bàitoán trong mô hnh đ. Khởi đầu là tm một giải thuật, đ là một chƣỗi hữu hạn các chỉ th(instruction) mà mỗi chỉ th c một ý ngha rõ ràng và thực hiện đƣợc trong một lƣợng thờigian hữu hạn.

Nhƣng xét cho cùng, giải thuật chỉ phản ánh các phép xư lý, cn đi tƣợng để xư lýtrong máy tnh chnh là dữ liệu (data ), chúng biểu diễn các thông tin cần thit cho bài toán:các dữ liệu vào, các dữ liệu ra, dữ liệu trung gian, … Không thể ni ti giải thuật mà khôngngh ti: giải thuật đ đƣợc tác động trên dữ liệu nào, cn xét ti dữ liệu th phải bit dữ liệuấy cần đƣợc giải thuật g tác động để đƣa ra kt quả mong muốn.. Nhƣ vậy, giữa cấu trúc dữliệu và giải thuật c mối liên quan mật thit vi nhau.

1.2. Cấu trúc dữ liệu và các vấn đề liên quan.

Trong một bài toán, dữ liệu bao gm một tập các phần tư cơ sở, đƣợc gọi là dữ liệunguyên tư. Dữ liệu nguyên tư c thể là một chữ số, một ký tự, … cũng c thể là một số, mộtxâu, … tùy vào bài toán. Trên cơ sở các dữ liệu nguyên tư, các cung cách khả d theo đ lien

kt chúng lại vi nhau, sẽ đãn đn các cấu trúc dữ liệu khác nhau. Lựa chọn một cấu trúc dữ liệu thch hợp để tổ chức dữ liệu vào và trên cơ sở đ xâydựng đƣợc giải thuật xư lý hữu hiệu đƣa ti kt quả mong muốn cho bài toán (dữ liệu ra), làmột khâu quan trọng.

Cách biểu diễn một cấu trúc dữ liệu trong bộ nh đƣợc gọi là cấu trúc lƣu trữ. Đây chnhlà cách cài đt cấu trúc ấy trên máy tnh và trên cơ sở các cấu trúc lƣu trữ này mà thực hiệncác phép xư lý. C thể c nhiều cấu trúc lƣu trữ khác nhau cho cùng một cấu trúc dữ liệu vàngƣợc lại.

Khi đề cập ti cấu trúc lƣu trũ, cần phân biệt: cấu trúc lƣu trữ tƣơng ứng vi bộ nh trong – lƣu trữ trong; cấu trúc lƣu trữ ứng vi bộ nh ngoài – lƣu trữ ngoài. Chúng c đcđiểm và cách xư lý riêng.



2

1.3. Ngôn ngữ diễn đạt giải thuật.

Việc sư dng một ngôn ngữ lập trnh bậc cao để diễn đạt giải thuật, nhƣ Pascal, C, C++,… sẽ gp một số hạn ch sau:

- Phải luôn tuân th các quy tắc cht chẽ về cú pháp ca ngôn ngữ khin cho việc trnh bày về giải thuật và cấu trúc dữ liệu c thiên hƣng nng nề, g b.

- Phải ph thuộc vào cấu trúc dữ liệu tiền đnh ca ngôn ngữ nên c lúc không thể hiệnđƣợc đầy đ các ý về cấu trúc mà ta muỗn biểu đạt Một khi đã c mô hình thích hợp cho bài toán, ta cần hnh thức hoá một giải thuật, một

cấu trúc dữ liệu trong thuật ngữ ca mô hnh đ. Khởi đầu là vit những mệnh đề tổng quátri tinh ch dần thành những chuỗi mệnh đề c thể hơn, cuối cùng là các chỉ th thch hợptrong một ngôn ngữ lập trnh.

Ở bƣc này, ni chung, ta c một giải thuật, một cấu trúc dữ liệu tƣơng đi rõ ràng, ngần giống nhƣ một chƣơng trnh đƣợc vit trong ngôn ngữ lập trnh, nhƣng n không phải làmột chƣơng trnh chạy đƣợc v trong khi vit giải thuật ta không chú trọng nng đn cú phápca ngôn ngữ và các kiểu dữ liệu cn ở mức trừu tƣợng chứ không phải là các khai báo cài đtkiểu trong ngôn ngữ lập trnh.

Chẳng hạn vi giải thuật tô màu đ th GREEDY, giả sư đ th là G, giải thuật sẽ xácđnh một tập hợp Newclr các đỉnh ca G đƣợc tô cùng một màu, mà ta gọi là màu mi C ở trên. Ðể tin hành tô màu hoàn tất cho đ th G th giải thuật này phải đƣợc gọi lp lại cho đnkhi toàn thể các đỉnh đều đƣợc tô màu.

void GREEDY ( GRAPH *G, SET *Newclr ){Newclr = ; /*1*/ for (mỗi đỉnh v chƣa tô màu ca G) /*2*/ if (v không đƣợc nối vi một đỉnh nào trong Newclr) /*3*/

{

đánh dấu v đã đƣợc tô màu; /*4*/ thêm v vào Newclr; /*5*/ }

}Trong th tc bng ngôn ngữ giả này chúng ta đã dùng một số từ khoá ca ngôn ngữ C

xen lẫn các mệnh đề ting Việt. Ðiều đc biệt nữa là ta dùng các kiểu GRAPH, SET c vẻ xalạ, chúng là các "kiểu dữ liệu trừu tƣợng" mà sau này chúng ta sẽ vit bng các kha i báo thíchhợp trong ngôn ngữ lập trnh c thể. D nhiên, để cài đt th tc này ta phải c thể hoá dầnnhững mệnh đề bng ting Việt ở trên cho đn khi mỗi mệnh đề tƣơng ứng vi một doạn mãthch hợp ca ngôn ngữ lập trnh. Chẳng hạn mệnh đề if ở /*3*/ c thể chi tit hoá hơn nữanhƣ sau:

void GREEDY ( GRAPH *G, SET *Newclr ){Newclr= ; /*1*/ for (mỗi đỉnh v chƣa tô màu ca G) /*2*/

{int found=0; /*3.1*/ for (mỗi đỉnh w trong Newclr) /*3.2*/ if (c cạnh nối giữa v và w) /*3.3*/

found=1; /*3.4*/ if (found==0)/*3.5*/ {

đánh dấu v đã đƣợc tô màu; /*4*/ thêm v vào Newclr; /*5*/

}



3

}

}GRAPH và SET ta coi nhƣ tập hợp. C nhiều cách để biểu diễn tập hợp trong ngôn ngữ

lập trnh, để đơn giản ta xem các tập hợp nhƣ là một danh sách (LIST) các số nguyên biểudiễn chỉ số ca các đỉnh và kt thúc bng một giá tr đc biệt NULL. Vi những qui ƣc nhƣvậy ta c thể tinh ch giải thuật GREEDY một bƣc nữa nhƣ sau:

void GREEDY ( GRAPH *G, LIST *Newclr ){int found;int v,w ;Newclr= ;v= đỉnh đầu tiên chƣa đƣợc tô màu trong G;while (v<>null)

{found=0;w=đỉnh đầu tiên trong newclr;

while( w<>null) && (found=0){if ( c cạnh nối giữa v và w )

found=1;else w= đỉnh k tip trong newclr; }if (found==0 ){

Ðánh dấu v đã đƣợc tô màu;Thêm v vào Newclr;

}

v= đỉnh chƣa tô màu k tip trong G; }}

1.4. Kiểu dữ liệu, cấu trúc dữ liệu, kiểu dữ liệu trừu tƣợng

Khái niệm trừu tƣợ ng hóaTrong tin học, trừu tƣợng ha ngha là đơn giản ha, làm cho n sáng sa hơn và dễ hiểu

hơn. C thể trừu tƣợng ha là che di những chi tit, làm nổi bật cái tổng thể. Trừu tƣợng hac thể thực hiện trên hai kha cạnh là trừu tƣợng ha dữ liệu và trừu tƣợng ha chƣơng trnh.

Trừu tƣợ ng hóa chƣơ ng trìnhTrừu tƣợng ha chƣơng trnh là sự đnh ngha các chƣơng trnh con để tạo ra các phép

toán trừu tƣợng (sự tổng quát ha ca các phép toán nguyên thy). Chẳng hạn ta c thể tạo ramột chƣơng trnh con Matrix_Mult để thực hiện phép toán nhân hai ma trận. Sau khiMatrix_mult đã đƣợc tạo ra, ta c thể dùng n nhƣ một phép toán nguyên thy (chẳng hạnphép cộng hai số).

Trừu tƣợng ha chƣơng trnh cho phép phân chia chƣơng trnh thành các chƣơng trnhcon. Sự phân chia này sẽ che dấu tất cả các lệnh cài đt chi tit trong các chƣơng trnh con. Ởcấp độ chƣơng trnh chnh, ta chỉ thấy lời gọi các chƣơng trnh con và điều này đƣợc gọi là sựbao gói.

V d nhƣ một chƣơng trnh quản lý sinh viên đƣợc vit bng trừu tƣợng ha c thểlà:

void main()

{Nhap(Lop);



4

Xu_ly (Lop);Xuat (Lop);}Trong chƣơng trnh trên, Nhap, Xu_ly, Xuat là các phép toán trừu tƣợng. Chúng che dấu

bên trong rất nhiều lệnh phức tạp mà ở cấp độ chƣơng trnh chnh ta không nhn thấy đƣợc.Cn Lop là một bin thuộc kiểu dữ liệu trừu tƣợng mà ta sẽ xét sau.

Chƣơng trnh đƣợc vit theo cách gọi các phép toán trừu tƣợng c lệ thuộc vào cáchcài đt kiểu dữ liệu không? Trừu tƣợng hóa dữ liệu Trừu tƣợng ha dữ liệu là đnh ngha các kiểu dữ liệu trừu tƣợng Một kiểu dữ liệu trừu t ƣợ ng là một mô hình toán học cùng với một tập hợp các phép

toán (operator) trừu t ƣợ ng đƣợ c định nghĩa trên mô hình đó. V d tập hợp số nguyên cùngvi các phép toán hợp, giao, hiệu là một kiểu dữ liệu trừu tƣợng.

Trong một ADT các phép toán c thể thực hiện trên các đi tƣợng (toán hạng) không chỉthuộc ADT đ, cũng nhƣ kt quả không nhất thit phải thuộc ADT. Tuy nhiên, phải c t nhấtmột toán hạng hoc kt quả phải thuộc ADT đang xét.

ADT là sự tổng quát hoá của các kiểu dữ liệu nguyên thƣ ỷ.

Ðể minh hoạ ta c thể xét bản phác thảo cuối cùng ca th tc GREEDY. Ta đã dùngmột danh sách (LIST) các số nguyên và các phép toán trên danh sách newclr là:

- Tạo một danh sách rỗng.- Lấy phần tư đầu tiên trong danh sách và trả về giá tr null nu danh sách rỗng.- Lấy phần tư k tip trong danh sách và trả về giá tr null nu không cn phần tư k

tip. - h.

Nu chúng ta vit các chƣơng trnh con thực hiện các phép toán này, th ta dễ dàng thaycác mệnh đề hnh thức trong giải thuật bng các câu lệnh đơn giản

Câu lệnh Mệnh đề hnh thức

MAKENULL(newclr) newclr=;

w=FIRST(newclr) w=phần tư đầu tiên trong newclr

w=NEXT(w,newclr) w=phần tư k tip trong newclr

INSERT( v,newclr) Thêm v vào newclr

Ðiều này cho thấy sự thuận lợi ca ADT, đ là ta c thể đnh ngha một kiểu dữ liệu tuỳý cùng vi các phép toán cần thit trên n ri chúng ta dùng nhƣ là các đi tƣợng nguyênthuỷ. Hơn nữa chúng ta c thể cài đt một ADT bng bất kỳ cách nào, chƣơng trnh dùngchúng cũng không thay đổi, chỉ c các chƣơng trnh con biểu diễn cho các phép toán caADT là thay đổi.

Cài đặt ADT là sự thể hiện các phép toán mong muốn (các phép toán trừu tƣợng) thành các câu lệnh ca ngôn ngữ lập trnh, bao gm các khai báo thch hợp và các th tc thực hiệncác phép toán trừu tƣợng. Ðể cài đt ta chọn một cấu trúc dữ liệu thch hợp c trong ngônngữ lập trnh hoc là một cấu trúc dữ liệu phức hợp đƣợc xây dựng lên từ các kiểu dữ liệu cơ

bản ca ngôn ngữ lập trnh.

Sự khác nhau giữa kiểu dữ liệu và kiểu dữ liệu trừu tƣợng là g? Mc dù các thuật ngữ kiểu dữ liệu (hay kiểu - data type), cấu trúc dữ liệu (data



5

structure), kiểu dữ liệu trừu tƣợng (abstract data type) nghe nhƣ nhau, nhƣng chúng c ýngha rất khác nhau.

Kiểu dữ liệu là một tập hợp các giá tr và một tập hợp các phép toán trên các giá tr đ.V d kiểu Boolean là một tập hợp c 2 giá tr TRUE, FALSE và các phép toán trên n nhƣOR, AND, NOT …. Kiểu Integer là tập hợp các số nguyên c giá tr từ -32768 đn 32767cùng các phép toán cộng, trừ, nhân, chia, Div, Mod…

Kiểu dữ liệu c hai loại là kiểu dữ liệu sơ cấp và kiểu dữ liệu c cấu trúc hay cn gọi làcấu trúc dữ liệu. Kiểu dữ liệu sơ cấp là kiểu dữ liệu mà giá tr dữ liệu ca n là đơn nhất. V d: kiểu

Boolean, Integer…. Kiểu dữ liệu c cấu trúc hay cn gọi là cấu trúc dữ liệu là kiểu dữ liệu mà giá tr dữ liệu

ca n là sự kt hợp ca các giá tr khác. V d: ARRAY là một cấu trúc dữ liệu. Một kiểu dữ liệu trừu tƣợng là một mô hnh toán học cùng vi một tập hợp các phép

toán trên n. C thể ni kiểu dữ liệu trừu tƣợng là một kiểu dữ liệu do chúng ta đnh ngha ở mức khái niệm (conceptual), n chƣa đƣợc cài đt c thể bng một ngôn ngữ lập trnh.

Khi cài đt một kiểu dữ liệu trừu tƣợng trên một ngôn ngữ lập trnh c thể, chúng ta phảithực hiện hai nhiệm v:

1. Biểu diễn kiểu dữ liệu trừu tƣợng bng một cấu trúc dữ liệu hoc một kiểu dữ liệutrừu tƣợng khác đã đƣợc cài đt.

2. Vit các chƣơng trnh con thực hiện các phép toán trên kiểu dữ liệu trừu tƣợng mà tathƣờng gọi là cài đt các phép toán.

Bài tập:

1. Tm hiểu các kiểu dữ liệu cơ sở trong C

2. Tm hiểu các cấu trúc dữ liệu mảng, cấu trúc trong C và thực hiện một số bài tập cơ

bản nhƣ nhập, xuất



6

CHƢƠNG 2. CÁC KIỂU DỮ LIỆU TRỪU TƢỢNG CƠ BẢN

2. 1. Ngăn xê p - Stack

2.1.1 Khái niệm

Khái niệm: Ngăn xêp (stack) là một tập hợp các phần tư (items) cùng kiểu đƣợc tổchƣ

c mô t ca

ch tuân tƣ (chnh v th một số tài liệu cn đnh ngha ngăn xp là một danh sách

tuyên t nh ca c phân tƣ vơ i ca c thao ta c truy câ p ha n chê tơ i ca c phần tƣ cu a danh sa ch đo )trong đo phần tƣ đƣơ c thêm va o cuối cu ng cu a tâ p hơ p se la phần tƣ bi loa i bo đầu tiên kho itâ p hơ p. Các ngăn xp thƣờng đƣợc gọi là các cấu trúc LIFO (Last In First Out).

Ví dụ vê ngăn xê p: Chông ta i liê u cu a mô t công chƣ c văn pho ng, chông đ a … la ca cv d về ngăn xp.

Chú ý: Phân tƣ duy nhất co thê truy câ p tơ i cu a mô t ngăn xêp la phân tƣ mơ i đƣơ cthêm va o gần đây nhất (theo thơ i gian) ca ngăn xp.

2.1.2 Các thao tác của ngăn xếp

Đối vi một ngăn xp chỉ c 2 thao ta c cơ ba n, thao ta c thƣ nhất thƣ c hiê n thêm mô t phân tƣ va o stack go i la push, thao ta c thƣ hai la đo c gia tri cu a mô t phần tƣ va loa i bo n khistack go i la pop.

Đê nhất qua n vơ i ca c thƣ viê n ca i đă t câu tru c stack chuâ n STL (và một số tài liệucũng phân chia nhƣ vậy), ta xa c đi nh ca c thao ta c đôi vơ i mô t stack gôm co :

1. Thao ta c push(d) sẽ đt phần tư d lên đ nh cu a stack .

2. Thao ta c pop() loại b phần tư ở đỉnh stack .3. Thao ta c top() sẽ trả về giá tr phần tư ở đỉnh stack .4. Thao ta c size() cho biêt số phần tƣ hiê n ta i đang lƣu trong stack

Ngoài hai thao tác cơ bản trên chúng ta cần co mô t sô thao ta c phu trơ kha c: chă ng ha nlàm th nào để bit là một stack không c phần tư nào – tƣ c la rô ng (empty) hay la đầy (full)tƣ c la không thê thêm va o bât cƣ mô t phần tƣ na o kha c nƣ a. Đê thƣ c hiê n điêu na y ngƣơ i tathƣơ ng thêm hai thao ta c tiên ha nh kiê m tra la empty() và full().

Đê đa m ba o không xa y ra t nh tra ng go i la stack overflow (tràn stack – không thê thêmvào stack bất cứ phần tư nào) chúng ta c thể cho hàm push tra về chă ng ha n 1 trong trƣơ ng

hơ p thƣ c hiê n tha nh công va 0 nêu không tha nh công.



7

2.1.3 Ví dụ về hoạt động của một stack

Giả sư chúng ta c một stack kch thƣc bng 3 (c thể chứa đƣợc tối đa 3 phần tƣ ) vàcác phần tư ca stack là các số nguyên trong khoảng từ -100 đn 100. Sau đây la minh ho acác thao tác đối vi stack và kt quả thực hiện ca các thao tác đ .

Thao ta c Nô i dung stack Kê t qua

Khơ i ta o ()push(55) (55) 1

push(-7) (-7, 55) 1

push(16) (16, -7, 55) 1

pop (-7, 55) 16

push(-8) (-8, -7, 55) 1

push(23) (-8, -7, 55) 0

pop (-7, 55) -8

pop (55) -7

pop () 55

pop () 101

2.1.4 Cài đặt stack bng mảng

Câu tru c dƣ liê u stack co thê ca i đă t băng ca ch sƣ dng một mảng và một số nguyêntop_idx đê chƣ a ch sô cu a phần tƣ ơ đ nh stack .

Ngăn xêp rô ng khi top_idx = -1 và đầy khi top_idx = n-1 trong đo n la k ch thƣơ c cu amảng.

Khi thƣ c hiê n thao ta c push chu ng ta tăng top_idx lên 1 và ghi dữ liệu vào v tr tƣơng

ứng ca mảng.Khi thƣ c hiê n thao ta c pop chu ng ta ch viê c gia m ch sô top_idx đi 1. V d về ngăn xp cài đt bng mảng :Giả sư chúng ta sư dng mảng E[0..4] để chứa các phần tư ca stack va biên top_idx

để lƣu chỉ số ca phần tư ở đỉnh stack . Trong ba ng sau cô t cuối cu ng kêt qua la gia tri tra vêca việc gọi hàm.

Thao ta c top_idx E[0] E[1] E[2] E[3] E[4] Kê t qua khơ i ta o -1 ? ? ? ? ?

push(55) 0 55 ? ? ? ? 1

push(-7) 1 55 -7 ? ? ? 1

push(16) 2 55 -7 16 ? ? 1

pop 1 55 -7 16 ? ? 16

push(-8) 2 55 -7 -8 ? ? 1

pop 1 55 -7 -8 ? ? -8

pop 0 55 -7 -8 ? ? -7

Chú ý rng trong minh họa này chúng ta thấy rng một số giá tr vẫn cn trong mảngnhƣng chu ng đƣơ c xem nhƣ không co trong stack v không co thao ta c na o truy câ p tơ i chu ng .

Ni chúng th phần tư E[i] đƣơ c xem la ra c nêu nhƣ i>top_idx. Tại sao chúng ta không xa bcác phần tư này (chă ng ha n nhƣ đă t chu ng bng các giá tr mc đnh nào đ?).



8

Cài đt ca stack bng ngôn ngữ C nhƣ sau (áp dng stack cho bài toán chuyển số từcơ số 10 sang cơ số 2):

#include <stdio.h>#include <stdlib.h>const int MAX_ELEMENT = 100; // so phan tu toi da cua stack la 100

// khai bao stack chua cac so nguyentypedef struct{

int * data; // khai bao mang dongint top_idx;

} stack; // ham khoi tao stack rongvoid init(stack *s);void push(stack * s, int d);

void pop(stack *s);int top(const stack *s);int size(const stack *s);int empty(const stack *s);int full(const stack *s);

// ham giai phong bo nho danh cho stackvoid clear(stack *s);

int main()

{int n;int bit;stack s;init(&s);printf("Nhap so nguyen n = ");scanf("%d", &n);while(n){

push(&s, n%2);n /= 2;

}while(!empty(&s)){

bit = top(&s);pop(&s);printf("%d", bit);

}

clear(&s);return 0;



9

}void init(stack *s){

s->data = (int*)malloc(MAX_ELEMENT * sizeof(int));s->top_idx = -1;

}void clear(stack *s){

if(s->data != NULL)free(s->data);

s->top_idx = -1;}void push(stack *s, int d){

s->data[++s->top_idx] = d;}void pop(stack *s){

s->top_idx --;}int top(const stack *s){

return s->data[s->top_idx];

}int size(const stack *s){

return s->top_idx+1;}int empty(const stack * s){

return (s->top_idx==-1)?(1):(0);}

int full(const stack * s){

return (s->top_idx==MAX_ELEMENT-1)?(1):(0);}Câu tru c stack co thê ca i đă t băng ma ng theo ca c ca ch kha c , hoă c ca i đă t băng con tro

(chúng ta sẽ học về phần ca i đă t na y sau phần danh sa ch liên kêt).Stack co thê đƣơ c ca i đă t băng ca ma ng va danh sa ch liên kêt vâ y khi na o chu ng ta sƣ

dng mảng và khi nào dùng danh sách liên kt ?

Danh sa ch liên kê t Mảng

Cƣ mô i phân tƣ cu a stack cầnc thêm 2 byte (1 con tro ).

Xin câp pha t mô t vu ng nhơ co k chthƣơ c cô đi nh va co thê mô t phần



10

Nêu k ch thƣơ c cu a mô t phầntƣ lơ n th không đa ng kê nhƣng nêu la kiê u int th k chthƣơ c se tăng gấp đôi.

trong số đo không bao giơ đƣơ c du ngđn và nu nhƣ kch thƣc ca một

phân tƣ lơ n th vu ng nhơ la ng ph na ycũng rất ln.

Không co giơ i ha n vê sô phân

tƣ cu a stack .

Kch thƣc tối đa ca stack đƣợc xác

đi nh ngay khi no đƣơ c ta o ra.2.1.5 Ưng dụng của stack

Ví dụ 1

Stack co thê du ng đê kiê m tra ca c că p ky hiê u cân băng trong mô t chƣơng tr nh (chă nghạn {}, (), []).

V d {()} và {()({})} là các biểu thức đúng cn {((} và {(}) không pha i la ca c biê uthƣ c đu ng.

Chúng ta thấy rng nu nhƣ một biểu thức là đúng th trong quá trnh đọc các ký hiệu

ca biểu thức đ nu chúng ta thấy một ký hiệu đng (chă ng ha n ), } hay ]) th ký hiệu này phải khp vi ký hiệu mở đƣợc đọc thấy gần nhất (theo thơ i gian), và khi đ việc sư dngstack cho ca c ba i toa n nhƣ thê na y la hoa n toa n hơ p ly .

Chúng ta c thể sư dng thuật toán sau đây :while not end of Input

S = next sumbolif(s is opening symbol)

push(s)else // s la dấu đo ng ngoă c

if(stack.empty)Báo lỗi

elseR = stack.top()stack.pop()if(!match(s,r))

Báo lỗi If(!stack.empty())

Báo lỗi

V d:1. Input: {()}s = {, push{,s = (, push (,s = ), r = pop = (, r,s matchs = }, r = pop = {, r,s matchEnd of Input, stack rô ng => biê u thƣ c la đu ng.V d: Input = { ( ) ( { ) } } (sai)

Input = { ( { } ) { } ( ) }



11

Ví dụ 2

Sƣ du ng Stack đê chuyê n đô i ca c dạng biểu thức đại số. Trong v du na y chu ng ta se xem xe t ca c thuâ t toa n sƣ du ng stack đê chuyê n đô i tƣ biê u đa i số ơ da ng trung tố (dạng thôngthƣơ ng, hay co n go i la infix notation) thành các biểu thức ở dạng tiền tố (prefix notation, haycn gọi là biểu thức Balan – Polish notation) và biểu thức hậu tố (postfix notation, hay biê u

thƣ c Balan ngƣơ c).Biê u thƣ c đa i số la mô t sƣ kêt hơ p đu ng đắn giƣ a ca c toa n ha ng (operand) và các toán

tƣ (operator). Toán hạng là các số liệu c thể thực hiện đƣợc các thao tác tnh toán toán học .Toán hạng cũng c thể là các bin số x , y, z hay ca c hăng số . Toán tư là một ký hiệu chỉ rathao ta c t nh toa n toa n ho c hay logic giƣ a ca c toa n ha ng, chă ng ha n nhƣ ca c toa n ha ng +, -, *,

/, ^ (toán tư mũ ha). Viê c đi nh ngh a ca c biê u thƣ c đa i số mô t ca ch chă t che vê ly thuyêt la nhƣ sau:

Mô t toa n ha ng la mô t biê u thƣ c hơ p lê

Nêu express ion1 và expression2 là hai biểu thức hợp lệ và op là một toán tư thmô t kêt hơ p hơ p lê giƣ a biê u thƣ c expression 1 vơ i biê u thƣ c expression 2 sƣ du ngtoán tư op sẽ cho ta một biểu thức đại số hợp lệ

Theo đi nh ngh a trên ta co x + y*z la mô t biê u thƣ c đa i sô hơ p lê nhƣng *x y z+không pha i la mô t biê u thƣ c hơ p lê . Trong ca c biê u thƣ c đa i số ngƣơ i ta co thê sƣ du ng ca cdấu đo ng va mơ ngoă c.

Mô t biê u thƣ c đa i số co thê đƣơ c biê u diê n băng 3 dạng khác nhau.Biê u thƣ c trung tố (infix notation): đây la da ng biê u diê n phô biên nhất cu a ca c biê u

thƣ c đa i số, trong ca c biê u thƣ c trung tố , toán tư nm giữa các toán hạng . V d nhƣ 2 + 3 * (7

– 3)Biê u thƣ c tiền tố (prefix notation): dạng biểu diễn này do nhà toán học ngƣời Balan

Jan Lukasiewicz đƣa ra va o nhƣ ng năm 1920. Trong da ng biê u diê n na y, toán tư đứng trƣccác toán hạng. V d nhƣ + * 2 3 7

Biê u thƣ c hâ u tố (postfix notation): hay co n go i la biê u thƣ c Balan ngƣơ c, toán tưđƣ ng sau ca c toa n ha ng. V d nhƣ 2 3 – 7 *.

Câu ho i ma chu ng ta co thê đă t ra ngay lâ p tƣ c ơ đây la : tại sao lại cần sư dng ti cácdạng biểu diễn tiền tố và hậu tố trong khi chúng ta vẫn quen và vẫn sư dng đƣợc các biểuthƣ c ơ da ng trung tố .

Lý do là các biểu thức trung tố không đơn giản và dễ dàng khi tnh giá tr ca chúngnhƣ chu ng ta vâ n tƣơ ng. Đê t nh gia tri cu a mô t biê u thƣ c trung tố chu ng ta cần t nh tơ i đô ƣutiên cu a ca c toa n tƣ cu a biê u thƣ c va ca c qui tắc kêt hơ p. Độ ƣu tiên ca các toán tư và các quităc kêt hơ p se quyêt đi nh tơ i qua tr nh t nh toa n gia tri cu a mô t biê u thức trung tố.

Chúng ta c bảng độ ƣu tiên ca các toán tư thƣờng gp nhƣ sau :

Toán tư Độ ƣu tiên ()

+ (mô t ngôi), - (mô t ngôi), !

+ (cô ng), - (trƣ )

<, <=, >, >===, !=



12

&&

||

Khi đa biêt đô ƣu tiên toa n tƣ chu ng ta c thể tnh toán các biểu thức chẳng hạn 2 + 4* 5 sẽ bng 22 v trƣc ht cần lấy 4 nhân vơ i 5, sau đo kêt qua nhâ n đƣơ c đem cô ng vơ i 2 v

phép nhân c độ ƣu tiên cao hơn phép cộng. Nhƣng vơ i biê u thƣ c 2*7/3 th ta không thê t nh

đƣơ c v phe p nhân va phe p chia co đô ƣ u tiên băng nhau, khi đo cần sƣ du ng tơ i ca c qui tắckêt hơ p ca c toa n tƣ . Qui tắc kêt hơ p se cho chu ng ta biêt thƣ tƣ thƣ c hiê n ca c toa n tƣ u co cu ngđô ƣu tiên. Chă ng ha n chu ng ta co qui tắc kêt hơ p tra i, ngha là các toán tư cùng độ ƣu tiên sẽđƣơ c thƣ c hiê n tƣ tra i qua pha i, hay qui tắc kêt hơ p pha i. Nêu theo qui tắc kêt hơ p tra i th

phép toán trên sẽ c kt quả là 4 (lấy kêt qua nguyên).V những vấn đề liên quan ti độ ƣu tiên toán tư và các qui luật kt hợp nên chúng ta

thƣơ ng sƣ du ng ca c da ng biê u diê n tiên tô va hâ u tố trong viê c t nh toa n ca c biê u thƣ c đa i số .Cả biểu thức hậu tố và tiền tố đều c một ƣu điểm hơn so vi cách biểu diễn trung tố:

đo la khi t nh toa n ca c biê u thƣ c ơ da ng tiền tố va hâ u tố chu ng ta không cần pha i đê y tơ i đô

ƣu tiên toa n tƣ va ca c luâ t kêt hơ p. Tuy nhiên so vơ i biê u thƣ c trung tố , các biểu thức tiền tốvà hậu tố kh hiểu hơn và v th nên khi biểu diễn chúng ta vẫn sư dng dạng biểu thức trungtô, nhƣng khi t nh toa n se sƣ du ng da ng tiên tô hoă c hâ u tố , điều na y yêu cầu cần co các thuậttoán chuyển đổi từ dạng trung tố sang dạng tiền tố hoc hậu tố .

Viê c chuyê n đô i cu a chu ng ta co thê thƣ c hiê n băng ca ch sƣ du ng cấu tru c stack hoă cây biê u thƣ c (chƣơng 5), phần na y chu ng ta se ch xem xe t ca c thuâ t toa n sƣ du ng stack v thuâ t toa n sƣ du ng cây biê u thƣ c kha phƣ c ta p.

Thuâ t toa n chuyê n đô i biê u thƣ c da ng trung tố tha nh da ng hâ u tố sƣ du ng stack .

Ví dụ 3Phân t ch đô ƣu tiên toa n tƣ Chúng ta c thể sư dng cấu tru c stack đê phân t ch va lƣơ ng gia ca c biê u thƣ c toa n

học kiểu nhƣ:5 * (( (9+8) * (4 * 6) ) + 7)Trƣơ c hêt chu ng ta chuyê n chu ng tha nh da ng hâ u tố (postfix):5 8 9 + 4 6 * * 7 + *Sau đo sƣ du ng mô t stack đê thƣ c hiê n viê c t nh toa n gia tri cu a biê u thƣ c hâ u tô nhâ n

đƣơ c.

Ngoài ra các stack cn c thể dùng để cài đt các thuật toán đệ qui và khư đệ qui cáccài đt thuật toán.

2.2. Hàng đợi - Queue

2.2.1 Khái niệm

Hàng đợi là một tập hợp các phần tư cùng kiểu đƣợc tổ chức một cách tuần tự (tuyêntnh) trong đo phân tƣ đƣơ c thêm va o đầu tiên se la phân tƣ đƣơ c loa i bo đâu tiên kho i ha ngđơ i. Các hàng đợi thƣờng đƣợc gọi là các cấu trúc FIFO (First In First Out).

Các v d thực t về hàng đợi mà chúng ta c thể thấy trong cuộc sống hàng ngày đ là

đoa n ngƣơ i xêp ha ng chơ mua ve tầu, danh sa ch ca c cuô c he n cu a mô t gia m đốc, danh sa chcác công viê c cần la m cu a mô t ngƣơ i …



13

Cũng c thể đnh ngha hàng đợi là một danh sách tuyn tnh các phần tư giống nhauvơ i mô t sô thao ta c ha n chê tơ i ca c phần tƣ trên danh sa ch đo .

2.2.2 Các thao tác cơ bản của một hàng đơ i

Tƣơng tƣ nhƣ cấu tru c ngăn xêp, chúng ta đnh ngha các thao tác trên hàng đợi tuântheo ca

i đă t chuâ n cu

a ha

ng đơ i trong thƣ viê n STL va

ca c ta

i liê u kha c , gôm co

:

1. push(d): thêm phần tƣ d va o vi tr ơ cuối ha ng đơ i.2. pop(): loại b phần tư ở đầu hàng đợi .3. front(): trả về giá tr phần tư ở đầu hàng đợi .4. back(): trả về giá tr phần tư ở cuối hàng đợi .5. size(): trả về số phần tư đang ở trong hàng đợi .6. empty(): kiê m tra ha ng đơ i co rô ng hay không.7. full(): kiê m tra ha ng đơ i đây (chỉ cần khi cài đt hàng đợi bng mảng ).

V d:

Thao ta c Nô i dung Giá trị trả về Khơ i ta o ( )

push(7) ( 7 )

push(8) ( 7, 8 )

push(5) ( 7, 8, 5 )

pop() ( 8, 5 ) 7

pop() ( 5 ) 8

2.2.3 Cài đặt hàng đợi sư dụng mảng

Đê ca i đă t cấu tru c ha ng đơ i chu ng ta co thê sƣ du ng ma ng hoă c sƣ du ng con tro ( phầnnày sẽ học sau phần danh sách liên kt ):

Ta lƣu ca c phần tƣ cu a ha ng đơ i trong mô t ma ng data . Đầu ca hàng đợi là phần tưđầu tiên, và đuôi đƣợc chỉ ra bng cách sư dng một bin tail .

push(d) đƣơ c thƣ c hiê n mô t ca ch dê da ng : tăng tail lên 1 và chn phần tư vào v trđo

pop() đƣơ c thƣ c hiê n không hiê u qua : tất ca ca c phần tƣ đều se bi dôn vê đâu ma ngdo đo đô phƣ c ta p la O(n).

Làm th nào chúng ta c thể cải thiện tnh hnh này ?Thay v ch sƣ du ng mô t biên ch sô tail chu ng ta sƣ dng hai bin tail và head, khi cân

loại b (pop) mô t phần tƣ kho i ha ng đơ i chu ng ta se tăng biên head lên 1:Tuy vâ y vâ n co n co vân đề , đo la sau n lần push() (n la k ch thƣơ c ma ng) mảng sẽ đầy

kê ca trong trƣơ ng hơ p n gần nhƣ rỗng về mt logic. Đê gia i quyêt vấn đề na y chu ng ta se sƣ dng lại các phần tư ở đầu mảng . Khi push() mô t phần tƣ mơ i tail se đƣơ c tăng lên 1 nhƣngnêu nhƣ no ơ cuôi ma ng th se đă t no băng 0.

Vân đề mơ i nảy sinh ở đây là làm th nào chúng ta c thể xác đnh đƣợc khi nào hàngđơ i rô ng hoă c đầy?



14

Cách giải quyt đơn giản là ta sẽ dùng một bin lƣu số phần tư thực sự ca hàng đợiđể giải quyt cho tất cả các thao tác kiê m tra ha ng đơ i rô ng, đầy hoă c lấy số phần tƣ cu a ha ngđơ i.

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

const int MAX_ELEMENT = 100; // so phan tu toi da cua queue la 100 // khai bao queue chua cac so nguyentypedef struct{

int * data; // khai bao mang dongint head;int tail;int cap; // luu so phan tu cua hang doi

} queue;

// ham khoi tao queue rongvoid init(queue *q);void push(queue * s, int d);void pop(queue *q);int front(const queue *q);int back(const queue *q);int size(const queue *q);int empty(const queue *q);int full(const queue *q);

// ham giai phong bo nho danh cho queuevoid clear(queue *q);int main(){

int a[] = {3, 5, 1, 8};int n = 4;int i;int d;queue q;

init(&q);for(i=0;i<n;i++)

push(&q, a[i]);while(!empty(&q)){

d = front(&q);printf("%d ", d);pop(&q);

}

clear(&q);return 0;



15

}void init(queue *q){

q->data = (int*)malloc(MAX_ELEMENT * sizeof(int));q->head = q->tail = -1;

q->cap = 0;}void clear(queue *q){

if(q->data != NULL)free(q->data);

q->head = q->tail = -1;q->cap = 0;

}

void push(queue *q, int d){

q->tail = (q->tail + 1) % MAX_ELEMENT;q->data[q->tail] = d;if(q->cap==0)

// neu hang doi rong thi sau khi push // ca head va tail deu chi vao 1 phan tuq->head = q->tail;

q->cap++;

}void pop(queue *q){

q->head = (q->head + 1)%MAX_ELEMENT;q->cap--;if(q->cap==0)

q->head = q->tail = -1;}int front(const queue *q)

{return q->data[q->head];

}int back(const queue *q){

return q->data[q->tail];}int size(const queue *q){

return q->cap;}



16

int empty(const queue *q){

return (q->cap==0)?(1):(0);}int full(const queue *q)

{return (q->cap==MAX_ELEMENT-1)?(1):(0);

}

2.2.4 Ví dụ về hoạt động của hàng đợi vi cài đặt bng mảng vng trn

Ta gia sƣ ma ng lƣu ca c phân tƣ cu a ha ng đơ i la E[0..3], các bin head, tail lƣu vi tr ca phần tư ở đầu và cuối hàng đợi , cô t R la cô t kêt qua thƣ c hiê n ca c thao ta c trên ha ng đơ i,các dấu ? tƣơng ƣ ng vơ i gia tri bất ky .

Thao ta c head tail E[0] E[1] E[2] E[3] R

Khơ i ta o -1 -1 ? ? ? ?push(55) 0 0 55 ? ? ?

push(-7) 0 1 55 -7 ? ?

push(16) 0 2 55 -7 16 ?

pop() 1 2 55 -7 16 ? 55

push(-8) 1 3 55 -7 16 -8

pop() 2 3 55 -7 16 -8 -7

pop() 3 3 55 -7 16 -8 16

push(11) 3 4 11 -7 16 -8

2.2.5 Ưng dụng của hàng đợi

Trong ca c hê điều ha nh:

Hàng đợi các công việc hoc các tin trnh đang đợi để đƣợc thực hiện

Hàng đợi các tin trnh chờ các tn hiệu từ các thit b IO

Các file đƣơ c gƣ i tơ i ma y in

Mô pho ng ca c hê thống ha ng đơ i thơ i trong thƣ c tê .

Các khách hàng trong các cưa hàng tạp ha , trong ca c hê thống ngân ha ng

Các đơn đt hàng ca một công ty Phng cấp cứu

Các cuộc gọi điện thoại hoă c ca c đă t ha ng ve ma y bay , các đt hàng ca kháchhàng …

Các ứng dng khác:Thƣ tƣ topo: vơ i mô t tâ p ca c sƣ kiê n, và các cp (a, b) trong đo sƣ kiê n a co đô ƣu tiên

cao hơn so vơ i sƣ kiê n b ( bài toán lập lch), duyệt đ th theo chiều rộng (Breadth FirstSearch).

Bài tập: Hãy vit chƣơng trnh chuyển đổi một biểu thức dạng infix (dạng thôngthƣơ ng) đơn gia n (không chƣ a ca c dấu ()) thành một biểu thức dạng tiền tố (prefix). V d nàyxem nhƣ mô t ba i tâ p đê sinh viên tƣ la m.



17

2.3. Danh sa ch liên kê t – Linked list

2.3.1 Đi nh ngh a

Danh sa ch liên kêt (linked list) là một tập hợp tuyn tnh các phần tư cùng kiểu gọi làcác nút (node), mô i nu t co ca c đă c điê m sau đây:

Mô i nu t co t nhất hai trƣơ ng (field) mô t trƣơ ng go i la trƣơ ng dƣ liê u (data) vàtrƣơ ng co n la i la trƣơ ng liên kêt (link) tr ti (point to) (thƣơ ng go i la next).

Trƣơ ng liên kêt cu a phần tƣ thƣ i cu a danh sa ch se tr ti phần tư thứ (i+1) cadanh sa ch

Phân tƣ đầu tiên cu a danh sa ch liên kêt đƣơ c go i la head va phân tƣ cuôi cu ngđƣơ c go i la tail. Head không chƣ a dƣ liê u va trƣơ ng next cu a tail se ch va o NULL .

Trƣơ ng data la trƣơ ng chƣ a dƣ liê u ma chu ng ta thƣ c sƣ lƣu trong danh sa ch liênkêt

Giá tr NULL và việc thực hiện tr ti (point to) ca mỗi liên kt thực sự diễn ra

nhƣ thê na o phu thuô c nhiêu va o viê c ca i đă t cu thê danh sa ch liên kêt.

C nhiều loại danh sách liên kt khác nhau tùy thuộc vào cấu trúc ca mỗi phần tưtrong danh sa ch (sô trƣơ ng liên kêt vơ i ca c phần tƣ kha c trong danh sa ch) nhƣng cơ ba n nhâtlà danh sách liên kt đơn (single linked list), mỗi phần tư c một trƣờng liên kt nhƣ trên hnhvẽ minh họa, và khi chúng ta ni đn danh sách liên kt , nêu không co ca c chu gia i đi ke m th

ngầm hiê u đo la danh sa ch liên kêt đơn.

2.3.2 Các thao tác trên danh sách liên kết.

Tƣơng tƣ nhƣ ca c câu tru c cơ ba n stack va queue, chúng ta đnh ngha các thao tác cadanh sa ch liên kêt dƣ a trên ca i đă t chuâ n cu a cấu tru c danh sa ch liên kêt trong thƣ viê n STL:

1. push_front(d): thêm mô t phần tƣ va o đầu danh sách.2. push_back(d): thêm mô t phân tƣ va o cuối danh sa ch.3. pop_front(): loại b phần tư ở đầu danh sách .4. pop_back(): loại b phần tư cuối danh sách.

5. erase(): xa b một phần tư khi danh sách.6. insert(): chn một phần tư mi vào một v tr c thể ca danh sách.7. size(): cho biêt số phần tƣ trong danh sa ch.8. empty(): kiê m tra danh sa ch rô ng.9. begin(): trả về phần tư ở đầu danh sách .10. end(): trả về phần tư ở cuối danh sách.11. sort(): săp xêp danh sa ch theo trƣơ ng kho a (là một trƣờng con ca trƣờng dữ liệu).12. merge(): trô n danh sa ch vơ i mô t danh sa ch kha c.13. clear(): xa b toàn bộ các phần tư ca danh sách .

14. find(): tm kim một phần tư trong danh sách theo kha tm kim.



18

Các thao ta c kha c cu ng co thê đƣơ c ca i đă t vơ i mô t danh sa ch liên kêt đê la m cho côngviê c cu a ca c lâ p tr nh viên trơ nên dê da ng hơn:

Di chuyê n mô t phân tƣ trong danh sa ch

Đổi hai phần tư cho nhau

2.3.3 Cài đặt danh sách liên kê t sƣ du ng con tro typedef struct Node{

// truong du lieuint data;struct Node * next;

} NodeType;Khơ i ta o danh sa ch:NodeType * head, * tail;

head = new node;headnext = NULL;Các thao tác trên sẽ tạo ra một danh sách liên kt rô ng (empty – không chƣ a phần tƣ

nào)Trong ca i đă t na y chu ng ta cho tail ch va o NULL , thƣơ ng đƣơ c đi nh ngh a la 0. Do đo

trƣơ ng next cu a mô t phân tƣ se la 0, và khi đ chúng ta bit là chúng ta đang ở phần tư tailca danh sa ch.

Ở đây tr ti (point to) c ngha là chúng ta thực sự sư dng các con tr . Chúng ta sẽsơ m thấy răng chu ng ta không cần thiêt pha i sƣ du ng ca c con tro thƣ c sƣ đê ca i đă t mô t danh

sách liên kt.Chn một nút (node) vào danh sách liên kết

Dê da ng nhâ n thấy răng ca ch đơn gia n nhất đê che n mô t nu t mơ i va o mô t danh sa chliên kêt la đă t nu t đo ơ đầu (hoă c cuối) ca danh sách. Hoă c cu ng co thê chu ng ta muốn che ncác phần tư vào giƣ a danh sa ch.

Chn X vào giữa I và S:struct node * A;A = new node;

Akey = X;

Anext = Inext;Inext = A;



19

Đê thƣ c hiê n điều na y chu ng ta cần 2 tham chiêu tơ i hai nu t trong danh sa ch va khôngcần quan tâm tơ i đô da i (sô phân tƣ ) ca danh sách. Tuy nhiên thƣ c hiê n viê c na y vơ i ca cmảng chắc chắn sẽ khác nhiều .Xóa một nút (node) khi danh sách liên kết

Xa một nút khi danh sách liên kt rất đơn giản chúng ta chỉ cần thay đổi một con

tr, tuy nhiên vấn đề la chu ng ta cần biêt nu t na o tro tơ i nu t ma chu ng ta đi nh xo a. Giả sưchúng ta bit nút i tr ti nút x và chúng ta muốn xa b x :

inext = xnext;

Chỉ c một tham chiu b thay đổi không ph thuộc vào đô da i cu a danh sa ch (so sa nhvơ i ca i đă t băng ma ng, tuy vâ y vâ n co vân đề vơ i ca i đă t trên ).Di chuyê n (move) mô t nu t trong danh sa ch liên kê t

Di chuyê n mô t nu t trong danh sa ch liên kêt bao gôm hai thao ta c: xa b một nút sauđo che n va o mô t nu t. V d chúng ta muốn di chuyển nút T từ cuối danh sách lên đầu danhsách:

Mô t lân nƣ a chu ng ta thấy răng thao ta c di chuyê n na y ch đo i ho i thay đô i 3 tham

chiêu va không phu thuô c va o đô da i cu a danh sa ch (so sa nh điều na y vơ i ca i đă t băng ma ng).Cài đt minh họa đầy đ ca danh sách liên kt đơn :#include <stdio.h>#include <conio.h>#include <stdlib.h>

// khai bao cau truc cho mot nut cua danh sachtypedef struct Node{

// truong du lieu

int data;struct Node * next;



20

} NodeType; // khai bao kieu danh sachtypedef struct{

NodeType * head;

NodeType * tail; // so phan tu cua danh sachint spt;

}LList; // ham khoi tao danh sachvoid init(LList * list);

// ham them 1 phan tu vao dau danh sachvoid push_front(LList *list, int d);

// ham them mot phan tu vao cuoi danh sach

void push_back(LList *list, int d); // ham xoa phan tu o cuoi danh sachint pop_back(LList * list);

// ham xoa phan tu o dau danh sachint pop_front(LList * list);

// ham tra ve phan tu dau tienint begin(const LList * list);

// ham tra ve phan tu cuoi cungint end(const LList * list);

void insertAfter(LList * list, NodeType * p);void insertBefore(LList * list, NodeType * p);void eraseAfter(LList * list, NodeType * p);void eraseBefore(LList * list, NodeType * p);

// ham in danh sachvoid printList(LList list);

// ham sap xep danh sachvoid sort(LList *list);

// ham tim kiem trong danh sach

NodeType * find(LList *, int d); // giai phong toan bo danh sachvoid clear(LList * list);

// ham tron hai danh sach, ket qua luu trong danh sach thu nhatvoid merge(LList *list1, const LList *list2);

// ham kiem tra danh sach lien ket co rong khongint empty(const LList *list);int main(){

LList myList;LList list2;



21

init(&myList);init(&list2);push_front(&myList, 10);push_front(&myList, 1);push_front(&myList, 12);

push_back(&myList, 20);push_back(&myList, 23);push_back(&myList, 25);sort(&myList);printList(myList);push_front(&list2, 14);push_front(&list2, 9);merge(&myList, &list2);printList(myList);

printList(list2);clear(&myList);printList(myList);return 0;

}void init(LList * list){

list->head = list->tail = NULL;list->spt = 0;

}void printList(LList list){

NodeType * tmp;tmp = list.head;while(tmp!=NULL){

printf("%d ", tmp->data);tmp = tmp->next;

}printf("\n");

}void push_front(LList * list, int d){

NodeType * tmp = (NodeType *)malloc(sizeof(NodeType));tmp->data = d;if(list->spt==0){

tmp->next = NULL;list->head = list->tail = tmp;



22

}else{

tmp->next = list->head;list->head = tmp;

}list->spt = list->spt+1;

}void push_back(LList * list, int d){

NodeType * tmp = (NodeType *)malloc(sizeof(NodeType));tmp->data = d;tmp->next = NULL;if(list->spt==0)

list->head = list->tail = tmp;else{

list->tail->next = tmp;list->tail = tmp;

}list->spt = list->spt+1;

}NodeType * find(LList * list, int d)

{NodeType * tmp = list->head;while(tmp!=NULL){

if (tmp->data==d)break;

tmp = tmp->next;}return tmp;

}int pop_back(LList * list){

NodeType * p, * q;int ret = -1;

if(list->spt>0){

p = list->head;

q = NULL;while(p->next!=NULL)



23

{q = p;p = p->next;

}if(q!=NULL)

{ // danh sach chi co 1 phan tuq->next = NULL;list->tail = q;

}else

list->head = list->tail = NULL;ret = p->data;free(p);

list->spt = list->spt-1;}return ret;

}int pop_front(LList * list){

int ret=-1;NodeType * tmp;if(list->spt>0)

{tmp = list->head;if(list->spt==1){

// danh sach chi co 1 phan turet = list->head->data;list->head = list->tail = NULL;

}elselist->head = list->head->next;

free(tmp);list->spt = list->spt - 1;

}return ret;

} // sap xep dung thuat toan doi cho truc tiep (interchange sort)void sort(LList * list){

// sƣ du ng thuâ t toa n săp xêp nô i bo t Bubble sort

NodeType * p, * q;int tmp;



24

p = list->head;while(p!=NULL){

q = p->next;

while(q!=NULL){

if(q->data < p->data){

tmp = q->data;q->data = p->data;p->data = tmp;

}q = q->next;

}p = p->next;

}}void clear(LList * list){

NodeType * p, * q;if(list->spt>0){

p = list->head;list->head = list->tail = NULL;list->spt = 0;while(p){

q = p->next;free(p);p = q;

}

}}void merge(LList *list1, const LList *list2){

NodeType * tmp;tmp = list2->head;while(tmp){

push_back(list1, tmp->data);

tmp = tmp->next;}



25

}int empty(const LList *list){

return (list->spt==0)?(1):(0);}

int begin(const LList * list){

return list->head->data;}int end(const LList * list){

return list->tail->data;}

So sa nh giƣ a danh sa ch liên kê t va ma ng

Danh sa ch liên kêt co sô phân tƣ co thê thay đô i va không cần chỉ rõ kch thƣc tối đaca danh trƣc. Ngƣơ c la i ma ng la ca c cấu tru c co k ch thƣơ c cố đi nh

Chúng ta c thể sắp xp lại, thêm va xo a ca c phân tƣ kho i danh sa ch liên kêt ch vơ imô t sô cô đi nh ca c thao ta c. Vơ i ma ng ca c thao ta c na y thƣơ ng tƣơng đƣơng vơ i k ch thƣơ cmảng.

Đê t m đên phân tƣ thƣ i trong mô t danh sa ch liên kêt chu ng ta cần pha i do qua i-1 phân tƣ đƣ ng trƣơ c no trong danh sa ch (i-1 thao ta c) trong khi vơ i ma ng đê la m điều na y ch mất 1 thao ta c.

Tƣơng tƣ k ch thƣơ c cu a mô t danh sa ch không pha i hiê n nhiên ma biêt đƣơ c trong khi

chúng ta luôn bit rõ kch thƣc ca một mảng trong chƣơng trnh (tuy nhiên co mô t ca ch đơngiản để khắc phc điều na y).

2.3.4 Các kiểu danh sách liên kết khác

Danh sách liên kt đôi (double linked list) giống nhƣ một danh sách liên kt đơn ngoạitrừ việc mỗi nút có thêm một trƣờ ng previous tr vào nút đứng trƣ c nó.

V i danh sách liên kt đôi các thao tác nhƣ tm kim, xóa b một nút khi danh sáchthực hiện dễ dàng hơn nhƣng đng thời cũng mất nhiều bộ nh hơn và số lƣợ ng các lệnh để thực hiện một thao tác trên danh sách liên kt đôi chắc chắn cũng xấp xỉ gấp đôi so v i danhsách liên kt đôi.

Ngoài ra còn có một loại danh sách liên kt khác đƣợ c gọi là danh sách liên kt vòng(circular-linked list).

Nút cuối cùng tr ti nút đầu tiênDanh sách liên kt vòng có thể là danh sách liên kt đơn hoc danh sách liên kt đôi Nó có thể đƣợc cài đt v i một đầu (head) cố đnh hoc thay đổi



26

Việc cài đt danh sách liên kt có thể không cần thit sư dng t i các con tr. Thay

vào đ chúng ta c thể sư dng các mảng để cài đt các danh sách liên kt, ở đây chúng takhông đi sâu vào xem xét c thể cài đt một danh sách liên kt bng mảng nhƣ th nào nhƣngcũng không quá kh để hình dung cách thức hoạt động ca các danh sách kiểu nhƣ th.

Kết luận:Danh sách liên kt là các cấu trúc dữ liệu rất giống v i các mảngCác thao tác chnh thƣờng đƣợ c sư dng đối v i một danh sách liên kt là thêm, xóa

và tìm kim trên danh sáchThao tác chèn và xóa có thể thực hiện v i thờ i gian hng số Việc tìm một phần tư trong danh sách liên kt thƣờ ng mất thờ i gian tuyn tính (xấp xỉ

độ dài danh sách) và trƣờ ng hợ p xấu nhất là đúng bng độ dài ca danh sách. Đây cũng chnh

là một trong những nhƣợc điểm l n nhất ca danh sách liên kt.2.3.5 Mô t sô v du sƣ du ng câ u tru c danh sa ch liên kê t

Các bài toán mà danh sách liên kt thƣờng đƣợc sư dng là các bài toán trong đ viê csƣ du ng ma ng se la không thuâ n lơ i, chă ng ha n mô t ba i toa n yêu cầu ca c thao ta c thêm , xa

b xảy ra thƣờng xuyên th lựa chọn thông minh sẽ là sư dng danh sách liên kt . Mô t v du nƣ a la khi ta la m viê c vơ i ca c đô thi thƣa (các cạnh t) lơ n (nhƣng số đ nh nhiêu), thay v du ngmô t ma ng hai chiều, ta se du ng mô t ma ng ca c danh sa ch liên kêt, mô i danh sa ch liên kêt chƣ acác đỉnh liền kề ca một đỉnh ca đ th .

2.3.6. Cài đặt stack va queue bă ng con tro Vê ba n chất, các cấu trúc dữ liệu stack và queue là các cấu trúc danh sách liên kt hạn

chê, các thao tác đƣợc gii hạn so vi cấu trúc danh sách liên kt . V th c thể coi một stack hay queue la mô t danh sa ch liên kêt, và c thể lợi dng cài đt bng con tr ca danh sách liênkêt đê ca i đă t ca c cấu tru c stack va queue (sƣ du ng con tro ). Phân na y đƣơ c đê la i xem nhƣmô t ba i tâ p cu a sinh viên.

2.4. Bài tập áp dụng

1. Vit khai báo và các chƣơng trnh con cài đt danh sách bng mảng. Dùng cácchƣơng trnh con này để vit:

a. Chƣơng trnh con nhận một đãy các số nguyên nhập từ bàn phm, lƣu trữ n trongdanh sách theo thứ tự nhập vào.b. Chƣơng trnh con nhận một đãy các số nguyên nhập từ bàn phm, lƣu trữ n trong



27

danh sách theo thứ tự ngƣợc vi thứ tự nhập vào.c. Vit chƣơng trnh con in ra màn hnh các phần tư trong danh sách theo thứ tự ca

nó trong danh sách.2. Tƣơng tự nhƣ bài tập 1. nhƣng cài đt bng con tr.3. Vit chƣơng trnh con sắp xp một danh sách chứa các số nguyên, trong các

trƣờng hợp:

a. Danh sách đƣợc cài đt bng mảng (danh sách đc).b. Danh sách đƣợc cài đt bng con tr (danh sách liên kt).4. Vit chƣơng trnh con thêm một phần tư trong danh sách đã c thứ tự sao cho ta vẫn

c một danh sách c thứ tự bng cách vận dng các phép toán co bản trên danh sách5. Vit chƣơng trnh con tm kim và xa một phần tư trong danh sách c thứ tự.6. Vit chƣơng trnh con nhận vào từ bàn phm một đãy số nguyên, lƣu trữ n trong

một danh sách c thứ tự không giảm, theo cách sau: vi mỗi phần tư đƣợc nhập vào chƣơngtrnh con phải tm v tr thch hợp để xen n vào danh sách cho dúng thứ tự. Vit chƣơng trnhcon trên cho trƣờng hợp danh sách đƣợc cài đt bng mảng và cài đt bng con tr và trongtrƣờng hợp tổng quát (dùng các phép toán cơ bản trên danh sách)

7. Vit chƣơng trnh con loại b các phần tư trùng nhau (giữ lại duy nhất 1 phần tư)

trong một danh sách c thứ tự không giảm, trong hai trƣờng hợp: cài đt bng mảng và cài đt bng con tr.

8. Vit chƣơng trnh con nhận vào từ bàn phm một đãy số nguyên, lƣu trữ n trongmột danh sách c thứ tự tang không c hai phần tư trùng nhau, theo cách sau: vi mỗi phần tưđƣợc nhập vào chƣơng trnh con phải tm kim xem n c trong danh sách chƣa, nu chƣa cth xen n vào danh sách cho đúng thứ tự. Vit chƣơng trnh con trên cho trƣờng hợp danhsách đƣợc cài đt bng mảng và cài đt bng con tr.

9. Vit chƣơng trnh con trộn hai danh sách liên kt chứa các số nguyên theo thứ tựtăng để đƣợc một danh sách cũng c thứ tự tăng.

10. Vit chƣơng trnh con xoá khi danh sách lƣu trữ các số nguyên các phần tư là sốnguyên lẻ, cũng trong hai trƣờng hợp: cài đt bng mảng và bng con tr.

11. Vit chƣơng trnh con tách một danh sách chứa các số nguyên thành hai danhsách: một danh sách gm các số chẵn cn cái kia chứa các số lẻ.



28

CHƢƠNG 3. CÂY (TREE).

3.1. Đinh ngh a

3.1.1. Đ thị (Graph)

Trƣơ c khi xem xe t kha i niê m thê na o la mô t cây (tree) chúng ta nhắc lại khái niệm đ th

(graph) đa đƣơ c ho c trong ho c phần Toa n rơ i ra c : Đ th G bao gm hai thành phần chnh : tâ pcác đỉnh V (Vertices) và tập các cung E (hay ca nh Edges ), thƣơ ng viêt ơ da ng G = <V, E>.Trong đo tâ p ca c đ nh V la tâ p ca c đối tƣơ ng cu ng loa i , đô c lâ p, chă ng ha n nhƣ ca c điê m trênmă t phă ng to a đô , hoă c tâ p ca c tha nh phố , tâ p ca c tra ng tha i cu a mô t tro chơi , mô t đôi tƣơ ngthƣ c nhƣ con ngƣơ i , … tất ca đều co thê la ca c đ nh cu a mô t đô thi na o đo . Tâ p ca c cung E la tâ p ca c môi quan hê hai ngôi giƣ a ca c đ nh cu a đô thi , đối vơ i đ nh la ca c điê m th đây co thê là quan hệ về khoa ng ca ch, tâ p đ nh la ca c tha nh phô th đây co thê la quan hê về đƣơ ng đi (ctôn ta i đƣơ ng đi trƣ c tiêp na o giƣ a ca c tha nh phố hay không ), hoă c nêu đ nh la ca c tra ng tha ica một tr chơi th cạnh c thể là cách bin đổi (transform) để đi từ trạng thái này sang mộttrạng thái khác , quá trnh chơi chnh là bin đổi từ trạng thái ban đầu ti trạng thái đch (cngha là đi tm một đƣờng đi).

Ví dụ về đ thị:

Hnh 5.1. Đ th c 6 đ nh va 7 cạnh, tham kha o tƣ wikipedia.

C rất nhiều vấn đề liên quan ti đ th , ở phần này chúng ta ch nhắc lại một số kháiniê m liên quan.Mô t đô thi đƣơ c go i la đơn đô thi (simple graph) nêu nhƣ không co đƣơ ng đi giƣ a hai

đ nh bât ky cu a đô thi bi lă p la i , ngƣơ c la i nêu nhƣ co đƣơ ng đi na o đo bi lă p la i hoă c tôn ta ikhuyên (self-loop), mô t da ng cung đi tƣ 1 đ nh đên ch nh đ nh đo , th đ th đƣợc gọi là đa đth (multigraph).

Giƣ a hai đ nh u , v trong đô thi co đƣơ ng đi trƣ c tiêp th u , v đƣơ c go i la liên kê vơ inhau, cạnh (u, v) đƣơ c go i la liên thuô c vơ i hai đ nh u, v.

Đ th đƣợc gọi là đ th c hƣng (directed graph) nêu nhƣ ca c đƣơ ng đi giƣ a hai đ nh bât ky trong đô thi phân biê t hƣơ ng vơ i nhau, khi đo ca c quan hê giƣ a ca c đ nh đƣơ c go i ch nhxác là các cung , ngƣơ c la i đô nêu không phân biê t hƣơ ng giƣ a ca c đ nh trong ca c ca nh nối

giƣ a hai đ nh th đ th đƣợc gọi là đ th vô hƣng (undirected graph), khi đo ta no i tâ p E la tâ p ca c ca nh cu a đô thi .Các cung hay các cạnh ca đ thj c thể đƣợc gán các giá tr gọi là các trọng số

(weight), mô t đô thi co thê là đ th c trọng số hoc không c trọng số . V d nhƣ đối vi đth mà các đỉnh là các thành phố ta c thể gán trọng số ca các cung là độ dài đƣờng đi nốigiƣ a ca c tha nh phô hoă c chi ph đi trên con đƣơ ng đo …

Mô t đƣơ ng đi (path) trong đô thi la mô t da y ca c đ nh v 1, v2, …, vk, trong đo ca c đ nh v i,vi+1 là liền kề vi nhau . Đƣờng đi c đỉnh đầu trùng vi đỉnh cuối đƣợc gọi là chu trnh(cycle).

Giƣ a hai đ nh cu a đô thi co thê c các đƣờng đi trực tip nu chúng liền kề vi nhau ,hoă c nêu co

mô t đƣơ

ng đi giƣ

a chu ng (gián tip ) th hai đỉnh đ đƣợc gọi là liên thông

(connected) vơ i nhau. Mô t đô thi đƣơ c go i la liên thông nêu nhƣ hai đ nh bất ky ca n đều

http://en.wikipedia.org/wiki/Image:6n-graf.svg



29

liên thông vơ i nhau. Nêu đô thi không liên thông th luôn co thê chia no tha nh ca c tha nh phânliên thông nho hơn.

3.1.2. Cây (tree)

C nhiều cách đnh ngha cây khác nhau nhƣng ở đây chúng ta sẽ đnh ngha khái niệ mcây theo ly thuyêt đô thi (graph theory).

Cây la mô t đô thi vô hƣơ ng , không co tro ng số , liên thông va không co chu tr nh . V dhnh vẽ sau là một cây:

Hnh 5.2. Cây, tham kha o tƣ wikipedia Câu tru c cây la mô t câu tru c đƣ ợc sư dng rất rộng rãi trong cuộc sống hàng ngày và

trên ma y t nh , chă ng ha n cấu tru c tô chƣ c cu a mô t công ty la mô t cây phân cấp , câu tru c cu amô t web site cu ng tƣơng tƣ :

Hnh 5.3. Câu tru c web site wikipedia, tham kha o tƣ wikipedia.Câu tru c tô chƣ c thƣ mu c cu a hê điêu ha nh la mô t cây … Trong cây luôn co mô t nu t đă c biê t go i la gốc cu a cây (root), các đỉnh trong cây đƣợc

gọi là các nút (nodes). Tƣ gốc cu a cây đi xuống tất ca ca c đ nh liên kê vơ i no , các đỉnh nàygọi là con ca gốc , đn lƣợt các con ca gốc lại c các nút con (child nodes) khác, nhƣ vâ yquan hê giƣ a hai nu t liền kề nhau trong cây la quan hê cha con , mô t nu t la cha (parent), mô t

nút là con (child), nút cha ca cha ca một nút đƣợc gọi là tổ tiên (ancestor) ca nút đ.Các nút trong cây đƣợc phân biệt làm nhiều loại : các nút c t nhất 1 nút con đƣợc gọi làcác nút trong (internal nodes hay inner nodes), các nu t không co nu t con đƣơ c go i la ca c nu t la (leaf nodes). Các nút lá không c các nút con nhƣng để thuận tiện trong quá trnh cài đtngƣơ i ta vâ n coi ca c nu t la co hai nu t con gia , rô ng (NULL) đo ng vai tro l nh canh , gọi la ca cnút ngoài (external nodes).

Các nút trong cây đƣợc phân chia thành các tầng (level), nút gốc thuộc tầng 0 (level 0),sau đo ca c tầng tiêp theo se đƣơ c tăng lên 1 đơn vi so vơ i tầng ph a trên no cho đên tầng cuốicùng. Độ cao (height) ca cây đƣợc tnh bng số tầng ca cây , đô cao cu a cây se quyêt đi nhđô phƣ c ta p (số thao ta c) khi thƣ c hiê n ca c thao ta c trên cây.

Mô i nu t trong cu a cây tô ng qua t co thê co nhiều nu t con , tuy nhiên ca c ngh iên cƣ u cu a

ngành khoa học máy tnh đã cho thấy cấu trúc cây quan trọng nhất cần nghiên cứu chnh làcác cây nh phân (binary tree), là các cây là mỗi nút chỉ c nhiều nhất hai nút con . Mô t câytô ng qua t luôn co thê phân chia tha nh ca c cây nhi phân.

http://en.wikipedia.org/wiki/Image:Binary_tree_structure.svg

http://en.wikipedia.org/wiki/Image:Tree_graph.svg



30

Các nút con ca một nút trong cây nh phân đƣợc gọi là nút con trái (left child) và nútcon pha i (right child).

Trong chƣơng na y chu ng ta se nghiên cƣ u mô t sô loa i cây nhi phân cơ ba n va đƣơ c ƣ ngdng rô ng ra i nhất , đo la cây t m kiêm nhi phân BST (Binary Search Tree), cây biê u thƣ c(expression tree hay syntax tree) và cây cân bng (balanced tree) AVL.

Hoặc một cách định nghĩa khác (đọc thêm)

Cây là một tập hợp các phần tư gọi là nút (nodes) trong đ c một nút đƣợc phân biệtgọi là nút gốc (root). Trên tập hợp các nút này c một quan hệ, gọi là mối quan hệ cha - con (parenthood), để xác dnh hệ thống cấu trúc trên các nút. Mỗi nút, trừ nút gốc, c duy nhấtmột nút cha. Một nút c thể c nhiều nút con hoc không c nút con nào. Mỗi nút biểu diễnmột phần tư trong tập hợp dang xét và n c thể c một kiểu nào đ bất kỳ, thƣờng ta biểudiễn nút bng một k tự, một chƣỗi hoc một số ghi trong vng trn. Mối quan hệ cha con

đƣợc biểu diễn theo qui ƣc nút cha ở dòng trên nút con ở dòng dưới và đƣợ c nối bởi một doạn thẳng . Một cách hnh thức ta c thể dnh ngha cây một cách đệ qui nhƣ sau:

Ðịnh nghĩa - Một nút đơn dộc là một cây. Nút này cũng chnh là nút gốc ca cây.- Giả sư ta c n là một nút đơn độc và k cây T1,.., Tk vi các nút gốc tƣơng ứng là n1,..,

nk th c thể xây dựng một cây mi bng cách cho nút n là cha ca các nút n1,.., nk. Cây minày c nút gốc là nút n và các cây T1,.., Tk đƣợc gọi là các cây con. Tập rỗng cũng đƣợc coilà một cây và gọi là cây rỗng k hiệu .

Ví dụ: Xét mc lc ca một quyển sách. Mc lc này c thể xem là một cây. Xétcấu trúc thƣ mc trongtin học, cấu trúc nàycũng đƣợc xem nhƣmột cây.

Hình III.1 - Cây mc lc một quyển sách Nu n1,.., nk là một chƣỗi các nút trên cây sao cho n i là nút cha ca nút ni+1, vi i=1..k -

1, th chƣỗi này gọi là một d ƣờ ng di trên cây (hay ngắn gọn là dƣờng di ) từ n1 đn nk. Ðộ dài

d ƣờ ng di đƣợc dnh ngha bng số nút trên dƣờng di trừ 1. Nhƣ vậy dộ dài dƣờng di từ một nút đn chnh n bng không.

Nu c dƣờng di từ nút a đn nút b th ta ni a là tiền bối (ancestor) ca b, cn b gọi làhậu duệ (descendant) ca nút a. Rõ ràng một nút vừa là tiền bối vừa là hậu duệ của chính nó.Tiền bối hoc hậu duệ ca một nút khác vi chnh n gọi là tiền bối hoc hậu duệ thực sự.Trên cây nút gốc không c tiền bối thực sự. Một nút không c hậu duệ thực sự gọi là nút lá

(leaf). Nút không phải là lá ta cn gọi là nút trung gian (interior). Cây con ca một cây là mộtnút cùng vi tất cả các hậu duệ ca n.

Chiều cao của một nút là dộ dài dƣờng di ln nhất từ nút đ ti lá. Chiều cao của câylà chiều cao ca nút gốc. Ðộ sâu của một nút là dộ dài dƣờng di từ nút gốc đn nút đ. Các

nút c cùng một dộ sâu i ta gọi là các nút c cùng một mức i. Theo dnh ngha này th nút gốcở mức 0, các nút con ca nút gốc ở mức 1. Ví dụ: đối vi cây trong hnh III.1 ta c nút C2 c chiều cao 2. Cây c chiều cao 3. nút

Sách

C1 C2C3

1.1 1.2 2.2

2.1.1 2.1.2

2.13.2



31

C3 c chiều cao 0. Nút 2.1 c dộ sâu 2. Các nút C1,C2,C3 cùng mức 1. Thứ tự các nút trong cây

Nu ta phân biệt thứ tự các nút con ca cùng một nút th cây gọi là cây c thứ tự, thứtự qui ƣc từ trái sang phải. Nhƣ vậy, nu kể thứ tự th hai cây sau là hai cây khác nhau:

Hình III.2: Hai cây c thứ tự khác nhau Trong trƣờng hợp ta không phân biệt rõ ràng thứ tự các nút th ta gọi là cây không c

thứ tự. Các nút con cùng một nút cha gọi là các nút anh em ruột (siblings). Quan hệ "trái sang phải" ca các anh em ruột c thể mở rộng cho hai nút bất kỳ theo qui tắc: nu a, b là hai anhem ruột và a bên trái b th các hậu duệ ca a là "bên trái" mọi hậu duệ ca b.

3.3. Cây t m kiê m nhi phân (Binary Search Tree - BST)

3.3.1. Đi nh ngh a Mô i nu t trong cây bất ky đêu chƣ a ca c trƣơ ng thông tin , trên mô t cây t m kiêm nh phân

mô i nu t la mô t struct ( bản ghi – record) gôm ca c trƣơ ng: trƣơ ng dƣ liê u data, trƣơ ng kho a keyđể so sánh vi các nút khác, các liên kt ti các nút con ca nút left và right .

Đê tâ p trung va o ca c vấn đề thuâ t toa n ta bo qua trƣơ ng dƣ liê u , chỉ xem nhƣ mỗi núttrên cây t m kiêm nhi phân gôm co mô t trƣơ ng kho a key và hai trƣờng liên kt left và right.

Vơ i ca c gia thiêt trên ta đi nh ngh a cây t m kiêm nhi phân nhƣ sau:Cây t m kiêm nhi phân la mô t cây nhi phân (binary tree) mà mỗi nút x trong cây tha

mãn bất đẳng thức kép sau:( _ ( )) ( ) ( _ ( ))key left child x key x key right child x

Trong đo left_child(x), right_child(x) là các nút con trái và phải ca nút x , key() là hàmtrả về giá tr kha ở nút tƣơng ứng.V d:

Hnh 5.4. Cây t m kiêm nhi phân BST, tham kha o tƣ wikipedia. Nhận xét: - Trên cây BST không có hai nút cùng khoá.- Cây con ca một cây BST là cây BST.

Ƣu điê m ch nh cu a cây t m kiêm nhi phân la : n cung câp thuâ t toa n săp xêp va t m

kiêm dƣ a trên kiê u duyê t thƣ tƣ giƣ a (in-order) mô t ca ch rât hiê u qua , và là cấu trúc dữ liệu cơ bản cho các cấu trúc dữ liệu cao cấp hơn (trƣ u tƣơ ng hơn) nhƣ tâ p hơ p (set), các mảng liên kêt

B C

AC B

A



32

(associative array), các ánh xạ map, và các cây cân bng tối ƣu nhƣ AVL , cây đo đen . Chúngta se xem xe t ta i sao cây t m kiêm nhi phân la i hiê u qua nhƣ vâ y.

3.3.2. Khơ i ta o cây rô ng

Thao ta c đâu tiên la khai ba o câu tru c cây va khơ i ta o mô t cây rô ng đê băt đầu thƣ c hiê ncác thao tác khác.

Ở đây ta giả sư cây tm kim nh phân chỉ chứa các kha là các số nguyên dƣơng .Khai ba o cây t m kiêm nhi phân trong ngôn ngƣ C nhƣ sau: // khai bao cau truc cay tim kiem nhi phantypedef struct tree{

int key;struct tree *left,*right;

}BSTree;Đê khơ i ta o mô t cây rô ng ta khai ba o gốc cu a cây va ga n cho gốc đo băng NULL :

// cayBSTree **root;

*root = NULL;3.3.3. Chn thêm một nút mi vào cây

Đê che n mô t nu t mơ i va o cây ta xuất pha t tƣ gốc cu a cây , ta go i đo la nu t đang xe t . Nêunhƣ nu t đang xe t co kho a băng vơ i kho a cần che n va o cây th xa y ra hiê n tƣơ ng tru ng kho a ,thuâ t toa n kêt thu c vơ i thông báo trùng kha. Nêu nhƣ nu t đang xe t la mô t nu t ngoa i (externalnodes) th ta tạo một nút mi và gán các trƣờng thông tin tƣơng ứng cho nút đ , gán các conca nút đ bng NULL.

// them mot nut moi vao cay, gia tri khoa cua nut moi luu trong bien toan cuc newkeyvoid insert(BSTree **root){

if(*root==NULL){

*root=calloc(1,sizeof(BSTree));(*root)->key = newkey;(*root)->left=NULL;(*root)->right=NULL;

}else{if((*root)->key>newkey)

insert(&((*root)->left));else

if((*root)->key<newkey)insert(&((*root)->right));else

printf("\nError: Duplicate key");}

}Thuâ t toa n trên sƣ du ng bô nhơ (log n) trong trƣơ ng hơ p trung b nh va

(n) trongtrƣơ ng hơ p tôi nhât . Độ phức tạp thuật toán bng vi độ cao ca cây , tƣ c la O (log n) trongtrƣơ ng hơ p trung b nh đối vơ i hâu hêt ca c cây, nhƣng se la

(n) trong trƣơ ng hơ p xấu nhất.Cũng nên chú ý là các nút mi luôn đƣợc chn vào các nút ngoài ca cây tm kim nh

phân, gốc cu a cây không thay đô i trong qua tr nh che n thêm nu t va o cây .



33

3.3.4. Xóa b khi cây một nút

Khi xo a bo mô t nu t X kho i cây (dƣ a trên gia tr kha), chúng ta chia ra một số trƣờnghơ p sau:

X la mô t nu t la : khi đo viê c xo a nu t không la m a nh hƣơ ng tơ i ca c nu t kha c , ta ch viê c

xa b nút đ khi cây.

X ch co mô t nu t con (trái hoc phải ): khi đo ta đƣa nu t con duy nhất cu a X lên thay

cho nu t X va xo a bo X.

Cn nu X là một nút trong và c hai con , ta se co hai lƣ a cho n, mô t la t m nu t hâ u duê

nh nhất bên nhánh phải ca X (gọi là Y), thay kho a cu a Y lên X va xo a bo Y . Cách thƣ hai la

tm nút hậu duệ ln nhất bên nhánh trái ca X (gọi là Z), thay kho a cu a Z lên X va xo a bo Z .

Các thao tác vi Y hoc Z đƣợc lp lại tƣơng tự nhƣ đối vi X .

Hnh minh họa:

Hnh 5.5. Xa nút trên cây BST, tham kha o tƣ wikipedia Do ca c nu t thƣ c sƣ bi xo a trong trƣơ ng hơ p thƣ ba se co thê rơi va o trƣơ ng hơ p 1 hoă c 2

(là các nút lá hoc các nút chỉ c 1 con), đông thơ i nu t bi xo a se co kho a nho hơn hai con cu aX nên trong ca i đă t ta nên tra nh ch sƣ du ng mô t phƣơng pha p , v c thể dẫn ti tnh huốngmât t nh cân băng cu a cây.

Viê c ca i đă t thuâ t toa n xo a mô t nu t trên cây t m kiêm nhi phân không đơn gia n nhƣ viê cmô ta thuâ t toa n xo a ơ trên . Trƣơ c hêt ta se xuât pha t tƣ gốc cu a cây đê đi t m nu t chƣ a kho acân xo a trên cây . Trong qua tr nh na y điều quan tro ng la ta xa c đi nh ro nu t cân xo a ( biên ptrong đoa n ma chƣơng tr nh bên dƣơ i ) là một nút lá, hay la mô t nút chỉ c một con , hay la nu tc đầy đ cả hai con . Dù trong trƣờng hợp nào th chúng ta cũng cần xác đnh nút cha ca nútp (nút q), và p là con trái hay con phải ca q . Đê xa c đi nh ca c trƣơ ng hơ p trên ta sƣ du ng mô t

biên cơ f , f băng 0 tƣơng ƣ ng vơ i viê c nu t cần xo a la gốc cu a cây , f băng 1 tƣơng ƣ ng vơ i p la con pha i cu a q, và f bng 2 tƣơng ƣ ng vơ i p la con tra i cu a q.

Cài đt bng C ca thao tác xa một nút khi cây BST : // xoa bo mot khoa khoi cayvoid del(BSTree ** root, int key){

BSTree *p, *q, *r;int f=0;p = *root;q = NULL;while(p!=NULL&&p->key!=key){

q = p;if(p->key<key){

http://en.wikipedia.org/wiki/Image:Binary_search_tree_delete.svg



34

f = 1;p = p->right;

}else{

f = 2;

p = p->left;}}if(p!=NULL){

if(p->right==NULL){

if(f==1){

q->right=p->left;free(p);

}else if(f==2){

q->left=p->left;free(p);

}else{

*root = p->left;free(p);

}}else{

q = p->right;r = NULL;while(q->left){

r = q;q = q->left;

}p->key = q->key;if(r==NULL)

p->right = q->right;else

r->left = q->right;free(q);

}}

}Mă c du viê c xo a cây không pha i luôn đo i ho i pha i duyê t tƣ gốc xuống thƣ c hiê n ơ mô t

nút lá nhƣng tnh huống này luôn c thể xảy ra (duyê t qua tƣ ng nu t tơ i mô t nu t la ), khi đo đô phƣ c ta p cu a thuâ t toa n xo a cây tƣơng đƣơng vơ i đô cao cu a cây (tnh huống ti nhất).

3.3.5. Tìm kiếm trên cây

Viê c t m kiêm trên cây nhi phân t m kiêm giống nhƣ khi ta thêm mô t nu t mơ i va o cây .Dƣ a trên kho a t m kiêm key ta xuất pha t tƣ gốc , gọi nút đang xét là X . Nêu kho a cu a X băng



35

vơ i key, th kt thúc và trả về X . Nêu X la mô t nu t lá th kt quả trả về NULL (cũng chnh làX). Nêu kho a cu a X nho hơn key th ta lă p la i thao ta c t m kiêm vơ i nu t con pha i cu a X ,ngƣơ c la i th tiên ha nh t m kiêm vơ i nu t con tra i cu a X.

Độ phức tạp ca thuật toán nà y băng vơ i đô phƣ c ta p cu a thuâ t toa n che n mô t nu t mơ ivào cây.

Cài đt ca thuật toán đƣợc để lại nhƣ một bài tập dành cho các bạn độc giả .

3.3.6. Duyê t cây

Duyê t cây (tree travel) là thao tác duyệt qua (đn thăm) tất cả các nút trên cây.C nhiều cách để duyệt một cây , chă ng ha n nhƣ duyê t theo chiều sâu (DFS), duyê t theo

chiêu rô ng (BFS), nhƣng ơ đây ta phân chia ca c ca ch duyê t mô t cây BST dƣ a trên thƣ tƣ đênthăm nu t gốc, nút con trái, và nút con phải ca gốc.

C thể c ba cách duyệt một cây BST : duyê t thƣ tƣ trƣơ c, thƣ tƣ giƣ a, thƣ tƣ sau.Đê minh ho a kêt qua cu a ca c ca ch duyê t cây ta xe t cây v du sau :

Hnh 5.6. Cây t m kiêm nhi phân, tham kha o tƣ wikipediaDuyê t thƣ tƣ trƣơ c (pre-order traversal):

Thăm gốc (visit root).

Duyê t cây con tra i theo thƣ tƣ trƣơ c

Duyê t cây con pha i theo thƣ tƣ trƣơ c .

C thể thuật toán đƣợc cài đt nhƣ sau: // duyet theo thu tu truocvoid pre_order(BSTree *node){

if(node!=NULL){

visit(node); // ham tham mot nut, don gian la in gia tri khoapre_order(node->left);pre_order(node->right);

}}Kêt qua duyê t cây theo thƣ tƣ trƣơ c: 8, 3, 1, 6, 4, 7, 10, 14, 13.Trong ca ch duyê t theo thƣ tự trƣc, gốc cu a cây luôn đƣơ c thăm đầu tiên.Duyê t thƣ tƣ giƣ a (in-order traversal):

Duyê t cây con tra i theo thƣ tƣ giƣ a Thăm gốc



36

Duyê t cây con pha i theo thƣ tƣ giƣ a .

Kêt qua duyê t cây theo thƣ tƣ trƣơ c: 1, 3, 4, 6, 7, 8, 10, 13, 14.Mô t điều dê nhâ n thấy la ca c kho a cu a cây khi duyê t theo thƣ tƣ giƣ a xuât hiê n theo thƣ

tƣ tăng dần.Duyê t thƣ tƣ sau (post-order traversal):

Duyê t cây con tra i theo thƣ tƣ sau Duyê t cây con pha i theo thƣ tƣ sau

Thăm gốc

Kêt qua duyê t cây theo thƣ tƣ sau: 1, 4, 7, 6, 3, 13, 14, 10, 8.Trong ca ch duyê t na y, gốc đƣơ c thăm sau cu ng. Nhận xét: - Khi duyệt trung tự (InOrder) cây BST ta đƣợc một dãy c thứ tự tăng.

Cài đt bng C ca hai cách duyệt sau đƣợc dành cho các bạn độc giả nhƣ một bài tập .

3.3.7. Cài đặt cây BST

Cây TKNP, trƣc ht, là một cây nh phân. Do đ, ta c thể áp dng các cách cài đtnhƣ đã trnh bày trong phần cây nh phân. Sẽ không c sự khác biệt nào trong việc cài đt cấutrúc dữ liệu cho cây TKNP so vi cây nh phân, nhƣng tất nhiên, sẽ c sự khác biệt trong cácgiải thuật thao tác trên cây TKNP nhƣ tm kim, thêm hoc xoá một nút trên cây TKNP đểluôn đảm bảo tnh chất cuả cây TKNP.

Một cách cài đt cây TKNP thƣờng gp là cài đt bng con tr. Mỗi nút ca cây nhƣ làmột mẩu tin (record) c ba trƣờng: một trƣờng chứa khoá, hai trƣờng kia là hai con tr trđn hai nút con (nu nút con vắng mt ta gán con tr bng NIL)

Khai báo nhƣ sau typedef <kiểu dữ liệu ca khoá> KeyType;typedef struct Node

{KeyType Key;Node* Left,Right;}typedef Node* Tree;Khởi tạo cây TKNP rỗng Ta cho con tr quản lý nút gốc (Root) ca cây bng NULL. void MakeNullTree(Tree *Root){(*Root)=NULL;}Tìm kiếm một nút có khóa cho trƣc trên cây TKNP Ðể tm kim 1 nút c khoá x trên cây TKNP, ta tin hành từ nút gốc bng cách so sánh

khoá ca nút gốc vi khoá x. - Nu nút gốc bng NULL th không c khoá x trên cây.- Nu x bng khoá ca nút gốc th giải thuật dừng và ta đã tm đƣợc nút chứa khoá x.- Nu x ln hơn khoá ca nút gốc th ta tin hành (một cách đệ qui) việc tm khoá x

trên cây con bên phải.- Nu x nh hơn khoá ca nút gốc th ta tin hành (một cách đệ qui) việc tm khoá x

trên cây con bên trái.Ví dụ: tìm nút có khoá 30 trong cây ở trong hình III.15

- So sánh 30 vi khoá nút gốc là 20, v 30 > 20 vậy ta tm tip trên cây con bên phải,tức là cây c nút gốc c khoá là 35.- So sánh 30 vi khoá ca nút gốc là 35, v 30 < 35 vậy ta tm tip trên cây con bên



37

trái, tức là cây c nút gốc c khoá là 22.- So sánh 30 vi khoá ca nút gốc là 22, v 30 > 22 vậy ta tm tip trên cây con bên

phải, tức là cây c nút gốc c khoá là 30.- So sánh 30 vi khoá nút gốc là 30, 30 = 30 vậy đn đây giải thuật dừng và ta tm

đƣợc nút chứa khoá cần tm.- Hàm dƣi đây trả về kt quả là con tr tr ti nút chứa khoá x hoc NULL nu

không tm thấy khoá x trên cây TKNP. Tree Search(KeyType x,Tree Root){if (Root == NULL) return NULL; //không tm thấy khoá x else if (Root->Key == x) /* tm thấy khoá x */ return Root;else if (Root->Key < x) //tm tip trên cây bên phải return Search(x,Root->right);else//tm tip trên cây bên trái return Search(x,Root->left);

}Câu hi ôn tập: Cây tm kim nh phân đƣợc tổ chức nhƣ th nào để quá trnh tm kim đƣợ c

hiệu quả nhất? Nhận xét: giải thuật này sẽ rất hiệu quả về mặt thời gian nếu cây TKNP đƣợ c tổ chức

tốt, nghĩa là cây t ƣơ ng đối "cân bằng". Về chủ dề cây cân bằng các bạn có thể tham khảothêm trong các tài liệu tham khảo của môn này.

Thêm một nút có khóa cho trƣc vào cây TKNP Theo dnh ngha cây tm kim nh phân ta thấy trên cây tm kim nh phân không c

hai nút c cùng một khoá. Do đ, nu ta muốn thêm một nút c khoá x vào cây TKNP thìtrƣc ht ta phải tm kim để xác dnh c nút nào chứa khoá x chƣa. Nu c th giải thuật ktthúc (không làm g cả!). Ngƣợc lại, sẽ thêm một nút mi chứa khoá x này. Việc thêm mộtkhoá vào cây TKNP là việc tm kim và thêm một nút, tất nhiên, phải đảm bảo cấutrúc cây TKNP không b phá vỡ. Giải thuật c thể nhƣ sau:

Ta tin hành từ nút gốc bng cách so sánh kha cuả nút gốc vi khoá x. - Nu nút gốc bng NULL th khoá x chƣa c trên cây, do đ ta thêm một nút mi

chứa khoá x.- Nu x bng khoá ca nút gốc th giải thuật dừng, trƣờng hợp này ta không thêm nút.- Nu x ln hơn khoá ca nút gốc th ta tin hành (một cách đệ qui) giải thuật này trên

cây con bên phải.- Nu x nh hơn khoá ca nút gốc th ta tin hành (một cách đệ qui) giải thuật này trên

cây con bên trái.Ví dụ: thêm khoá 19 vào cây ở trong hình III.15So sánh 19 vi khoá ca nút gốc là 20, v 19 < 20 vậy ta xét tip đn cây bên trái, tức

là cây c nút gốc c khoá là 10. - So sánh 19 vi khoá ca nút gốc là 10, v 19 > 10 vậy ta xét tip đn cây bên phải,

tức là cây c nút gốc c khoá là 17.- So sánh 19 vi khoá ca nút gốc là 17, v 19 > 17 vậy ta xét tip đn cây bên phải.

Nút con bên phải bng NULL, chứng t rng khoá 19 chƣa c trên cây, ta thêm nút mi chứakhoá 19 và nút mi này là con bên phải ca nút c khoá là 17, xem hnh III.16

Hình III.16: Thêm khoá 19 vào cây hình III.15

Th tc sau dây tin hành việc thêm một khoá vào cây TKNP.void InsertNode(KeyType x,Tree *Root ){if (*Root == NULL){ /* thêm nút mi chứa khoá x */



38

(*Root)=(Node*)malloc(sizeof(Node));(*Root)->Key = x;(*Root)->left = NULL;(*Root)->right = NULL;}else

if (x < (*Root)->Key)InsertNode(x,Root->left);else if (x>(*Root)->Key) InsertNode(x,Root->right);}Xóa một nút có khóa cho trƣc ra khi cây TKNP Giả sư ta muốn xoá một nút c khoá x, trƣc ht ta phải tm kim nút chứa khoá x trên

cây.Việc xoá một nút nhƣ vậy, tất nhiên, ta phải bảo đảm cấu trúc cây TKNP không b phá

vỡ. Ta c các trƣờng hợp nhƣ hnh III.17: Hnh III.17 V d về giải thuật xa nút trên cây - Nu không tm thấy nút chứa khoá x th giải thuật kt thúc.

- Nu tm gp nút N c chứa khoá x, ta c ba trƣờng hợp sau (xem hnh III.17)- Nu N là lá ta thay n bởi NULL.- N chỉ c một nút con ta thay n bởi nút con ca n.- N có hai nút con ta thay n bởi nút ln nhất trên cây con trái ca n (nút cực phải ca

cây con trái) hoc là nút bé nhất trên cây con phải ca n (nút cực trái ca cây con phải).Trong giải thuật sau, ta thay x bởi khoá ca nút cực trái ca cây con bên phải ri ta xoá nútcực trái này. Việc xoá nút cực trái ca cây con bên phải sẽ roi vào một trong hai trƣờng hợptrên.

Giải thuật xoá một nút có khoá nh nhất Hàm dƣi dây trả về khoá ca nút cực trái, dng thời xoá nút này. KeyType DeleteMin (Tree *Root ){KeyType k;if ((*Root)->left == NULL){k=(*Root)->key;(*Root) = (*Root)->right;return k;}else return DeleteMin(Root->left);}Thủ tục xóa một nút có khoá cho trƣc trên cây TKNP void DeleteNode(key X, Tree *Root){if ((*Root)!=NULL)if (x < (*Root)->Key)

DeleteNode(x,Root->left)else if (x > (*Root)->Key)

DeleteNode(x,Root->right) elseif ((*Root)->left==NULL)&&((*Root)->right==NULL)

(*Root)=NULL;elseif ((*Root)->left == NULL)

(*Root) = (*Root)->right ;else if ((*Root)->right==NULL)(*Root) = (*Root)->left;



39

else (*Root)->Key = DeleteMin(Root->right);}

3.4.Cây cân bng – AVL

Trong khoa học máy tnh, một cây AVL là một cây tm kim nh phân tự cân bng, và là cấutrúc dữ liệu đầu tiên c khả năng này. Trong một cây AVL, tại mỗi nút chiều cao ca hai câycon sai khác nhau không quá một. Hiệu quả là các phép chn (insertion), và xa (deletion)luôn chỉ tốn thời gian O(log n) trong cả trƣờng hợp trung bnh và trƣờng hợp xấu nhất. Phép

bổ sung và loại b c thể cần đn việc tái cân bng bng một hoc nhiều phép quay.

3.4.1. Cây nhị phân cân bng hoàn toàn

a. Định nghĩa

Cây cân bng hoàn toàn là cây nh phân tm kim mà tại mỗi nút ca n, số nút ca cây contrái chênh lệch không quá một so vi số nút ca cây con phải.

b. Đánh giá

Một cây rất kh đạt đƣợc trạng thái cân bng hoàn toàn và cũng rất dễ mất cân bng v khithêm hay hy các nút trên cây c thể làm cây mất cân bng (xác suất rất ln), chi ph cân bnglại cây ln v phải thao tác trên toàn bộ cây.

Tuy nhiên nu cây cân đối th việc tm kim sẽ nhanh. Đối vi cây cân bng hoàn toàn, trongtrƣờng hợp xấu nhất ta chỉ phải tm qua log2n phần tư (n là số nút trên cây).

Sau đây là v d một cây cân bng hoàn toàn (CCBHT):

2n. Đây chnh là lý do cho phép bảo đảm khả năng tmkim nhanh trên CTDL này.

Do CCBHT là một cấu trúc kém ổn đnh nên trong thực t không thể sư dng. Nhƣng ƣu điểmca n lại rất quan trọng. V vậy, cần đƣa ra một CTDL khác c đc tnh giống CCBHTnhƣng ổn đnh hơn.

Nhƣ vậy, cần tm cách tổ chức một cây đạt trạng thái cân bng yu hơn và việc cân bng lạichỉ xảy ra ở phạm vi cc bộ nhƣng vẫn phải bảo đảm chi ph cho thao tác tm kim đạt ở mứcO(log2n).

3.4.2. CÂY NHỊ PHÂN CÂN BẰNG (AVL)

http://vi.wikipedia.org/wiki/Khoa_h%E1%BB%8Dc_m%C3%A1y_t%C3%ADnh



http://vi.wikipedia.org/wiki/C%C3%A2y_t%C3%ACm_ki%E1%BA%BFm_nh%E1%BB%8B_ph%C3%A2n



http://vi.wikipedia.org/w/index.php?title=Chi%E1%BB%81u_cao_c%E1%BB%A7a_c%C3%A2y&action=edit&redlink=1



http://vi.wikipedia.org/w/index.php?title=K%C3%BD_hi%E1%BB%87u_O_l%E1%BB%9Bn&action=edit&redlink=1



http://vi.wikipedia.org/wiki/Ph%C3%A9p_quay_c%C3%A2y_nh%E1%BB%8B_ph%C3%A2n










40

a. Định nghĩa:

Cây nh phân tm kim cân bng là cây mà tại mỗi nút ca n độ cao ca cây con trái và cacây con phải chênh lệch không quá một.

Dƣi đây là v d cây cân bng (lƣu ý, cây này không phải là cây cân bng hoàn toàn):

Dễ dàng thấy CCBHT là cây cân bng. Điều ngƣợc lại không đúng.

b. Lịch sư cây cân bng (AVL Tree)

AVL là tên vit tắt ca các tác giả ngƣời Nga đã đƣa ra đnh ngha ca cây cân bng Adelson -Velskii và Landis (1962). V lý do này, ngƣời ta gọi cây nh phân cân băng là cây AVL. Tùnay về sau, chúng ta sẽ dùng thuật ngữ cây AVL thay cho cây cân bng.

Từ khi đƣợc gii thiệu, cây AVL đã nhanh chng tm thấy ứng dng trong nhiều bài toán

khác nhau. V vậy, n mau chng trở nên thnh hành và thu hút nhiều nghiên cứu. Từ câyAVL, ngƣời ta đã phát triển thêm nhiều loại CTDL hữu dng khác nhƣ cây đ -đen (Red-Black Tree), B-Tree, …

c. Chiều cao của cây AVL

Một vấn đề quan trọng, nhƣ đã đề cập đn ở phần trƣc, là ta pjải khẳng đnh cây AVL n nút phải c chiều cao khoảng log2(n).

Để đánh giá chnh xác về chiều cao ca cây AVL, ta xét bài toán: cây AVL c chiều cao h sẽ phải c tối thiểu bao nhiêu nút ?

Gọi N(h) là số nút tối thiểu ca cây AVL c chiều cao h.

http://vi.wikipedia.org/wiki/H%C3%ACnh:TreeBSTAndAVL.jpg



41

Ta có N(0) = 0, N(1) = 1 và N(2) = 2.

Cây AVL tối thiểu c chiều cao h sẽ c 1 cây con AVL tối thiểu chiều cao h -1 và 1 cây conAVL tối thiểu chiều cao h-2. Nhƣ vậy:

N(h) = 1 + N(h-1) + N(h-2) (1)

Ta lại c: N(h-1) > N(h-2)

Nên từ (1) suy ra:

N(h) > 2N(h-2)

N(h) > 22N(h-4)

…

N(h) > 2iN(h-2i)

h/2-1

2(N(h)) + 2

Nhƣ vậy, cây AVL c chiều cao O(log2(n)).

V d: cây AVL tối thiểu c chiều cao h=4

d. Cấu trúc dữ liệu cho cây AVL

Chỉ số cân bng của một nút:

Định nghĩa: Chỉ số cân bng ca một nút là hiệu ca chiều cao cây con phải và cây con tráica n.

Đối vi một cây cân bng, chỉ số cân bng (CSCB) ca mỗi nút chỉ c thể mang một trong ba

giá tr sau đây: CSCB(p) = 0 <=> Độ cao cây trái (p) = Độ cao cây phải (p)



42

CSCB(p) = 1 <=> Độ cao cây trái (p) < Độ cao cây phải (p)

CSCB(p) =-1 <=> Độ cao cây trái (p) > Độ cao cây phải (p)

Để tiện trong trnh bày, chúng ta sẽ ký hiệu nhƣ sau:

p->balFactor = CSCB(p);

Độ cao cây trái (p) ký hiệu là hL

Độ cao cây phải(p) ký hiệu là hR

Để khảo sát cây cân bng, ta cần lƣu thêm thông tin về chỉ số cân bng tại mỗi nút. Lúc đ,cây cân bng c thể đƣợc khai báo nhƣ sau:

typedef struct tagAVLNode {

char balFactor; //Chỉ số cân bằng

Data key;

struct tagAVLNode* pLeft;

struct tagAVLNode* pRight;

}AVLNode;

typedef AVLNode *AVLTree;

Để tiện cho việc trnh bày, ta đnh ngha một số hăng số sau:

#define LH -1 //Cây con trái cao hơn

#define EH -0 //Hai cây con bng nhau

#define RH 1 //Cây con phải cao hơn

e. Đánh giá cây AVL

Cây cân bng là CTDL ổn đnh hơn hẳn CCBHT v chỉ khi thêm hy làm cây thay đổi chiềucao các trƣờng hợp mất cân bng mi c khả năng xảy ra.

Cây AVL vi chiều cao đƣợc khống ch sẽ cho phép thực thi các thao tác tm thêm hy vichi phí O (log2(n)) và bảo đảm không suy bin thành O(n).

f . Các thao tác cơ bản trên cây AVL

Ta nhận thấy trƣờng hợp thêm hay hy một phần tư trên cây c thể làm cây tăng hay giảmchiều cao, khi đ phải cân bng lại cây. Việc cân bng lại một cây sẽ phải thực hiện sao cho

chỉ ảnh hƣởng tối thiểu đn cây nhm giảm thiểu chi ph cân bng. Nhƣ đã ni ở trên, cây cân



43

bng cho phép việc cân bng lại chỉ xảy ra trong gii hạn cc bộ nên chúng ta c thể thựchiện đƣợc mc tiêu vừa nêu.

Nhƣ vậy, ngoài các thao tác bnh thƣờng nhƣ trên CNPTK, các thao tác đc trƣng ca câyAVL gm:

Thêm một phần tư vào cây AVL.

Hủy một phần tư trên cây AVL.

Cân bng lại một cây vừa bị mất cân bng.

g. CÁC TRƢỜNG HỢP MẤT CÂN BẰNG

Ta sẽ không khảo sát tnh cân bng ca 1 cây nh phân bất kỳ mà chỉ quan tâm đn các khảnăng mất cân bng xảy rakhi thêm hoc hy một nút trên cây AVL.

Nhƣ vậy, khi mất cân bng, độ lệch chiều cao giữa 2 cây con sẽ là 2. Ta c 6 khả năng sau:

Trƣờng hợp 1: cây T lệch về bên trái (có 3 khả năng)

Trƣờng hợp 2: cây T lệch về bên phải

Ta c các khả năng sau:

http://e/Hanh%20Phuc/Tai%20lieu_giao%20trinh/Cau%20truc%20Du%20lieu%20va%20Giai%20thuat/Cau_Truc_Du_Lieu_1/Htm/bai14.htm%23them


http://e/Hanh%20Phuc/Tai%20lieu_giao%20trinh/Cau%20truc%20Du%20lieu%20va%20Giai%20thuat/Cau_Truc_Du_Lieu_1/Htm/bai14.htm%23huy






44

Ta c thể thấy rng các trƣờng hợp lệch về bên phải hoàn toàn đối xứng vi các trƣờng hợplệch về bên trái. V vậy ta chỉ cần khảo sát trƣờng hợp lệch về bên trái. Trong 3 trƣờng hợplệch về bên trái, trƣờng hợp T1 lệch phải là phức tạp nhất. Các trƣờng hợp cn lại giải quytrất đơn giản.

Sau đây, ta sẽ khảo sát và giải quyt từng trƣờng hợp nêu trên.

T/h 1.1: cây T1 lệch về bên trái. Ta thực hiện phép quay đơn Left-Left

T/h 1.2: cây T1 không lệch. Ta thực hiện phép quay đơn Left-Left



45

T/h 1.3: cây T1 lệch về bên phải. Ta thực hiện phép quay kép Left-Right

Do T1 lệch về bên phải ta không thể áp dng phép quay đơn đã áp dng trong 2 trƣờng hợptrên v khi đ cây T sẽ chuyển từ trạng thái mất cân bng do lệch trái thành mất cân bng do

Hnh vẽ dƣi đây minh họa phép quay kép áp dng cho trƣờng hợp này:

Lƣu ý rng, trƣc khi cân bng cây T c chiều cao h+2 trong cả 3 trƣờng hợp 1.1, 1.2 và 1.3.Sau khi cân bng, trong 2 trƣờng hợp 1.1 và 1.3 cây c chiều cao h+1; cn ở trƣờng hợp 1.2cây vẫn c chiều cao h+2. Và trƣờng hợp này cũng là trƣờng hợp duy nhất sau khi cân bng

Thao tác cân bng lại trong tất cả các trƣờng hợp đều cù độ phức tạp O(1).

Vi những xem xét trên, xét tƣơng tự cho trƣờng hợp cây T lệch về bên phải, ta c thể xâydựng 2 hàm quay đơn và 2 hàm quay kép sau:

//quay đơn Left-Left

void rotateLL(AVLTree &T)

{ AVLNode* T1 = T->pLeft;

T->pLeft = T1->pRight;

T1->pRight = T;

switch(T1->balFactor) {

case LH: T->balFactor = EH;



46

T1->balFactor = EH; break;

case EH: T->balFactor = LH;

T1->balFactor = RH; break;

}

T = T1;

}

//quay đơn Right-Right

void rotateRR(AVLTree &T)

{ AVLNode* T1 = T->pRight;

T->pRight = T1->pLeft;

T1->pLeft = T;


case RH: T->balFactor = EH;


case EH: T->balFactor = RH; break;

T1->balFactor = LH; break;

}

T = T1;

}

//quay kép Left-Right

void rotateLR(AVLTree &T)


AVLNode* T2 = T1->pRight;

T->pLeft = T2->pRight;

T2->pRight = T;

T1->pRight = T2->pLeft;



47

T2->pLeft = T1;


case LH: T->balFactor = RH;


case EH: T->balFactor = EH;



T1->balFactor = LH; break;

}

T2->balFactor = EH;

T = T2;

}

//quay kép Right-Left

void rotateRL(AVLTree &T)


AVLNode* T2 = T1->pLeft;

T->pRight = T2->pLeft;

T2->pLeft = T;

T1->pLeft = T2->pRight;

T2->pRight = T1;


case RH: T->balFactor = LH;


case EH: T->balFactor = EH;





48

T1->balFactor = RH; break;

}

T2->balFactor = EH;

T = T2;

}

Để thuận tiện, ta xây dựng 2 hàm cân bng lại khi cây b lệch trái hay lệch phải nhƣ sau:

//Cân băng khi cây b lêch về bên trái

int balanceLeft(AVLTree &T)



case LH: rotateLL(T); return 2;

case EH: rotateLL(T); return 1;

case RH: rotateLR(T); return 2;

}

return 0;

}

//Cân băng khi cây b lêch về bên phải

int balanceRight(AVLTree &T)



case LH: rotateRL(T); return 2;

case EH: rotateRR(T); return 1;

case RH: rotateRR(T); return 2;

}

return 0;

}



49

h. Thêm một phần tư trên cây AVL

Việc thêm một phần tư vào cây AVL diễn ra tƣơng tự nhƣ trên CNPTK. Tuy nhiên, sau khithêm xong, nu chiều cao ca cây thay đổi, từ v tr thêm vào, ta phải lần ngƣợc lên gốc đểkiểm tra xem c nút nào b mất cân bng không. Nu c, ta phải cân bng lại ở nút này.

Việc cân bng lại chỉ cần thực hiện 1 lần tại nơi mất cân bng. ( Tại sao ? Hd: chú ý những khả năng mất cân bằng có thể )

Hàm insert trả về giá tr –1, 0, 1 khi không đ bộ nh, gp nút cũ hay thành công. Nu sau khithêm, chiều cao cây b tăng, giá tr 2 sẽ đƣợc trả về:

int insertNode(AVLTree &T, DataType X)

{ int res;

if(T) {

if(T->key == X) return 0; //đã c

if(T->key > X) {

res = insertNode(T->pLeft, X);

if(res < 2) return res;

switch(T->balFactor) {


return 1;


return 2;

case LH: balanceLeft(T); return 1;

}

}else {

res = insertNode(T-> pRight, X);




return 1;



50

case EH: T->balFactor = RH;

return 2;

case RH: balanceRight(T); return 1;

}

}

}

T = new TNode;

if(T == NULL) return -1; //thiu bộ nh

T->key = X; T->balFactor = EH;

T->pLeft = T->pRight = NULL;

return 2; // thành công, chiều cao tăng

}

i. Hủy một phần tư trên cây AVL

Cũng giống nhƣ thao tác thêm một nút, việc hy một phần tư X ra khi cây AVL thực hiệngiống nhƣ trên CNPTK. Chỉ sau khi hy, nu tnh cân bng ca cây b vi phạm ta sẽ thực hiệnviệc cân bng lại.

Tuy nhiên việc cân bng lại trong thao tác hy sẽ phức tạp hơn nhiều do c thể xảy ra phảnứng dây chuyền. (Tại sao ?)

Hàm delNode trả về giá tr 1, 0 khi hy thành công hoc không c X trong cây. Nu sau khihuỷ, chiều cao cây b giảm, giá tr 2 sẽ đƣợc trả về:

int delNode(AVLTree &T, DataType X)

{ int res;

if(T==NULL) return 0;

if(T->key > X) {

res = delNode (T->pLeft, X);






51

return 2;

case EH: T->balFactor = RH;

return 1;

case RH: return balanceRight(T);

}

}

if(T->key < X) {

res = delNode (T->pRight, X);




return 2;


return 1;

case LH: return balanceLeft(T);

}

}else { // T->key == X

AVLNode* p = T;

if(T->pLeft == NULL) {

T = T->pRight; res = 2;

}else if(T->pRight == NULL) {

T = T->pLeft; res = 2;

}else { // T có cả 2 con

res=searchStandFor(p,T->pRight);





52


return 2;


return 1;

case LH: return balanceLeft(T);

}

}

delete p;

return res;

}

}

//Tm phần tư th mạng

int searchStandFor(AVLTree &p, AVLTree &q)

{ int res;

if(q->pLeft) {

res = searchStandFor(p, q->pLeft);


switch(q->balFactor) {

case LH: q->balFactor = EH;

return 2;

case EH: q->balFactor = RH;

return 1;

case RH: return balanceRight(T);

}

}else {

p->key = q->key;



53

p = q;

q = q->pRight;

return 2;

}

}

k. Nhận xét

Thao tác thêm một nút c độ phức tạp O(1).

Thao tác hy một nút c độ phức tạp O(h).

Vi cây cân bng trung bnh 2 lần thêm vào cây th cần một lần cân bng lại; 5 lần hy th

cần một lần cân bng lại.

Việc huỷ 1 nút c thể phải cân bng dây chuyền các nút từ gốc cho đên phần tư b huỷ trongkhi thêm vào chỉ cần 1 lần cân bng cc bộ.

Độ dài đƣờng tm kim trung bnh trong cây cân bng gần bng cây cân bng hoàn to ànlog2n, nhƣng việc cân bng lại đơn giản hơn nhiều.

Một cây cân bng không bao giờ cao hơn 45% cây cân bng hoàn toàn tƣơng ứng dùsố nút trên cây là bao nhiêu.

Bài tập

1. Vit chƣơng trnh tạo cây BST vi thông tin tại mỗi nút là các số nguyên 2. Vit chƣơng trnh tm kim một nút trong cây BST ở câu 1 3. Vit chƣơng trnh xa một nút trong cây BST ở câu 1 4. Cài đt hoàn thiện các hàm ca cây AVL



54

CHƢƠNG 4. BẢNG BĂM (HASH TABLE)

Phép băm là một thuật toán đƣợc đề xuất và hiện thực trên máy tnh từ những năm 50

ca th kỷ 20. Thuật toán này dựa trên ý tƣởng là chuyển đổi khoá thành một số và sư dng số

này để đánh chỉ số cho bảng dữ liệu.

Nhƣ chúng ta đã bit các phép toán dựa trên các cấu trúc nhƣ cây, danh sách … chyu đƣợc thực hiện thông qua việc so sánh các phần tư c cấu trúc. Do vậy thời gian thực thi

lâu và ph thuộc vào kch thƣc các phần tư này. Để khắc phc ngƣời ta đƣa ra thuật toán sư

dng bảng băm (Hash Table). Các phép toán trên bảng băm c độ phức tạp là O(1) và không

ph thuộc vào kch thƣc bảng. Dƣi đây là một số vấn đề chnh mà chúng ta cần quan tâm

trong bảng băm :

Đnh ngha bảng băm.

Hàm băm và các loại hàm băm. Xung đột và cách xư lý xung đột

4. 1. Định nghĩa bảng băm

4.1.1.Định nghĩa :

Bảng băm là một kiểu dữ liệu trừu tƣợng cho phép lƣu trữ dữ liệu một cách nhanh

chng và hiệu quả. Về thực chất bảng băm là một mảng c chỉ số là bất cứ loại dữ liệu nào.

Trong khi một mảng thông thƣờng yêu cầu chỉ số ca n phải là số nguyên th chỉ số bảng

băm lại c thể là một số thực, một xâu, một mảng khác hay thậm ch là một dạng cấu trúc dữliệu. Các chỉ số này ngƣời ta gọi chung là khoá ( Key ) và nội dung chỉ đnh bởi các chỉ số

này gọi là các giá tr ( Value ).

Vậy bảng băm là một cấu trúc dữ liệu lƣu trữ một cp dữ liệu Key/Value và cho phép

tìm Key một cách nhanh chng.

Bảng băm sư dng một hàm cho phép bin đổi bất kỳ đối tƣợng nào thành chỉ số phù

hợp ca mảng. Hàm này đƣợc gọi là hàm băm (Hash Function)

Bảng băm c thể đƣợc mô tả nhƣ sau: Gọi K là tập các khoá.

M là tập các đa chỉ.

HF(k) là hàm băm dùng để ánh xạ một khoá k từ tập khoá k thành một chỉ số trong tập

đa chỉ M.



55

Hình 2.1 : Mô tả về hàm băm

Sau đây là v d về một bảng băm (Hàm băm trong trƣờng hợp này c dạng : h(k ) = k

mod 8 trong đ k là khoá).

Hình 2.2 : Một bảng băm đơn giản

Trong bảng băm nhiều khoá c giá tr khác

nhau c thể đƣợc băm thành cùng một chỉ số ca mảng. Hiện tƣợng này gọi là xung đột vàgiải quyt xung đột chnh là mc tiêu ca bất cứ bảng băm nào. Vấn đề này chúng ta sẽ đề cập

đn trong phần 3 ca chƣơng này.

4.1.2.Kích thƣc của bảng băm :

Kch thƣc một bảng băm cho bit số mc vào tối đa mà bảng băm c thể lƣu trữ đƣợc.

Thông thƣờng các giá tr ca khoá đƣợc lƣu trữ vừa đ lấp đầy bảng nhƣng đôi khi các giá tr

này lại vƣợt quá gii hạn ca mảng. Giải pháp đƣa ra là buộc các khoảng giá tr này nm

trong gii hạn kch thƣc ca bảng.

Kch thƣc bảng phải đƣợc lƣu trữ một cách ngẫu nhiên v các phƣơng pháp giải quyt

xung đột trong bảng băm c một số điều kiện về kch thƣc bảng nhất đnh để đảm bảo thực

thi chnh xác. Tuy nhiên hầu ht các trƣờng hợp kch thƣc bảng băm thƣờng đƣợc lựa chọn

là luỹ thừa ca 2 ( 2n )hay một số nguyên tố.

Bảng băm c kch thƣc là luỹ thừa ca 2 chỉ là một kỳ vọng ln. Bởi v kch thƣc này

cho phép việc tnh toán đa chỉ đƣợc thực hiện dễ dàng hơn và kt quả c đƣợc nhanh hơn.

Cách để buộc các giá tr nm trong khoảng luỹ thừa ca 2 một cách nhanh chng là sư dng

hàm mt nạ.

Kch thƣc bảng băm thƣờng đƣợc sư dng là một số nguyên tố. L do là v các phép

băm nhn chung là kh hiểu và các phép băm yêu cầu thêm các bƣc chia ca số nguyên tố

đƣợc trộn lẫn vi nhau. Mt khác một số phƣơng pháp xư lý xung đột cũng yêu cầu kiểu kch

thƣc này.

4.1.3. Phân loại :

C rất nhiều loại bảng băm khác nhau. Thông thƣờng bảng băm đƣợc phân loại theo

cấu trúc hoc theo cách xư lý xung đột.

1.3.1.Phân loại theo cấu trúc :



56

Bảng băm phân loại theo cấu trúc gm c :

Bảng băm chữ nhật.

Bảng băm tam giác (tam giác trên và tam giác dƣi ).

Bảng băm đƣờng chéo.

Gọi i, j là các khoá tƣơng ứng vi phần tư hàng i, cột j. Khi đ một phần tư trong bảng băm đƣợc xác đnh bởi cp i, j.

a.Bảng băm chữ nhật :

Một phần tư ca bảng đƣợc xác đnh bởi khoá i ở hàng i và khoá j ở hàng j. Tổng quát

v tr ca phần tư này c thể xác đnh qua công thức :

f(i,j) = n*i + j (n là số cột ca bảng chữ nhật)

Bảng băm hnh chữ nhật đƣợc mô tả bởi một danh sách kề :

0 1 2 … n-1 n n+1 … m*n

b.Bảng băm tam giác :

Bảng băm tam giác trên n cột:

Bảng băm tam giác dƣi m hàng:

Mỗi phần tư trên bảng tam giác tƣơng ứng vi hàng i, cột j (i j) và đa chỉ ca n đƣợc

xác đnh qua hàm băm :

f (i,j) = i*(i + 1)/2 + j

c.Bảng băm đường chéo :

Một số loại bảng băm đƣờng chéo c dạng sau :

1.3.2.Phân loại theo cách xử lý xung đột :



57

Bảng băm phân loại theo cách này gm :

Bảng băm sư dng phƣơng pháp nối kt trực tip

Bảng băm vi phƣơng pháp nối kt hợp nhất

Bảng băm vi phƣơng pháp d tuyn

Bảng băm vi phƣơng pháp d căn bậc 2 Bảng băm vi phƣơng pháp băm kép

4.1.4.Các phép toán trên bảng băm :

Khởi tạo (Initialize ): Khởi tạo bảng băm, cấp phát vùng nh, quy đnh số phần tư ca

bảng ( kch thƣc ca bảng ).

Kiểm tra rỗng ( Empty ): Kiểm tra liệu bảng băm c rỗng hay không.

Lấy kch thƣc bảng băm (Size): Lấy số phần tư hiện thời c trong bảng băm.

Tm kim ( Search ): Tm một phần tư theo một khoá k cho trƣc. Thêm mi một phần tư ( Insert ): Chn thêm một phần tư vào một v tr trống ca bảng

băm.

Xoá ( Delete / Removal ): Loại b một phần tư khi bảng băm.

Sao chép (Copy ): Tạo một bảng băm mi trên cơ sở một bảng băm đã c.

Duyệt ( Traverse ): Duyệt các phần tư ca bảng theo một thứ tự nhất đnh.

4.2.Hàm băm và các loại hàm băm :

4.2.1.Hàm băm (Hash Function):

Hàm băm là hàm sư dng để ánh xạ tập các khoá đại diện cho các mc dữ liệu trong

bảng thành đa chỉ nơi chứa mc dữ liệu đ.

Hình 2.3 : Mô hình hàm băm

Khoá trong bảng băm c thể là dạng số hoc chuối (

xâu ký tự ). Nu khoá là dạng số th trƣc khi áp dng phép băm ta phải lựa chọn các chữ số,gii hạn giá tr, áp dng các thuật toán. Các khoá ở dạng số thƣờng đƣợc chọn c kiểu số

nguyên.

Nu khoá ở dạng xâu ký tự th trƣc khi áp dng phép băm n cần đƣợc bin đổi thành

dạng phù hợp ( V d lấy giá tr mã ASCII ca các ký tự chẳng hạn ), chọn lựa những phần

độc lập và c ý ngha nhất trong khoá và lựa chọn một hàm băm phù hợp nhất vi cấu trúc

ca khoá.

Hàm băm đƣợc chia làm hai dạng chnh : Dạng bảng tra và dạng công thức. Hàm băm dạng bảng tra :



58

Giả sư c bảng tra c khoá là bộ chữ cái ting Anh.Bảng c 26 đa chỉ c giá tr từ 0..25.

Khoá a ứng vi đa chỉ 0, khoá b ứng vi đa chỉ 1… khoá z ứng vi đa chỉ 25.

Khoá Đa chỉ Khoá Đa chỉ Khoá Đa chỉ Khoá Đa chỉ

a 0 h 7 o 14 v 21

b 1 i 8 p 15 w 22c 2 j 9 q 16 x 23

d 3 k 10 r 17 y 24

e 4 l 11 s 18 z 25

f 5 m 12 t 19

g 6 n 13 u 20

Bảng 2.1 : Hàm băm dạng bảng tra Hàm băm dạng công thức : Hàm băm dạng công thức thƣờng c dạng tổng quát là

HF(k ) trong đ k là khoá. Hàm băm dạng này rất đa dạng và không b ràng buộc bởi bất cứ

tiêu chuẩn nào.

4.2.2.Một số loại hàm băm :

Một hàm băm tốt phải thoả mãn một số điều kiện sau :

Tnh toán nhanh chng và đơn giản.

Các khoá phân bố đều trong bảng.

Ít xảy ra xung đột giữa các khoá.

Gọi P(k) là xác suất khoá k xuất hiện trong bảng. Khi đ vi mỗi i = 0, 1, …, m

- 1 thì ta có :

Giá tr băm phải độc lập vi bất cứ phần nào ca dữ liệu ngha là n phải phù hợp

và c tnh ngẫu nhiên.

Sau đây là một số hàm băm đơn giản và phổ bin.

2.2.1.Hàm băm sử dụng phương pháp chia :

Hàm băm này c các đc điểm sau :

Một khoá đƣợc ánh xạ vào một trong m ô ca bảng thông qua hàm:

HF(k ) = k mod m

Trong đ : k là khoá, m là kch thƣc bảng.

Chỉ sư dng phép chia đơn do đ tốc độ tnh toán nhanh.

Vấn đề đt ra là phải chọn một giá tr m phù hợp.

ik H k m

k P)(

1)(



59

o m chọn không tốt khi n c một trong các giá tr sau :

+ m = 2P , khi đ h(k ) sẽ chọn cùng giá tr là p bit cuối ca k .

+ m = 10P, khi đ hàm băm không ph thuộc vào tất cả các số thập phân ca khoá.

+ m = 2P – 1. Nu khoá là một xâu ký tự đƣợc dch thành các giá tr là luỹ thừa ca 2, th

hai xâu c thể đƣợc băm thành cùng một giá tr đa chỉ trên bảng. o Giá tr ca m là tốt khi n là một số nguyên tố và không quá gần vi giá tr là luỹ

thừa ca 2.

V d về cài đt một hàm băm sư dng phép chia :

Public Function Hash(ByVal Key As Long) As Long

Hash = Key Mod HashTableSize

End Function

2.2.2.Hàm băm sử dụng phương pháp nhân : Phƣơng pháp nhân c hai bƣc :

Khoá k đƣợc nhân vi hng số A nm trong khoảng 0 < A < 1. Sau đ ngƣời ta sẽ sư

dng phần phân số ca k *A.

Phần phân số ni trên đƣợc nhân vi m sau đ lấy phần nguyên. Do đ hàm băm c

dạng :

HF(k ) = m * (k *A mod 1 )

Trong đ : k là khoá, m là kch thƣc bảng, A là hng số. Một hàm băm sư dng phép nhân muốn c hiệu quả cao phải lựa chọn giá tr m và A

cho phù hợp.

m thƣờng đƣợc chọn là m = 2 p.

A đƣợc chọn ph thuộc vào đc trƣng ca dữ liệu. Một giá tr A tốt đƣợc đề xuất c

giá tr là :

A = )2 / )51 /((1 = 2 / )15( 0.6180339887…

V d về cài đt một hàm băm sư dng phép chia : Private Const S As Long = 64

Private Const N As Long = 1023

Public Function Hash(ByVal Key As Long) As Long

Hash = ((K * Key) And N) \ S

End Function

2.2.3.Hàm băm sử dụng phép nghịch đảo :

Đây là phƣơng pháp trong đ hàm băm c dạng : HF(k ) = A / ( B*k + C ) mod m



60

Trong đ : k là khoá, m là kch thƣc bảng, A, B, C là các hng số.

2.2.4.Hàm băm sử dụng phương pháp cộng xâu :

Để băm một xâu c chiều dài thay đổi, mỗi ký tự đƣợc thêm vào xâu sẽ đƣợc chia lấy

dƣ cho 256 cho đn tận ký tự cuối cùng. Giá tr băm, nm trong khoảng 0..255, đƣợc tnh nhƣ

sau :Public Function Hash(ByVal S As String) As Long

Dim h As Byte

Dim i As Long

h = 0

For i = 1 to Len(S)

h = h + Asc(Mid(S, i, 1))

Next i Hash = h

End Function

2.2.5.Hàm băm sử dụng phương pháp XOR xâu :

Trong các xâu thƣờng xuất hiện một chuỗi ký tự tƣơng tự nhau hay đảo ngữ. Do đ

việc thực hiện phép XOR các Byte trong xâu sẽ giúp khắc phc hiện tƣợng này và giúp đạt

đƣợc các giá tr băm nm trong khoảng 0..255. Kt quả ca mỗi phép XOR tạo ra một thành

phần ngẫu nhiên.

Private Rand8(0 To 255) As Byte

Public Function Hash(ByVal S As String) As Long

Dim h As Byte

Dim i As Long

h = 0

For i = 1 To Len(S)

h = Rand8(h Xor Asc(Mid(S, i, 1)))

Next i

Hash = h

End Function

2.2.6.Phép băm phổ quát (Universal Hashing):

Nhƣ chúng ta thấy c nhiều loại hàm băm khác nhau. Xong chúng ta cần phải chọn

đƣợc một hàm băm thch hợp để hạn ch hiện tƣợng xung đột giữa các khoá. Giải pháp đƣa ra

là sư dng hàm băm phổ quát.

Băm phổ quát ngha là chúng ta chọn ngẫu nhiên một hàm băm h trong một tập các

hàm băm H khi thuật toán bắt đầu. Hàm băm đƣợc chọn phải đảm bảo :



61

C tnh chất ngẫu nhiên.

Đảm bảo các khoá t xảy ra xung đột.

Gọi H là tập hữu hạn các hàm băm ánh xạ một tập các khoá U thành các giá tr nm

trong khoảng {0, 1, …, m - 1}. H gọi là phổ quát nu :

Mỗi cp khoá riêng biệt x, y U số hàm băm h H cho kt quả h( x) = h( y) là | H | / m.

Ni cách khác vi mỗi hàm băm ngẫu nhiên từ H khả năng xung đột giữa x và y ( x y

) chính xác là 1/ m( m là kch thƣc bảng băm cho trƣc ).

Tập H sẽ đƣợc xây dựng nhƣ sau :

Chọn kch thƣc bảng m là một số nguyên tố.

Phân tích khoá x thành r + 1 byte để x c dạng x = { x1, x2, ..., xr }.

Giá tr ln nhất ca chuỗi sau khi phân tch < m. Gọi = {1, 2,…, r } biểu th cho một chuỗi r + 1 phần tư đƣợc chọn trong khoảng

{0, 1,…, m - 1}.

Hàm băm h H tƣơng ứng đƣợc đnh ngha nhƣ sau :

h( x) = xa i

r

i

i0

mod m

Theo đnh ngha ở trên H có mr +1 phần tư.

4.3.Xung đột và cách xư lý xung đột

4.3.1. Định nghĩa :

Xung đột trong phép băm đƣợc hiểu là trạng thái khi hai khoá khác nhau đƣợc băm

thành cùng một giá tr đa chỉ. Tổng quát ta c:

k1 k2 thì ta nói k1 và k2 là hai khoá xung đột khi: HF(k1) = HF(k2)

4.3.2.Hệ số tải (Load Factor - ) :

Giả sư c bảng băm c kch thƣc m vi n mc dữ liệu. Khi đ tỷ số = n / m đƣợc

gọi là hệ số tải. Hệ số tải cho bit trạng thái lấp đầy ca bảng. V d một bảng băm c hệ số

tải là 0.25 th c ngha là bảng băm này đã sư dng 25% kch thƣc bảng để lƣu dữ liệu.

Hệ số tải quyt đnh xác suất xảy ra tƣơng tranh ca các khoá. Do đ cần phải chọn

một hệ số tải thch hợp để giảm thiểu xung đột. Giá tr ca hệ số tải thƣờng đƣợc sư dng là

nh hơn hoc bng 30%.

4.3.3.Một số phƣơng pháp xư lý xung đột :

C hai cách tip cận ch yu để giải quyt xung đột : sư dng bảng băm đa chỉ mở và

cấu trúc lại bảng băm.



62

Để giải quyt xung đột thông qua bảng băm đa chỉ mở ngƣời ta c các phƣơng pháp :

d tuyn tnh, d căn bậc hai, băm kép và băm lại.

Đối vi cách tip cận thay đổi cấu trúc bảng ngƣời ta c các phƣơng pháp : Mc nối

trực tip, sư dng các Bucket.

Ngoài ra đối vi trƣờng hợp dữ liệu c kch thƣc ln ngƣời ta c thể sư dng các phƣơng pháp băm khác nhƣ : băm lại, băm mở rộng.

Dƣi đây là chi tit về các phƣơng pháp này.

3.3.1.Băm theo địa chỉ mở (Open-adressing hashing) :

Băm theo đa chỉ mở giải quyt xung đột bng cách lƣu tất cả các mc dữ liệu trong

chnh bảng băm. Phƣơng pháp này khá thch hợp khi chúng ta c thể ƣc lƣợng đƣợc số mc

vào. Khi đ chúng ta c thể c đ các v tr để lƣu tất cả các mc trong bảng (kể cả các v tr

sư dng để ngăn cách) và vẫn giảm đƣợc không gian lƣu trữ nhiều hơn so vi phƣơng phápmc nối.

Ngƣời ta đnh ngha một hàm băm chung cho phƣơng pháp băm theo đa chỉ mở. Nhƣ

vậy hàm băm lúc này gm c 2 tham số : khoá k và số lần d tm p , trong đ 0 p m-1.

Tham số p sư dng để gii hạn số lần d và cho phép chúng ta bit khi nào thuật toán dừng.

Sau đây chúng ta xét một số phƣơng pháp băm theo đa chỉ mở c thể.

3.3.1.1.Phương pháp dò tuyến tính :

D tuyn tnh là mô hnh đa chỉ mở đơn giản nhất. Phƣơng pháp này gm các thao

tác: tm kim, chn thêm một mc dữ liệu.

Hàm băm sư dng cho phƣơng pháp này c dạng :

h(k , p) = ( h(k ) + p )mod m

Thao tác tm kim :

Khi xung đột xảy ra phƣơng pháp này đơn giản là d một v tr trống trong bảng. Để tm

một mc dữ liệu trƣc ht ta phải thực hiện băm khoá ca mc dữ liệu này để tm ra chỉ số

ca n trong bảng. Nu mc dữ liệu không c tại v tr ca chỉ số mà chúng ta thu đƣợc th

chúng ta bắt đầu thực hiện d theo tuyn tại v tr này. C 3 khả năng c thể xảy ra :

1. V tr tip theo c chứa mc dữ liệu và tm kim kt thúc thành công.

2. V tr tip theo trống, dữ liệu không tm thấy, quá trnh tm kim kt thúc không thành

công.

3. V tr tip theo b chim giữ nhƣng các khoá lại không phù hợp v th v tr tip theo

đ sẽ đƣợc d.

Số các v tr cần d trong phƣơng pháp này ph thuộc vào 2 yu tố :

+ Hàm băm đƣợc chọn nhƣ th nào.

+ Bảng đã sư dng bao nhiêu không gian để lƣu dữ liệu.



63

Nu chúng ta chọn đƣợc một hàm băm thch hợp và bảng đã sư dng khoảng 30% - 50%

th sẽ đảm bảo đƣợc số v tr cần d là nh nhất c thể.

Chúng ta c một v d về cách cài đt thao tác tm kim đ là :

int jsw_find ( void *key, int len )

{

unsigned h = hash ( key, len ) % N;

void *save = table[h];

while ( table[h] != NULL ) {

if ( compare ( key, table[h] ) == 0 )

return 1;

h = ( h + 1 ) % N;

if ( compare ( table[h], save ) == 0 )return 0;

}

return 0;

}

Thao tác chèn :

Để chn thêm một mc mi chúng ta cần thực hiện :

Tnh các giá tr băm cho các khoá thông qua hàm băm đã chọn.

Nu v tr c giá tr băm đã c dữ liệu th thao tác d đƣợc thực hiện từ v tr này.

Thao tác d đƣợc thực hiện cho đn khi tm đƣợc một v tr trống. Thao tác này sẽ d tip ở v

tr đầu nu n đạt đn v tr cuối ca tuyn.

Khi tm đƣợc một ô trống th mc dữ liệu sẽ đƣợc chn vào.

Thao tác này c thể cài đt nhƣ sau :

void jsw_insert ( void *key, int len )

{


while ( table[h] != NULL )

h = ( h + 1 ) % N;

table[h] = key;

}

Thao tác xoá :

Thao tác nay không đơn giản nhƣ hai thao tác trên. Việc xoá trực tip một mc khi

bảng là khôn thể v các phép d tip theo đ c thể nhận ra các khoá đã b b đi và nu một

bucket rỗng đƣợc tạo ra trong khi một buket khác vẫn đầy th quá trnh tm kim c thể không



64

chnh xác. Nhƣ vậy thao tác xoá c thể phá vỡ cấu trúc dữ liệu ca bảng. Giải pháp đƣa ra là

khi xoá một khoá trên một đoạn ca bucket th ta lại chn khoá vào đoạn tƣơng tự ca n.

Nhƣng cách này dƣờng nhƣ khá phức tạp.

Sau đây là một v d về thao tác xoá :

void jsw_remove ( void *key, int len )

{



h = ( h + 1 ) % N;

table[h] = DELETED;

}

Đánh giá :

Trong phƣơng pháp này các khoá c khuynh hƣng b đƣa vào các đoạn gọi l à Cluster

( b cm ). Điều này c ngha là nhiều phần trong bảng c thể đầy lên nhanh chng trong khi

các phần khác vẫn cn trống. Do phƣơng pháp này cần sư dng một lƣợng ln các Bucket

rỗng nm xen kẽ vi các Bucket đã sư dng nên việc b cm sẽ làm cho nhiều Bucket b

duyệt qua trƣc khi tm đƣợc một Bucket rỗng. V vậy thao tác tm kim sẽ b chậm đi và kéo

theo các thao tác chn và xoá cũng chậm. Một bảng băm c hệ số tải càng ln th khả năng b

cm xảy ra càng ln. Do đ một hàm băm tốt và kch thƣc bảng là một số nguyên tố sẽ cải

thiện đƣợc vấn đề này.

3.3.1.2.Phương pháp dò căn bậc 2 :

Để khắc phc vấn đề b cm chnh ngƣời ta đƣa ra phƣơng pháp d căn bậc hai.

Phƣơng pháp này sư dng hàm băm c dạng :

h(k , p) = ( h(k ) + c1 p + c2 p2 ) mod m

Các giá tr c1, c2, m xác đnh liệu toàn bộ bảng c đƣợc sư dng hay không.

Thao tác tm kim :

Theo hàm băm nhƣ trên để tm kim một mc trong bảng ngƣời ta sẽ bắt đầu từ v tr

đầu tiên trong bảng đƣợc xác đnh bởi hàm băm, gọi là v tr i và tip tc d ti các v tr i +

12, i + 22 , …, i + ( m - 1 )2 ( tất cả đều mod m ). Cứ nhƣ vậy quá trnh tm kim đƣợc thực

hiện cho đn khi tm thấy mc dữ liệu trong bảng ( kt thúc thành công ) hoc gp một v tr

trống ( kt thúc không thành công ).

Thuật toán sư dng cho phƣơng pháp này c phần phức tạp hơn phƣơng pháp d tuyn

tnh. Dƣi đây là v d c thể :

int jsw_search ( void *key, int len )

{



65


unsigned step;

for ( step = 1; table[h] != NULL; ++step ) {


return 1;

h = ( h + step * step ) % N;

}

return 0;

}

Thao tác chèn :


{unsigned h = hash ( key, len ) % N;

unsigned step;

for ( step = 1; table[h] != NULL; ++step )

h = ( h + step * step ) % N;

table[h] = key;

}

Thao tác xoá :


{


unsigned step;

for ( step = 1; table[h] != NULL; ++step )

h = ( h + step * step ) % N;

table[h] = DELETED;

}

Đánh giá :

Phƣơng pháp d theo căn bậc hai giảm đáng kể hiện tƣợng b cm chnh. Tuy nhiên v

chuỗi d tm luôn bắt đầu ở cùng bucket ( một ô ca bảng) nên chúng ta lại gp phải hiện

tƣợng b cm thứ cấp ( Secondary Clustering ). Đây không phải là một hiện tƣợng đáng quan

tâm nhƣ b cm chnh. Nhƣng do phƣơng pháp d căn bậc hai chỉ hoạt động khi hệ số tải <

0.5 và kch thƣc ca bảng là một số nguyên tố nên hiện tƣợng này lại làm chậm đáng kể tốc

độ tm kim.



66

Ni chung phƣơng pháp này nhanh và tránh đƣợc hiện tƣợng b cm chnh nhƣng lại t

đƣợc sư dng trong thực t v sự gii hạn về thời gian. Phƣơng pháp này chỉ đảm bảo hoạt

động hiệu quả khi kch thƣc bảng là số nguyên tố và dung lƣợng bảng đã sư dng chƣa quá

một nưa.

3.3.1.3.Phương pháp băm kép : Phƣơng pháp này là một giải pháp đáng lƣu ý thay cho phƣơng pháp d theo căn bậc

hai. N c thể khắc phc đƣợc hiện tƣợng b cm chnh mà không chu sự gii hạn nào.

Phƣơng pháp này sư dng hai hàm băm độc lập nhau. Hàm băm thứ nhất đƣợc sư

dng nhƣ bnh thƣờng ( theo một trong hai phƣơng pháp đã kể trên ). Hàm băm thứ hai đƣợc

sư dng để tạo ra kch thƣc bƣc d. Do bản thân khoá c thể xác đnh đƣợc bƣc d nên

tránh đƣợc hiện tƣợng b cm chnh. Phƣơng pháp này c thuật toán khá đơn giản nhƣng c 2

điều cần chú ý để đảm bảo phƣơng pháp này hoạt động chnh xác : Hàm băm thứ hai không đƣợc trả về giá tr 0 để tránh hiện tƣợng lp vô hạn.

Giống nhƣ d theo tuyn, kch thƣc bảng phải là một số nguyên tố hoc là một giá tr

luỹ thừa ca 2 vi kt quả hàm băm thứ hai trả về là một số lẻ.

Nhƣ vậy cách cài đt cho phƣơng pháp này cũng tƣơng tự nhƣ các phƣơng pháp băm

theo đa chỉ mở khác. Một v d minh hoạ c thể là :

Thao tác tm kim :

int jsw_search ( void *key, int len )

{


unsigned h2 = hash2 ( key ) % ( N - 1 ) + 1;

while ( table[h] != NULL ) {


return 1;

h = ( h + h2 ) % N;

}

return 0;

}

Thao tác chèn :


{






67

h = ( h + h2 ) % N;

table[h] = key;

}

Thao tác xoá :


{



for ( table[h] != NULL )

h = ( h + h2) % N;

table[h] = DELETED;

}3.3.2.Cấu trúc lại bảng băm :

Phƣơng pháp này giải quyt xung đột bng cách thay đổi cấu trúc ca bảng băm. Theo

đ một v tr c thể chứa đƣợc nhiều hơn một mc dữ liệu. Sau đây là một số phƣơng pháp

cấu trúc lại bảng băm.

3.3.2.1.Sử dụng Bucket :

Trong phƣơng pháp này bản thân mỗi phần tư trong bảng băm là một mảng đƣợc gọi

là ngăn chứa( Bucket ). Các khoá đƣợc băm về cùng một v tr sẽ đƣợc đt trong các cột tƣơng

ứng vi các v tr này. V d :

0 1 2 3 4 5 6 7 8 9 10

K

k3 k5 k5 k7 k8

K

k4 k9

Bảng 2.2 : Mô hình một Bucket

Giả sư c hai khoá k 1, k 2 là hai khoá xung đột. Kt quả sau khi băm hai khoá này là 2.

Vậy ta xp k 1 và k 2 vào cột 1 tƣơng ứng vi v tr thứ 2. Tƣơng tự nhƣ vậy nu kt quả băm

các khoá khác cho v tr 2 th các khoá sẽ lần lƣợt đƣợc xp vào cột này.

Nhƣ vậy c thể thấy phƣơng pháp này cần nhiều không gian lƣu trữ hơn thực t dữ

liệu yêu cầu.

Trong phƣơng pháp này, để tm một khoá nhất đnh ngƣời ta phải kiểm tra tất cả các

cột liên quan ti v tr ca khoá này ( t nhất là cho đn khi chúng ta tm đƣợc một v tr trống



68

). Nu các khoá c thứ tự, chúng ta nên lƣu các khoá theo trật tự tăng dần. Nhƣ vậy chúng ta

c thể loại bt các cột cần kiểm tra. Độ phức tạp trung bnh ca thao tác tm kim ph thuộc

vào số v tr trong Bucket đã đƣợc điền. Do đ khi nào bảng chƣa đƣợc điền đầy khi đ khả

năng xung đột vẫn c thể xảy ra.

3.3.2.2.Phương pháp móc nối trực tiếp :Theo phƣơng pháp này bảng băm là một mảng các danh sách liên kt. Phƣơng pháp

này đt các khoá b xung đột vào cùng một danh sách liên kt tại v tr là kt quả sau khi băm.

Một bảng băm theo phƣơng pháp này c thể mô tả nhƣ sau :

Hình 2.3 : Bảng băm theo

phương pháp móc nối

Vấn đề đt ra ở đây là danh sách liên kt đƣợc cấu trúc nhƣ th nào. Khi việc tm kim

ca bảng băm ph thuộc vào việc tm kim trên danh sách liên kt th một danh sách đƣợc sắp

xp là một cấu trúc đáng lƣu ý. Cấu trúc này c hiệu quả t hơn vi thao tác chn và thao tác

tm kim thành công hoc không thành công ( tnh trung bnh ). Khi đ một nưa số danh sách

liên kt sẽ đƣợc tm kim. Nu danh sách không đƣợc sắp xp th một lần tm kim không

thành công c thể duyệt qua toàn bộ các danh sách liên kt.

Tuy nhiên điều ni trên chỉ đúng về mt lý thuyt. Trên thực t cn c nhiều thao tác

hơn cần thit. V vi một hàm băm tốt các chuỗi ( danh sách liên kt ) phải đảm bảo đ ngắn

để thấy đƣợc sự khác nhau giữa danh sách đƣợc sắp xp và danh sách chƣa đƣợc sắp xp.

Chúng ta giả sư rng hầu ht thời gian thực hiện phƣơng pháp này sư dng để thực

hiện so sánh giữa khoá tm kim vi các khoá khác trong danh sách. Chúng ta cũng giả sư

thời gian cần thit để băm ti danh sách thch hợp và xác đnh khi nào đn v tr cuối ca danh

sách tƣơng đƣơng vi một so sánh.

Nhƣ vậy tất cả các thao tác cần 1 + Số so sánh (lần).

Giả sư bảng băm c kch thƣc m và có n mc đƣợc chn vào bảng. Khi đ mỗi danh

sách trung bnh sẽ chứa n / m mc. Ở đây ta c thể thấy số mc trung bnh trên một danh sách

chnh là hệ số tải = n / m.

Sau đây là một số thao tác chnh ca phƣơng pháp này.

Thao tác tm kim :

Khi tm một khoá trong bảng, khoá sẽ đƣợc băm và trả về kt quả là chỉ số nơi c danh

sách liên kt sẽ đƣợc tm kim. Nhƣ vậy hàm băm sẽ quyt đnh phải tm ở danh sách nào.



69

Khi tm kim thành công thuật toán sẽ thực hiện băm và tm ti danh sách thch hợp.

Tính trung bnh th một nưa số mc sẽ đƣợc kiểm tra trƣc khi một mc chnh xác đƣợc tm

thấy. Do đ thời gian tm kim là : 1 + /2.

Trong trƣờng hợp tm kim không thành công, nu danh sách không c trật tự th tất cả

các mc sẽ đƣợc kiểm tra và thời gian tm kim là : 1 + .Sau đây là cài đt ca thao tác này :

struct jsw_node {

void *key;

struct jsw_node *next;

};

struct jsw_node *table[N];

int jsw_find ( void *key, int len ){


if ( table[h] != NULL ) {

struct jsw_node *it = table[h];

while ( it != NULL ) {

if ( compare ( key, it->key ) == 0 )

return 1;

it = it->next;

}

}

return 0;

}

Thao tác chèn :

Chn vào một danh sách liên kt đơn giản hơn tm kim. Khi cần chn thêm một mc dữ

liệu vào bảng th khoá sẽ đƣợc băm và cho kt quả là v tr ca danh sách cần chn. Một nút

sẽ đƣợc thêm vào danh sách ( tạo phần header ca nút nu cần thit ) sau đ khoá và giá tr sẽ

đƣợc đẩy vào phần trƣc ca nút này.

Việc chn một nút vào cuối danh sách liên kt khá đơn giản. Nu một nút đƣợc chn vào

pha đầu ca danh sách liên kt th danh sách liên kt sẽ đƣợc sư dng nhƣ một ngăn xp vi

tnh chất truy cập tuần tự. Trên thực t chn một nút vào trƣc danh sách là cách đơn giản và

đạt hiệu quả tốt nhất.V d về cài thao tác này là :

int jsw_insert ( void *key, int len )



70

{


struct jsw_node *it = malloc ( sizeof *it );

if ( it == NULL )

return 0;

it->key = key;

it->next = table[h];

table[h] = it;

return 1;

}

Thao tác xoá :

Khi xoá một mc dữ liệu th cần thực hiện thao tác tm khoá cũ.

int jsw_remove ( void *key, int len )

{


struct jsw_node *save;

if ( table[h] == NULL )

return 0;

if ( compare ( key, table[h]->key ) == 0 ) {

save = table[h]->next;

table[h]->next = table[h]->next;

free ( save );

}

else {

struct jsw_node *it = table[h];

while ( it->next != NULL ) {

if ( compare ( key, it->next->key ) == 0 )

break;

it = it->next;

}

if ( it->next == NULL )

return 0;

save = it->next;

it->next = it->next->next;



71

free ( save );

}

return 1;

}

Đánh giá : Phƣơng pháp mc nối trực tip là phƣơng pháp xư lý xung đột phổ bin nhất v n khá

linh hoạt. Nội dung ca phƣơng pháp này đơn giản và n c một số ƣu điểm sau :

Gii hạn kch thƣc bảng không quá cứng nhắc.

Việc thực thi tránh tối đa hiện tƣợng xung đột.

Bảng dễ dàng xư lý các khoá trùng lp.

Thao tác xoá đơn giản và c thể thực hiện thƣờng xuyên.

Tuy nhiên việc cài đt phƣơng pháp này phức tạp hơn các phƣơng pháp khác. N cũngc một số nhƣợc điểm :

Phải xây dựng lại bảng khi việc thay đổi kch thƣc gp kh khăn.

Sư dng nhiều không gian nh hơn cho các liên kt.

Tốc độ xư lý c thể chậm hơn do sự tham chiu qua lại ca các liên kt.

3.3.3.Các phương pháp băm khác :

Băm lại :

Chúng ta thấy rng tất cả các phƣơng pháp trên chỉ hiệu quả khi hệ số tải < 2/3, tức là bảng không quá đầy. Khi bảng băm b lấp đầy các phƣơng pháp này không cn hiệu quả nữa.

Giải pháp đƣa ra là tạo ra một bảng mi c kch thƣc ln gấp đôi bảng ban đầu. Sau đ tất cả

các khoá sẽ đƣợc băm lại.

Độ phức tạp ca phƣơng pháp này là O(n) do đ phƣơng pháp này chỉ sư dng khi

kch thƣc dữ liệu ln. Cá biệt trong phƣơng pháp d theo căn bậc hai chúng ta phải băm lại

khi ½ bảng đƣợc sư dng.

Băm mở rộng :

Đây là một phƣơng pháp hỗ trợ hữu hiệu cho việc sư dng c hiệu quả không gian lƣu

trữ.

4.3.4. Đánh giá :

Khi xây dựng bảng băm nu chúng ta bit trƣc số mc dữ liệu sẽ đƣợc chn vào bảng

th mô hnh băm theo đa chỉ mở vi hệ số tải < ½ sẽ cho kt quả tốt nhất.

Mt khác nu chúng ta không bit trƣc c bao nhiêu mc dữ liệu đƣợc chn vào bảng

th phƣơng pháp mc nối trực tip c hiệu quả hơn.



72

Khi hệ số tải tăng sư dng phƣơng pháp băm theo đa chỉ mở sẽ gp những bất lợi ch

yu trong thực thi. Nhƣng đối vi phƣơng pháp mc nối hiệu quả ca n chỉ b giảm tuyn

tnh khi hệ số tải tăng. Do đ nu không chắc chắn về hệ số tải th phƣơng pháp đƣợc lựa

chọn là phƣơng pháp mc nối.

4.4.4.Kết luận :Bảng băm là một cấu trúc dữ liệu thch hợp cho việc lƣu trữ và tm kim dữ liệu

không c trật tự. Tuy phải xư lý xung đột nhƣng hầu ht các thao tác ca bảng băm đều dễ

thực hiện và các thao tác này c hiệu quả gần nhƣ không đổi trong hầu ht các trƣờng hợp.

Hàm băm ánh xạ các khoá dữ liệu vào trong các ô c sẵn ca bảng. Một bảng băm c

hiệu quả khi chúng ta chọn đƣợc một hàm băm tốt. Vấn đề cốt yu là :

Sư dng bảng băm c kch thƣc là một số nguyên tố.

Sư dng hàm băm c thể đảm bảo các khoá đƣợc phân bố đều trong bảng.Tuy nhiên

ngay cả trong trƣờng hợp chúng ta chọn đƣợc hàm băm tốt nhất th hiện tƣợng xung đột vẫn

c thể xảy ra.

Băm theo đa chỉ mở là một trong các phƣơng pháp giải quyt xung đột. Trong đ :

Phƣơng pháp d tuyn tnh : sư dng nu các ô đƣợc duyệt toàn bộ và tm v tr thành

công. Nhƣng phƣơng pháp này c thể gây ra hiện tƣợng b cm.

Phƣơng pháp d căn bậc 2 : Phƣơng pháp này tốt hơn do c thể giảm xác suất xảy ra

hiện tƣợng b cm. Hệ số tải nên < ½ để tránh làm giảm hiệu quả thực hiện ca phƣơng pháp.

Mc nối cũng là một biện pháp xư lý xung đột hiệu quả. Xong phƣơng pháp này đi hi

không gian lƣu trữ ln.

4.5. Bài tập áp dụng

1. Tạo các bảng băm chứa các số nguyên theo từng loại giải quyt xung đột 2. Tạo các bảng băm chứa họ tên sinh viên theo từng loại giải quyt xung đột 3. Tạo từ điển đơn giản

Một số đề thi tham khảo Đề 1 Câu 1: Cho biểu thức (a+b-c)*(d-e*f)-(x+y)/z

Hãy vẽ cây nh phân tƣơng ứng và suy ra dạng tiền tố và dạng hậu tố ca biểu thức đ. Câu 2:

a) Khai ba o cấu tru c dƣ liê u danh sa ch liên kêt đơn chƣ a ca c thông tin về nhân sƣ gôm co các trƣờng thông tin:

Họ và tên Thâm niên công ta c (tnh theo năm) Hê sô lƣơng

Lƣơng cơ ba n.b) Viêt ha m thêm mô t ba n ghi chƣ a thông tin nhân sƣ cu a mô t ngƣơ i va o cuôi danh sa chđa khai ba o ơ phần a.



73

c) Viêt ha m t nh xem co bao nhiêu nhân viên pha i đo ng thuê thu nhâ p biêt r ng lƣơngca một ngƣời trong một tháng đƣợc tnh bng công thức : hê sô lƣơng * lƣơng cơ ba n+ thâm niên * 200 (ngàn đng) và ngƣời đng thu thu nhập là ngƣời c thu nhập 1năm lơ n hơn 1000000000.

Đề 2

Câu 1:

a) Chn các kha sau lần lƣơ t va o mô t cây t m kiêm nhi phân rô ng : 20, 5, 1 17, 30, 24, 7,18, 23, 9, 32, 25. Xa khi cây các nút chứa các kha sau : 24, 10, 7.

b) Khai ba o cấu tru c cây nhi phân chƣ a ca c thông tin nhƣ ơ phần a cu a câu 2 và vit hàmduyê t cây theo thƣ tƣ trƣơ c.

Chuyê n biê u thƣ c trung tố sau tha nh cây biê u thƣ c : x*y + z*(t-u). Trong đo z , y, z, t, u la ca c biên (toán hạng).

Câu 2:Khai ba o danh sa ch liên kêt đơn chƣ a ca c trƣơ ng thông tin về mô t kha ch ha ng nhƣ

sau: Mã khách hàng, Họ và tên khách hàng, Sô điê n thoa i cu a kha ch ha ng (13 chƣ sô).

a) Viêt ha m co input la danh sa ch đa đƣơ c khai ba o ơ phần a va mô t xâu sdt la mô t phầnsố điê n thoa i trong trƣơ ng điê n thoa i cu a mô t kha c h ha ng na o đo . Viêt ha m tra vê nu tđầu tiên trong danh sa ch liên kêt co phần đầu trƣơ ng số điê n thoa i tru ng vơ i xâu sdt.

b) Viêt ha m sắp xêp danh sa ch kha ch ha ng trên theo chiều tăng dần cu a tên kha ch ha ng .Đề 3

Câu 1:a) Hãy chn các kha sau vào một cây tm kim nh phân rỗng mà các nút chứa các số

nguyên: 17, 4, 19, 27, 7, 18, 8, 30, 15. Xa khi cây lần lƣợt các nút chứa các kha :

19, 8, 17.b) Chuyê n biê u thƣ c trung tố sau tha nh biê u thƣ c tiền tố: 12 – 7*(3+9 – 2*5).c) Hãy khai báo cấu trúc cây tm kim nh phân chứa các trƣờng thông tin về sinh viên

nhƣ sau: Mã sinh viên, Họ và tên, Điê m trung b nh.

trong đo ma sinh viên la trƣơ ng kho a.Viêt ha m che n thêm mô t sinh viên vào cây vừa khai báo.

Câu 2:

a)

Khai ba o danh sa ch liên kêt đơn chƣ a ca c số thƣ c.b) Viêt ha m đa o ngƣơ c danh sa ch liên kêt đơn chƣ a ca c số thƣ c đƣơ c khai ba o ơ phần a .c) Viêt ha m săp xêp danh sa ch số thƣ c trên theo chiều tăng dần.

Đề 4: Câu 1:

a) Hãy chn các kha sau vào một cây tm kim nh phân rỗng mà các nút chứa các sốnguyên: 20, 17, 29, 15, 80, 6, 19, 51, 32. Xa khi cây lần lƣợt các nút chứa các kha :29, 20, 17.

b) Chuyê n biê u thƣ c trung tố sau tha nh biê u thƣ c hâ u tố:5 * ( 2 + 3 ) – 2 * ( 15 - 10 ) + 21.

c) Hãy khai báo cấu trúc cây tm kim nh phân chứa các trƣờng thông tin về nhân sự

nhƣ sau: Họ và tên Mã nhân viên



74

Lƣơng trong đo ma nhân viên la trƣơ ng kho a.Viêt ha m tnh trung bnh cộng lƣơng ca các nhân viên trong một cây vừa khai báo .

Câu 2:a) Khai ba o danh sa ch liên kêt đơn chƣ a ca c trƣơ ng thông tin về ha ng ho a nhƣ sau :

Tên mă t ha ng

Giá mt hàng Số lƣơ ng co n trong kho

b) Hãy cài đt hàm sắ p xêp danh sa ch trên theo chiều tăng dần cu a gia mă t ha ng , nêucùng giá th theo tên.

c) Viêt ha m nhâ n input la mô t danh sa ch đƣơ c khai ba o nhƣ trên va hai số nguyên dƣơngx < y, in ra tên ca c mă t ha ng co số lƣơ ng co n trong kho lơ n hơn x va nho hơn y.

Đề 5: Câu 1:

a) Khai ba o danh sa ch liên kêt đơn chƣ a ca c trƣơ ng thông tin về phần mềm nhƣ sau: Tên phân mềm Dung lƣơ ng (tnh bng Mb) Đi a ch download

b) Hãy cài đt hàm thêm một phần tư vào cuối danh sách trên .c) Viêt ha m t nh dung lƣơ ng trung b nh cu a ca c phần mềm trong danh sa ch liên kêt trên .

Câu 2:a) Hãy chn các kha sau vào một cây tm kim nh phân rỗng mà các nút chứa các số

nguyên: 19, 7, 1, 9, 25, 21, 70, 30, 8. Xa khi cây nút gốc. Đƣa ra kêt qua duyê t câytheo thƣ tƣ trƣơ c va thƣ tƣ sau.

b) Chuyê n biê u thƣ c hâ u tố sau tha nh biê u thƣ c tiên tô va t nh gia tri cu a no :11 2 3 * + 4 5 * 8 + 7 / +

c) Hãy khai báo cấu trúc cây tm kim nh phân chƣ a ca c trƣơ ng thông tin về nhân sƣ nhƣ sau: Họ và tên Mã nhân viên Lƣơng

trong đo ma nhân viên la trƣơ ng kho a.Viêt ha m t m nu t chƣ a thông tin về nhân viên co lƣơng thấp nhất.



TÀI LIỆU THAM KHẢO.

1. Đinh Mạnh Tƣờng, Cấu trúc dữ liệu và thuật toán, NXB Đại học Quốc gia Hànội, 2002

2. Đỗ Xuân Lôi, Cấu trúc dữ liệu và giải thuật, NXB Khoa học và Kỹ thuật, 1997

3. Nguyễn Quốc Lƣợng, Hoàng Đức Hải ,Cấu trúc dữ liệu + giải thuật = chƣơng

trình, NXB Giáo dc, 1996 4. Hoare, C.A.R, Note on date Structuring in structured Programming Dahl,

Dijkstra, and Hoare, pp 83-174.

5. Robert Sedgewick , Cẩm năng thuật toán, NXB KH Kỹ thuật, 2000

Documents

Bai Giang Cau Truc Du Lieu