Bài giảng Phân tích thiết kế giải thuật và cấu trúc dữ liệu: Phần 2 - ĐH CNTT&TT

Chương 4
CÁC THUẬT TỐN SẮP XẾP
4.1. Các thuật tốn sắp xếp cơ bản
4.1.1. Sắp xếp chọn (Selection Sort)
Giải thuật
Ðây là phương pháp sắp xếp đơn giản nhất được tiến hành như sau:
• Ðầu tiên chọn phần tử có khóa nhỏ nhất trong n phần tử từ a[1] đến
a[n] và hoán vị nó với phần tử a[1].
• Chọn phần tử có khóa nhỏ nhất trong n-1phần tử từ a[2] đến a[n] và
hốn vị nó với a[2].
• Tổng qt ở bước thứ i, chọn phần tử có khố nhỏ nhất trong n-i+1
phần tử từ a[i] đến a[n] và hốn vị nó với a[i].
• Sau n-1 bước này thì mảng đã được sắp xếp.
Phương pháp này được gọi là phương pháp chọn bởi vì nó lặp lại q
trình chọn phần tử nhỏ nhất trong số các phần tử chưa được sắp.
Ví dụ 2-1: Sắp xếp mảng gồm 10 mẩu tin có khóa là các số nguyên:
5, 6, 2, 2, 10, 12, 9, 10, 9 và 3
Bước 1: Ta chọn được phần tử có khoá nhỏ nhất (bằng 2) trong các
phần tử từ a[1] đến a[10] là a[3], hoán đổi a[1] và a[3] cho nhau. Sau bước
này thì a[1] có khố nhỏ nhất là 2.
Bước 2: Ta chọn được phần tử có khố nhỏ nhất (bằng 2) trong các
phần tử từ a[2] đến a[10] là a[4], hoán đổi a[2] và a[4] cho nhau.
Tiếp tục quá trình này và sau 9 bước thì kết thúc.

57


Bảng sau ghi lại các giá trị khoá tương ứng với từng bước.

Bảng 4.1: Các bước thực hiện sắp xếp chọn
Chương trình:

PROCEDURE SelectionSort;
VAR
i,j,LowIndex: integer;
LowKey: KeyType;
BEGIN
{1}

FOR i := 1 TO n-1 DO BEGIN

{2}

LowIndex := i;

{3}

LowKey := a[i].key;

{4}

FOR j := i+1 TO n DO

{5}

IF a[j].key < LowKey THEN

BEGIN
{6}

LowKey := a[j].key;

{7}

LowIndex := j;

END;
{8} Swap(a[i],a[LowIndex]);
END;

58


END;
Ðánh giá: Phương pháp sắp xếp chọn lấy O(n) để sắp xếp n phần tử.
Trước hết ta có thủ tục Swap lấy một hằng thời gian như đã nói ở mục
2.2.3.
Các lệnh {2}, {3} đều lấy O(1) thời gian. Vòng lặp for {4} – {7} thực
hiện n-i lần, vì j chạy từ i+1 đến n, mỗi lần lấy O(1), nên lấy O(n-i) thời gian.
2

Do đó thời gian tổng cộng là: O(n ).
4.1.2. Sắp xếp chèn (Insert Sort)
Giải thuật
Trước hết ta xem phần tử a[1] là một dãy đã có thứ tự.
Bước 1, xen phần tử a[2] vào danh sách đã có thứ tự a[1] sao cho a[1],
a[2] là một danh sách có thứ tự.
Bước 2, xen phần tử a[3] vào danh sách đã có thứ tự a[1], a[2] sao cho
a[1], a[2], a[3] là một danh sách có thứ tự.
Tổng quát, bước i, xen phần tử a[i+1] vào danh sách đã có thứ tự
a[1],a[2],..a[i] sao cho a[1], a[2],.. a[i+1] là một danh sách có thứ tự.
Phần tử đang xét a[j] sẽ được xen vào vị trí thích hợp trong danh sách

các phần tử đã được sắp trước đó a[1],a[2],..a[j-1] bằng cách so sánh khoá của
a[j] với khoá của a[j-1] đứng ngay trước nó. Nếu khố của a[j] nhỏ hơn khố
của a[j-1] thì hốn đổi a[j-1] và a[j] cho nhau và tiếp tục so sánh khoá của a[j1] (lúc này a[j-1] chứa nội dung của a[j]) với khoá của a[j-2] đứng ngay trước
nó...
Ví dụ 2-2: Sắp xếp mảng gồm 10 mẩu tin đã cho trong ví dụ 2-1.
Bước 1: Xen a[2] vào dãy chỉ có một phần tử a[1] ta được dãy hai phần
tử a[1]..a[2] có thứ tự. Việc xen này thực ra khơng phải làm gì cả vì hai phần
tử a[1], a[2] có khố tương ứng là 5 và 6 đã có thứ tự.
Bước 2: Xen a[3] vào dãy a[1]..a[2] ta được dãy ba phần tử a[1]..a[3]
có thứ tự. Việc xen này được thực hiện bằng cách : so sánh khoá của a[3] với
khoá của a[2], do khoá của a[3] nhỏ hơn khoá của a[2] (2<6) nên hoán đổi

59


a[3] và a[2] cho nhau. Lại so sánh khoá của a[2] với khoá của a[1], do khoá
của a[2] nhỏ hơn khoá của a[1] (2<5) nên hoán đổi a[2] và a[1] cho nhau.
Tiếp tục quá trình này và sau 9 bước thì kết thúc.
Bảng sau ghi lại các giá trị khố tương ứng với từng bước.

Bảng 4.2: Các bước sắp xếp chèn
Chương trình
PROCEDURE InsertionSort;
VAR
i,j: integer;
BEGIN
{1} FOR i := 2 TO n DO BEGIN
{2} J := i;
{3} WHILE (j>1) AND (a[j].key < a[j-1].key) DO BEGIN
{4} swap(a[j], a[j-1]);

{5} j := j-1;
END;
END;
END;
Ðánh giá: Phương pháp sắp xếp xen lấy O(n) để sắp xếp n phần tử.

60


Ta thấy các lệnh {4} và {5} đều lấy O(1). Vòng lặp {3} chạy nhiều
nhất i-1 lần, mỗi lần tốn O(1) nên {3} lấy i-1 thời gian. Lệnh {2} và {3} là
hai lệnh nối tiếp nhau, lệnh {2} lấy O(1) nên cả hai lệnh này lấy i-1.
Vịng lặp {1} có i chạy từ 2 đến n nên nếu gọi T(n) là thời gian để sắp n
phần tử thì ta có

4.1.3. Sắp xếp nổi bọt (Bubble Sort)
Giải thuật
Chúng ta tưởng tượng rằng các mẩu tin được lưu trong một mảng dọc,
qua q trình sắp, mẩu tin nào có khóa “nhẹ” sẽ được nổi lên trên. Chúng ta
duyệt tòan mảng, từ dưới lên trên. Nếu hai phần tử ở cạnh nhau mà không
đúng thứ tự tức là nếu phần tử “nhẹ hơn” lại nằm dưới thì phải cho nó “nổi
lên” bằng cách đổi chỗ hai phần tử này cho nhau. Cụ thể là:
Bước 1: Xét các phần tử từ a[n] đến a[2], với mỗi phần tử a[j], so sánh
khố của nó với khố của phần tử a[j-1] đứng ngay trước nó. Nếu khố của
a[j] nhỏ hơn khố của a[j-1] thì hốn đổi a[j] và a[j-1] cho nhau.
Bước 2: Xét các phần tử từ a[n] đến a[3], và làm tương tự như trên.
Sau n-1 bước thì kết thúc.
Ví dụ 2-3: Sắp xếp mảng gồm 10 mẩu tin đã cho trong ví dụ 2-1.
Bước 1: Xét a[10] có khố là 3, nhỏ hơn khố của a[9] nên ta hoán đổi
a[10] và a[9] cho nhau. Khoá của a[9] bây giờ là 3 nhỏ hơn khoá của a[8] nên

ta hoán đổi a[9] và a[8] cho nhau. Khoá của a[8] bây giờ là 3 nhỏ hơn khoá
của a[7] nên ta hoán đổi a[8] và a[7] cho nhau. Khoá của a[7] bây giờ là 3 nhỏ
hơn khoá của a[6] nên ta hoán đổi a[7] và a[6] cho nhau. Khoá của a[6] bây
giờ là 3 nhỏ hơn khoá của a[5] nên ta hoán đổi a[6] và a[5] cho nhau. Khố
của a[5] bây giờ là 3 khơng nhỏ hơn khố của a[4] nên bỏ qua. Khố của
a[4] là 2 khơng nhỏ hơn khoá của a[3] nên bỏ qua. Khoá của a[3] là 2 nhỏ
hơn khoá của a[2] nên ta hoán đổi a[3] và a[2] cho nhau. Khoá của a[2] bây

61


giờ là 2 nhỏ hơn khoá của a[1] nên ta hoán đổi a[2] và a[1] cho nhau. Đến đây
kết thúc bước 1 và a[1] có khố nhỏ nhất là 2.
Bước 2: Xét a[10] có khố là 9, nhỏ hơn khố của a[9] nên ta hoán đổi
a[10] và a[9] cho nhau. Khố của a[9] bây giờ là 9 khơng nhỏ hơn khoá của
a[8] nên bỏ qua. Khoá của a[8] là 9 nhỏ hơn khoá của a[7] nên ta hoán đổi
a[8] và a[7] cho nhau. Khoá của a[7] bây giờ là 9 nhỏ hơn khoá của a[6] nên
ta hoán đổi a[7] và a[6] cho nhau. Khoá của a[6] bây giờ là 9 khơng nhỏ hơn
khố của a[5] nên bỏ qua. Khố của a[5] bây giờ là 3 khơng nhỏ hơn khố
của a[4] nên bỏ qua. Khoá của a[4] là 2 nhỏ hơn khoá của a[3] nên ta hoán đổi
a[4] và a[3] cho nhau. Khoá của a[3] bây giờ là 2 nhỏ hơn khoá của a[2] nên
ta hoán đổi a[3] và a[2] cho nhau. Đến đây kết thúc bước 2 và a[2] có khố là
2.
Tiếp tục q trình này và sau 9 bước thì kết thúc.
Bảng sau ghi lại các giá trị khố tương ứng với từng bước.

Bảng 4.3: Các bước sắp xếp nổi bọt
Chương trình
PROCEDURE BubbleSort;
VAR

i,j: integer;
BEGIN

62


{1} FOR i := 1 to n-1 DO
{2} FOR j := n DOWNTO i+1 DO
{3} IF a[j].key < a[j-1].key THEN
{4} Swap(a[j],a[j-1]);
END;
Ðánh giá: Phương pháp sắp xếp nổi bọt lấy O(n) để sắp n phần tử.
Dòng lệnh {3} lấy một hằng thời gian. Vòng lặp {2} thực hiện (n-i)
bước, mỗi bước lấy O(1) nên lấy O(n-i) thời gian. Như vậy đối với tồn bộ
chương trình ta có:

4.2. Sắp xếp nhanh (Quick Sort)
4.2.1. Tư tưởng
Chúng ta vẫn xét mảng a các mẩu tin a[1]..a[n]. Giả sử v là 1 giá trị
khóa mà ta gọi là chốt (pivot). Ta phân hoạch dãy a[1]..a[n] thành hai mảng
con "bên trái" và "bên phải". Mảng con "bên trái" bao gồm các phần tử có
khóa nhỏ hơn chốt, mảng con "bên phải" bao gồm các phần tử có khóa lớn
hơn hoặc bằng chốt.
Sắp xếp mảng con “bên trái” và mảng con “bên phải” thì mảng đã cho
sẽ được sắp bởi vì tất cả các khóa trong mảng con “bên trái“ đều nhỏ hơn các
khóa trong mảng con “bên phải”.
Việc sắp xếp các mảng con “bên trái” và “bên phải” cũng được tiến
hành bằng phương pháp nói trên.
Một mảng chỉ gồm một phần tử hoặc gồm nhiều phần tử có khóa bằng
nhau thì đã có thứ tự.

4.2.2. Giải thuật
Vấn đề chọn chốt

63


Chọn khóa lớn nhất trong hai phần tử có khóa khác nhau đầu tiên kể
từ trái qua. Nếu mảng chỉ gồm một phần tử hay gồm nhiều phần tử có khóa
bằng nhau thì khơng có chốt.
Ví dụ 2-5: Chọn chốt trong các mảng sau
Cho mảng gồm các phần tử có khoá là 6, 6, 5, 8, 7, 4, ta chọn chốt là 6
(khoá của phần tử đầu tiên).
Cho mảng gồm các phần tử có khố là 6, 6, 7, 5, 7, 4, ta chọn chốt là 7
(khoá của phần tử thứ 3).
Cho mảng gồm các phần tử có khố là 6, 6, 6, 6, 6, 6 thì khơng có chốt
(các phần tử có khố bằng nhau).
Cho mảng gồm một phần tử có khố là 6 thì khơng có chốt (do chỉ có
một phần tử).
Vấn đề phần hoạch
Ðể phân hoạch mảng ta dùng 2 "con nháy" L và R trong đó L từ bên
trái và R từ bên phải, ta cho L chạy sang phải cho tới khi gặp phần tử có khóa
≥ chốt và cho R chạy sang trái cho tới khi gặp phần tử có khóa < chốt. Tại chỗ
dừng của L và R nếu L < R thì hốn vị a[L],a[R]. Lặp lại q trình dịch sang
phải, sang trái của 2 "con nháy" L và R cho đến khi L > R. Khi đó L sẽ là
điểm phân hoạch, cụ thể là a[L] là phần tử đầu tiên của mảng con “bên phải”.
Giải thuật QuickSort
Ðể sắp xếp mảng a[i]..a[j] ta tiến hành các bước sau:
• Xác định chốt.
• Phân hoạch mảng đã cho thành hai mảng con a[i]..a[k-1] và a[k]..a[j].
• Sắp xếp mảng a[i]..a[k-1] (Ðệ quy).

• Sắp xếp mảng a[k]..a[j] (Ðệ quy).
Quá trình đệ quy sẽ dừng khi khơng cịn tìm thấy chốt.
Procedure quicksoft(t,p:integer);
var i,j,x,m:integer;

64


begin
i:=t;j:=p;
m:=a[(i+j) div 2];
While (i<=j) do
Begin
while (a[i]while (a[j]>m) do j:=j-1;
if (i<=j) then
begin
hoanvi(a[i],a[j]);
i:=i+1;
j:=j-1;
end;
if (tif(iend;
end;
Ví dụ 2-4: Sắp xếp mảng gồm 10 mẩu tin có khóa là các số nguyên: 5,
8, 2, 10, 5, 12, 8, 1, 15 và 4.
Với mảng a[1]..a[10], hai phần tử đầu tiên có khóa khác nhau là là a[1]
và a[2] với khố tương ứng là 5 và 8, ta chọn chốt v = 8.
Để phân hoạch, khởi đầu ta cho L := 1 (đặt L ở cực trái) và R := 10 (đặt R ở

cực phải). Do a[L] có khố là 5 nhỏ hơn chốt nên L := L+1 = 2 (di chuyển L
sang phải), lúc này a[L] có khố là 8 = chốt nên dừng lại. Do a[R] có khố là
4 nhỏ hơn chốt nên R cũng không chuyển sang trái được. Tại các điểm dừng
của L và R ta có L < R (L=2 và R=10) nên hoán đổi a[L] và a[R] (a[2] và
a[10]) cho nhau. Sau khi hoán đổi, a[L] lại có khố là 4 nhỏ hơn chốt nên di
chuyển L sang phải (L := L+1 = 3). Khoá của a[L] là 2 nhỏ hơn chốt nên lại di
65


chuyển L sang phải (L := L+1 = 4). Khoá của a[L] là 10 lớn hơn chốt nên
dừng lại. Với R, khoá của a[R] bây giờ là 8 bằng chốt nên di chuyển R sang
trái (R := R-1 = 9). Khoá của a[R] là 15 lớn hơn chốt nên di chuyển R sang
trái (R := R-1 = 8). Khoá của a[R] là 1 nhỏ hơn chốt nên dừng lại. Tại các
điểm dừng của L và R ta có L < R (L=4 và R=8) nên hoán đổi a[L] và a[R]
(a[4] và a[8]) cho nhau. Sau khi hốn đổi, a[L] có khoá là 1 nhỏ hơn chốt nên
di chuyển L sang phải (L := L+1 = 5). Khoá của a[L] là 5 nhỏ hơn chốt nên lại
di chuyển L sang phải (L := L+1 = 6). Khoá của a[L] là 12 lớn hơn chốt nên
dừng lại. Với R, khoá của a[R] bây giờ là 10 lớn hơn chốt nên di chuyển R
sang trái (R := R-1 = 7). Khoá của a[R] là 8 bằng chốt nên di chuyển R sang
trái (R := R-1 = 6). Khoá của a[R] là 12 lớn hơn chốt nên di chuyển R sang
trái (R := R-1 = 5). Khoá của a[R] là 5 nhỏ hơn chốt nên dừng lại. Tại các
điểm dừng của L và R ta có L > R (L=6 và R=5) nên ta đã xác định được
điểm phân hoạch ứng với L = 6. Tức là mảng đã cho ban đầu được phân thành
hai mảng con bên trái a[1]..a[5] và mảng con bên phải a[6]..a[10]. Hình ảnh
của sự phân hoạch này được biểu diễn như sau:

Trong bảng trên, dòng chỉ số ghi các chỉ số của các phần tử của mảng
(từ 1 đến 10).
Trong dịng khố ban đầu, các giá trị khố ở dòng trên (5, 8, 2, 10, 5,
12, 8, 1, 15 và 4) là các giá trị khoá của mảng đã cho ban đầu, các giá trị khố

ở dịng dưới (4, 1, 10 và 8) là các giá trị khoá mới sau khi thực hiện hoán đổi
a[2] với a[10] và a[4] với a[8].
Giá trị chốt là v = 8.
Dòng cấp cấp 1, biểu diễn hai mảng con sau khi phân hoạch. Mảng bên
trái từ a[1] đến a[5] gồm các phần tử có khố là 5, 4, 2, 1 và 5. Mảng con bên
phải từ a[6] đến a[10] gồm các phần tử có khố 12, 8, 10, 15 và 8.
Tiếp tục sắp xếp đệ quy cho mảng con bên trái và mảng con bên phải.

66


Với mảng con bên trái a[1]..a[5], hai phần tử đầu tiên có khóa khác
nhau là là a[1] và a[2] với khoá tương ứng là 5 và 4, ta chọn chốt v = 5.
Để phân hoạch, khởi đầu ta cho L := 1 (đặt L ở cực trái) và R := 5 (đặt
R ở cực phải). Do a[L] có khố là 5 bằng chốt nên không thể di chuyển L. Do
a[R] có khố là 5 bằng chốt nên di chuyển R sang trái (R := R-1 = 4). Khoá
của a[R] bây giờ là 1 nhỏ hơn chốt nên dừng lại. Tại các điểm dừng của L và
R ta có L < R (L= và R=4) nên hoán đổi a[L] và a[R] (a[1] và a[4]) cho nhau.
Sau khi hoán đổi, a[L] lại có khố là 1 nhỏ hơn chốt nên di chuyển L sang
phải (L := L+1 = 2). Khoá của a[L] là 4 nhỏ hơn chốt nên lại di chuyển L sang
phải (L := L+1 = 3). Khoá của a[L] là 2 nhỏ hơn chốt nên lại di chuyển L sang
phải (L := L+1 = 4). Khoá của a[L] là 5 bằng chốt nên dừng lại. Với R, khoá
của a[R] bây giờ là 5 bằng chốt nên di chuyển R sang trái (R := R-1 = 4).
Khoá của a[R] là 5 bằng chốt nên di chuyển R sang trái (R := R-1 = 3). Khoá
của a[R] là 2 nhỏ hơn chốt nên dừng lại. Tại các điểm dừng của L và R ta có
L > R (L=4 và R=3) nên ta đã xác định được điểm phân hoạch ứng với L = 4.
Tức là mảng bên trái phân thành hai mảng con bên trái a[1]..a[3] và mảng con
bên phải a[4]..a[6].
Hình ảnh của sự phân hoạch này được biểu diễn dưới đây:

Tiếp tục sắp xếp cho các mảng con của cấp 1 và mảng con bên phải của
mảng ban đầu cho đến khi dừng (các mảng khơng có chốt). Cuối cùng ta có
mảng được sắp thứ tự. Hình sau biểu diễn tồn bộ quá trình sắp xếp.

67


4.3. Sắp xếp (Merge Sort)
4.3.1. Tư tưởng
Trong khoa học máy tính, sắp xếp trộn (merge sort) là một thuật tốn
sắp xếp để sắp xếp các danh sách hoặc bất kỳ cấu trúc dữ liệu nào có thể truy
cập tuần tự) theo một trật tự nào đó. Thuật tốn này là một ví dụ tương đối
điển hình của lối thuật tốn chia để trị. Nó được xếp vào thể loại sắp xếp so
sánh. Tư tưởng chủ đạo của thuật toán này như sau:
Giả sử có hai danh sách đã được sắp xếp a[1..m] và b[1..n]. Ta có thể
trộn chúng lại thành một danh sách mới c[1..m+n], được sắp xếp theo cách
sau đây:




So sánh hai phần tử đứng đầu của hai danh sách, lấy phần tử nhỏ hơn
cho vào danh sách mới. Tiếp tục như vậy cho tới khi một trong hai
danh sách là rỗng.
Khi một trong hai danh sách là rỗng ta lấy phần còn lại của danh sách
kia cho vào cuối danh sách mới.

Ví dụ: Cho hai danh sách a =(1,4,6,7,10) và b = (2,5,8,9), quá trình trộn diễn
ra như sau:
Danh sách a

Danh sách b

1,4,6,7,10

2,5,8,9
2,5,8,9
5,8,9

4,6,7,10
4,6,7,10

So sánh
1<2
2<4
4<5

68

Danh sách C
1
1,2
1,2,4


6,7,10
...

5<6

5,8,9

1,2,4,5
1,2,4,5,6,7,8,9,10

Đối với sắp xếp trong một danh sách, tư tưởng như sau:
Nếu danh sách con chỉ gồm hai phần tử, mỗi nửa của nó gồm một phần
tử đương nhiên đã được sắp. Do đó việc trộn tại chỗ hai nửa danh sách này
cho danh sách con 2 phân tử được sắp.
Trường hợp có nhiều hơn 2 phần tử, việc sắp xếp trộn được tiến hành
như sau: Xuất phát từ đầu danh sách a ta trộn a[1] với a[2], a[3] với a[4],...
Khi đó mọi danh sách con gồm hai phần tử của a đã được sắp. Tiếp tục trộn
các danh sách con kế tiếp nhau gồm 2 phần tử thành các danh sách con 4 phần
tử ... Mỗi lần trộn số các danh sách con cần trộn giảm đi một nửa. Q trình
dừng lại khi số danh sách con chỉ cịn một.
Ví dụ: Cho danh sách a =[2,7,6,3,4,5,1]
Sắp xếp như sau:
Giải thuật trộn đệ quy chia a thành hai danh sách con và tiến hành 3 bước
Danh sách trái Danh sách phải
2,7,6
3,4,5,1


Sắp xếp trộn danh sách trái 2,7,6
Quá trình chia
2,7,6
2 7,6
2 7 6



Quá trình trộn
2,6,7
2 6,7
2 6 7

Sắp xếp trộn danh sách phải 3,4,5,1
Quá trình chia
3,4,5,1
3,4
5,1
3 4 5 1

Quá trình trộn
1,3,4,5
3,4
1,5
3 4 5 1

69




Trộn danh sách trái 2,6,7 với danh sách phải 1,3,4,5
Danh sách trái Danh sách phải Danh sách trộn
2,6,7
1,3,4,5
1,2,3,4,5,6,7

4.3.2. Giải thuật
Để sắp xếp trộn đoạn a [k1..k2] của danh sách a[1..n] ta chia đoạn đó
thành 2 phần a[k1..k3] và a[k3+1..k2],trong đó k3=[k1+k/2] tiến hành sắp xếp
với mỗi phần rồi trộn chúng lại. Lời gọi thủ tục sắp xếp trộn với a[1..n]sẽ cho
kết quả là sắp toàn bộ danh sách a[1..n].
Đoạn chương trình:
Procedure MergeSort (a,k1,k2)
Var Int k3
{
if k1k3=int((k1+k2)/2)
MergeSort(a,k1,k3)
MergeSort(a,k3+1,k2)
Merge(a,k1,k3+1,k2)
}
}
Đoạn chương trình C:
void sapxep(int a[],int k1,int k2,int k3)
{
int i,j,k,T[k3-k1+1];
i=k1;
j=k2;
k=k1;
while (i{
if (a[i]<=a[j])
{
T[k]=a[i];
i=i+1;
}

else
{
T[k]=a[j];
j=j+1;
}
k=k+1;
}
70


if (i>=k2)
while (k<=k3)
{
T[k]=a[j];
j=j+1;
k=k+1;
}
if (j>k3)
while (k{
T[k]=a[i];
i=i+1;
k=k+1;
}
for (k=k1;k<=k3;k++)
a[k]=T[k];
}
void sapxeptron(int a[],int k1,int k2)
{
int k3;

if(k1{
k3=int((k1+k2)/2);
sapxeptron(a,k1,k3);
sapxeptron(a,k3+1,k2);
sapxep(a,k1,k3,k2);
}
}

71


Chương 5
CÂY
5.1. Các khái niệm
Hình 5.1 minh hoạ một cây T. Đó là một tập hợp T gồm 11 phần tử,
T={a, b, c, d, e, f, g, h, i, j, k}. Các phần tử của T được gọi là các đỉnh của cây
T. Tập T có cấu trúc như sau. Các đỉnh của T được phân thành các lớp không
cắt nhau : lớp thứ nhất gồm một đỉnh duy nhất a, đỉnh này gọi là gốc của cây;
lớp thứ hai gồm các đỉnh b, c ; lớp thứ ba gồm các đỉnh d, e, f, g, h và lớp
cuối cùng gồm các đỉnh i, j, k, mỗi đỉnh thuộc một lớp (trừ gốc), có một cung
duy nhất nối với một đỉnh nào đó thuộc lớp kề trên. (Cung này biểu diễn mối
quan hệ nào đó).

Trong tốn học có nhiều cách định nghĩa cây. Ở đây chúng ta đưa ra
định nghĩa đệ quy về cây. Định nghĩa này cho phép ta xuất phát từ các cây
đơn giản nhất ( cây chỉ có một đỉnh) xây dựng nên các cây lớn hơn.
Cây (cây có gốc) được xác định đệ quy như sau.
72

1. Tập hợp gồm một đỉnh là cây. Cây này có gốc là đỉnh duy nhất của
nó.
2. Giả sử T1, T2, ... , Tk (k = 1) là các cây có gốc tương ứng là r1,r2...,rk.
Các cây Ti (i = 1, 2,...k) , không không cắt nhau tức là Ti n Tj =  với i  j.
Giả sử r là một đỉnh mới không thuộc các cây Ti (i = 1, 2,... , k). Khi đó, tập
hợp T gồm đỉnh r và tất cả các đỉnh của cây Ti (i = 1, 2, ... , k) lập thành một
cây mới với gốc r. Các cây Ti (i = 1, 2, ... , k) được gọi là cây con của gốc r.
Trong biểu diễn hình học của cây T, mỗi đỉnh ri (i =1, 2, ... ,k) có cung nối với
gốc r (xem hình 5.2)

5.1.1. Cha, con, đường đi.
Từ định nghĩa cây ta suy ra rằng, mỗi đỉnh của cây là gốc của các cây
con của nó. Số các cây con của một đỉnh gọi là bậc của đỉnh đó. Các đỉnh có
bậc khơng được gọi là lá của cây.
Nếu đỉnh b là gốc của một cây con của đỉnh a thì ta nói đỉnh b là con
của đỉnh a và a là cha của b. Như vậy, bậc của một đỉnh là số các đỉnh con của
nó, cịn lá là đỉnh khơng có con. Các đỉnh có ít nhất một con được gọi là đỉnh
trong. Các đỉnh của cây hoặc là lá hoặc là đỉnh trong.
Các đỉnh có cùng một cha được gọi là anh em. Một dãy các đỉnh a1, a2,
... an (n  1), sao cho ai (i = 1, 2, ... , n-1) là cha của ai+1 được gọi là đường đi
từ a1 đến an. Độ dài của đường đi này là n-1. Ta có nhận xét rằng, luôn luôn
tồn tại một đường đi duy nhất từ gốc tới một đỉnh bất kỳ trong cây.

73


Nếu có một đường đi từ đỉnh a đến đỉnh b có độ dài k  1, thì ta nói a là
tiền thân của b và b là hậu thế của a.
Ví dụ. Trong cây ở hình 4.1, đỉnh c là cha của đỉnh f, g, h. Các đỉnh d,

i, j, k và h là lá, các đỉnh còn lại là đỉnh trong. a, c, g, k là đường đi có độ dài
3 từ a đến k. Đỉnh b là tiền thân của các đỉnh d, e, i, j.
5.1.2. Cây con.
Từ định nghĩa cây ta có, mỗi đỉnh a bất kỳ của cây T là gốc của một
cây nào đó, ta gọi cây này là cây con của cây T. Nó gồm đỉnh a và tất cả các
đỉnh là hậu thế của a. Chẳng hạn, với cây T trong hình 4.1, T1 = {c, f, g, h, k}
là một cây con
5.1.3. Độ cao, mức.
Trong một cây, độ cao của một đỉnh a là độ dài của đường đi dài nhất
từ a đến một lá. Độ cao của gốc được gọi là độ cao của cây. Mức của đỉnh a là
độ dài của đường đi từ gốc đến a. Như vậy gốc có mức 0.
Ví dụ. Trong cây ở hình 4.1, đỉnh b có dộ cao là 2, cây có độ cao là 3.
Các đỉnh b, c có mức 1 ; các đỉnh d, e, f, g, h có mức 2, còn mức của các đỉnh
i, j, k là 3.
5.1.4. Cây được sắp.
Trong một cây, nếu các cây con của mỗi đỉnh được sắp theo một thứ tự
nhất định, thì cây được gọi là cây được sắp. Chẳng hạn, hình 5.3 minh hoạ hai
cây được sắp khác nhau,

Sau này chúng ta chỉ quan tâm đến các cây được sắp. Do đó khi nói đến
cây thì cần được hiểu là cây được sắp.
74


Giả sử trong một cây được sắp T, đỉnh a có các con được sắp theo thứ
tự : b 1, b2, ..., bk (k  1). Khi đó ta nói b1 là con trưởng của a, và bi là anh liền
kề của bi+1 (b i+1 là em liền kề của bi), i = 1,2, ..., k-1. Ta cịn nói, với i < j thì bi
ở bên trái b j (bj ở bên phải bi). Quan hệ này được mở rộng như sau. Nếu a ở
bên trái b thì mọi hậu thế của a ở bên trái mọi hậu thế của b.
Ví dụ. Trong hình 4.1, f là con trưởng của c, và là anh liền kề của đỉnh

g. Đỉnh i ở bên trái đỉnh g.
Cây gắn nhãn.
Cây gắn nhãn là cây mà mỗi đỉnh của nó được gắn với một giá trị
(nhãn) nào đó. Nói một cách khác, cây gắn nhãn là một cây cùng với một ánh
xạ từ tập hợp các đỉnh của cây vào tập hợp nào đó các giá trị (các nhãn).
Chúng ta có thể xem nhãn như thông tin liên kết với mỗi đỉnh của cây. Nhãn
có thể là các dữ liệu đơn như số nguyên, số thực, hoặc cũng có thể là các dữ
liệu phức tạp như bản ghi. Cần biết rằng, các đỉnh khác nhau của cây có thể
có cùng một nhãn.
Rừng.
Một rừng F là một danh sách các cây :
F = (T1, T2, ..., Tn)
trong đó Ti(i = 1, ..., n) là cây (cây được sắp)
Chúng ta có tương ứng một - một giữa tập hợp các cây và tập hợp các
rừng. Thật vậy, một cây T với gốc r và các cây con của gốc theo thứ tự từ trái
sang phải là T1, T2, ..., Tn, T = (r, T1, T2, ..., Tn) tương ứng với rừng F = (T1,
T2, ..., Tn) và ngược lại.

5.2. Các phép toán trên cây
Các phép toán cơ bản trên cây.
1. Tìm cha của mỗi đỉnh.
Giả sử x là đỉnh bất kỳ trong cây T. Hàm Parent(x) xác định cha của
đỉnh x. Trong trường hợp đỉnh x khơng có cha (x là gốc) thì giá trị của hàm
Parent (x) là một ký hiệu đặc biệt nào đó khác với tất cả các đỉnh của cây,
chẳng hạn $. Như vậy nếu parent (x) = $ thì x là gốc của cây.
75


2. Tìm con bên trái ngồi cùng (con truởng) của mỗi đỉnh.
Hàm EldestChild (x) cho ta con trưởng của đỉnh x. Trong trường hợp x

là lá (x khơng có con) thì EldestChild (x) = $.
3. Tìm em liền kể của mỗi đỉnh.
Hàm NextSibling (x) xác định em liền kề của đỉnh x. Trong trường hợp
x khơng có em liền kề (tức x là con ngoài cùng bên phải của một đỉnh nào đó)
thì NextSibling(x) = $.
Ví dụ. Giả sử T là cây đã cho trong hình 4.1. Khi đó Parent(e) = b,
Parent(a) = $, EldestChild (c) = f, EldestChild (k) = $, NextSibling (g) = h,
NextSibling (h) = $.

5.3. Duyệt Cây
Trong thực tiễn chúng ta gặp rất nhiều bài toán mà việc giải quyết nó
được qui về việc đi qua cây (còn gọi là duyệt cây), "thăm" tất cả các đỉnh của
cây một cách hệ thống.
Có nhiều phương pháp đi qua cây. Chẳng hạn, ta có thể đi qua cây lần
lượt từ mức 0, mức 1,... cho tới mức thấp nhất. Trong cùng một mức ta sẽ
thăm các đỉnh từ trái sang phải. Ví dụ, với cây trong hình 4.1, danh sách các
đỉnh lần lượt được thăm là (a, b, c, d, e, f, g,h, i, j, k). Đó là phương pháp đi
qua cây theo bề rộng.
Tuy nhiên, ba phương pháp đi qua cây theo các hệ thống sau đây là
quan trọng nhất : đi qua cây theo thứ tự Preorder, Inorder và Postorder. Danh
sách các đỉnh của cây theo thứ tự Preordor, Inorder, và Postorder (gọi tắt là
danh sách Preorder, Inorder, và Postorder) được xác định đệ qui như sau :
1. Nếu T là cây gồm một đỉnh duy nhất thì các danh sách Preordor,
Inorder và Postorder chỉ chứa một đỉnh đó.
2. Nếu T là cây có gốc r và các cây con của gốc là T1, T2, ..., Tk (hình
4.2) thì
2a. Danh sách Preorder các đỉnh của cây T bắt đầu là r, theo sau là các
đỉnh của cây con T1 theo thứ tự Preordor, rồi đến các đỉnh của cây con T2

76

theo thứ tự Preorder, ..., cuối cùng là các đỉnh của cây con Tk theo thứ tự
Preordor.
2b. Danh sách Inorder các đỉnh của cây T bắt đầu là các đỉnh của cây
con T1 theo thứ tự Inordor, rồi đến gốc r, theo sau là các đỉnh của các cây con
T2, ... Tk theo thứ tự Inordor.
2c. Danh sách Postorder các đỉnh của cây T lần lượt là các đỉnh của các
cây con T1, T2,...Tk, theo thứ tự Postorder sau cùng là gốc r.
Ví dụ, khi đi qua cây trong hình 5.1 theo thứ tự Preordor ta được danh
sách các đỉnh là (a, b, d, e, i, j, c, f, g, k, h). Nếu đi qua cây theo thứ tự
Inorder, ta có danh sách (d, b, i, e, j, a, f, c, k, g, h). Còn danh sách Postorder
là (d, i, j, e, b, f, k, g, h, c, a).
Phương pháp đi qua cây theo thứ tự Preorder còn được gọi là kỹ thuật
đi qua cây theo độ sâu. Đó là một kỹ thuật quan trọng thường được áp dụng
để tìm kiếm nghiệm của các bài toán. Gọi là đi qua cây theo độ sâu, bởi vì khi
ta đang ở một đỉnh x nào đó của cây (chẳng hạn, đỉnh b trong cây ở hình 4.1),
ta cố gắng đi sâu xuống đỉnh cịn chưa được thăm ngồi cùng bên trái chừng
nào có thể được (chẳng hạn, đỉnh d trong cây ở hình 4.1) để thăm đỉnh đó.
Nếu tất cả các đỉnh con của x đã được thăm (tức là từ x khơng thể đi sâu
xuống được) ta quay lên tìm đến cha của x. Tại đây ta lại cố gắng đi sâu
xuống đỉnh con chưa được thăm. Chẳng hạn, trong cây ở hình 4.1, ta đang ở
đỉnh f, tại đây khơng thể đi sâu xuống, ta quay lên cha của f là đỉnh c. Tại c có
thể đi sâu xuống thăm đỉnh g, từ g lại có thể đi sâu xuống thăm đỉnh k. Quá
trình trên cứ tiếp tục cho tới khi nào toàn bộ các đỉnh của cây đã được thăm.
Đối lập với kỹ thuật đi qua cây theo độ sâu là kỹ thuật đi qua cây theo
bề rộng mà chúng ta đã trình bày. Trong kỹ thuật này, khi đang ở thăm đỉnh x
nào đó của cây, ta đi theo bề ngang sang bên phải tìm đến em liền kề của x để
thăm. Nếu x là đỉnh ngoài cùng bên phải, ta đi xuống mức sau thăm đỉnh
ngoài cùng bên trái, rồi lại tiếp tục đi theo bề ngang sang bên phải.

Sau đây chúng ta sẽ trình bày các thủ tục đi qua cây theo các thứ tự
Preorder, Inorder, Postorder và đi qua cây theo bề rộng.

77


Sử dụng các phép toán cơ bản trên cây và định nghĩa đệ qui của thứ tự
Preorder, chúng ta dễ dàng viết được thủ tục đệ qui đi qua cây theo thứ tự
Preorder. Trong thủ tục, chúng ta sẽ sử dụng thủ tục Visit (x) (thăm đỉnh x) nó
được cài đặt tuỳ theo từng ứng dụng. Các biến A, B trong thủ tục là các đỉnh
(Node) của cây.
procedure

Preorder ( A : Node) ;

{Thủ tục đệ qui đi qua cây gốc A theo thứ tự Preorder}
var B : Node
begin
Visit (A) ;
B : = EldestChild (A)
while B < > $ do
begin
Preorder ( B) ;
B : = NexSibling (B)
end ;
end ;
Một cách tương tự, ta có thể viết được các thủ tục đệ qui đi qua cây
theo thứ tự Inorder và Postorder.
procedure Inorder ( A : Node) ;
{Thủ tục đệ qui đi qua cây gốc A theo thứ tự Inorder }

var

B : Node ;

begin
B := EldestChild (A) ;
if B < > $ then begin Inorder (B) : B : = NextSibling (B) end ;
Visit (A) ;
while B < > $ do

78


begin
Inorder (B) ;
B : = NextSibling (B)
end ;
end ;

procedure Postorder (A : Node) ;
{Thủ tục đệ qui đi qua cây gốc A theo thứ tự Postorder}
var

B : Node ;

begin
B : = EldestChild (A) ;
while B < > $ do
begin
Postorder (B) ;

B : = NextSibling (B)
end ;
Visit (A)
end ;
Chúng ta cũng có thể viết được các thủ tục khơng đệ qui đi qua cây
theo các thứ tự Preordor, Inorder và Postorder. Chúng ta sẽ viết một trong ba
thủ tục đó (các thủ tục khác giành lại cho độc giả). Tư tưởng cơ bản của thuật
tốn khơng đệ qui đi qua cây theo thứ tự Preorder là như sau. Chúng ta sẽ sử
dụng một stack S để lưu giữ các đỉnh của cây. Nếu ở một thời điểm nào đó ta
đang ở thăm đỉnh x thì stack sẽ lưu giữ đường đi từ gốc đến x, gốc ở đáy của
stack còn x ở đỉnh stack. Chẳng hạn, với cây trong hình 4.1, nếu ta đang ở
thăm đỉnh i, thì stack sẽ lưu (a, b, e, i) và i ở đỉnh stack
procedure

Preorder ( A : Node) ;

79


{Thủ tục không đệ qui đi qua cây theo thứ tự Preorder}
var B : Node ;
S : Stack ;
begin
Intealize (S) ; {khởi tạo stack rỗng}
B:=A;
while B < > $ do
begin
Visit (B) ;
Push (B, S) ; {đẩy B vào stack}
B : = EldestChild (B)

end ;
while not Empty (S) do
begin
Pop (S,B) ;{loại phần tử ở đỉnh stack và gán cho B]
B : = NexSibling (B) ;
if B < > $ then
while B < > $ do
begin
Visit (B) ;
Push (B, S) ;
B : = EldestChild (B)
end ;
end ;
end ;

80


Sau đây chúng ta sẽ trình bày thuật tốn đi qua cây theo bề rộng, chúng
ta sẽ sử dụng hàng Q để lưu giữ các đỉnh theo thứ tự đã được thăm, đầu hàng
là đỉnh ngoài cùng bên trái mà ta chưa thăm các con của nó, cịn cuối hàng là
đỉnh ta đang ở thăm. Chẳng hạn, với cây trong hình 4.1, nếu ta đang ở thăm
đỉnh i thì trong hàng sẽ chứa các đỉnh (f, g, h, i) trong đó f ở đầu hàng và i ở
cuối hàng. Khi loại một phần tử ở đầu hàng, chúng ta sẽ lần lượt thăm các con
của nó (nếu có) và khi thăm đỉnh nào thì đưa đỉnh đó vào cuối hàng. Chúng ta
có thủ tục sau
procedure BreadthTraverse ( A : Node) ;
{Thủ tục đi qua cây gốc A theo bề rộng }
var

B : node ;
Q : Queue ;

begin
Initialize (Q) ; {khởi tạo hàng rỗng}
Visit (A) ;
Add (A, Q) ; {đưa gốc A vào hàng Q}
while not Empty (Q) do
begin
Delete (Q, B) ; {loại phần tử đầu hàng và gán cho B}
B : = EldestChild (B) ;
while B < > $ do
begin
Visit (B) ;
Add (B, Q) ;
B : = NextSibling (B)
end ;
end ; end ;

81