THAM KHẢO
Video hướng dẫn cách cài đặt LIST bằng mảng
I. KIỂU DỮ LIỆU TRỪU TƯỢNG DANH SÁCH [LIST]
1. Khái niệm danh sách
Mô hình toán học của danh sách là một tập hợp hữu hạn các phần tử có cùng một kiểu, mà tổng quát ta gọi là kiểu phần tử [Elementtype]. Ta biểu diễn danh sách như là một chuỗi các phần tử của nó: a1, a2, . . ., anvới n ≥ 0. Nếu n=0 ta nói danh sách rỗng [empty list]. Nếu n > 0 ta gọi a1 là phần tử đầu tiên và an là phần tử cuối cùng của danh sách. Số phần tử của danh sách ta gọi là độ dài của danh sách.
Một tính chất quan trọng của danh sách là các phần tử của danh sách có thứ tự tuyến tính theo vị trí [position] xuất hiện của các phần tử. Ta nói ai đứng trước ai+1, với i từ 1 đến n-1; Tương tự ta nói ailà phần tử đứng sau ai-1, với i từ 2 đến n. Ta cũng nói ai là phần tử tại vị trí thứ i, hay phần tử thứ i của danh sách.
Ví dụ: Tập hợp họ tên các sinh viên của lớp TINHOC 28 được liệt kê trên giấy như sau:
- Nguyễn Trung Cang
- Nguyễn Ngọc Chương
- Lê Thị Lệ Sương
- Trịnh Vũ Thành
- Nguyễn Phú Vĩnh
là một danh sách. Danh sách này gồm có 5 phần tử, mỗi phần tử có một vị trí trong danh sách theo thứ tự xuất hiện của nó.
2. Các phép toán trên danh sách
Để thiết lập kiểu dữ liệu trừu tượng danh sách [hay ngắn gọn là danh sách] ta phải định nghĩa các phép toán trên danh sách. Và như chúng ta sẽ thấy trong toàn bộ giáo trình, không có một tập hợp các phép toán nào thích hợp cho mọi ứng dụng [application]. Vì vậy ở đây ta sẽ định nghĩa một số phép toán cơ bản nhất trên danh sách. Để thuận tiện cho việc định nghĩa ta giả sử rằng danh sách gồm các phần tử có kiểu là kiểu phần tử [elementType]; vị trí của các phần tử trong danh sách có kiểu là kiểu vị trí và vị trí sau phần tử cuối cùng trong danh sách L là ENDLIST[L]. Cần nhấn mạnh rằng khái niệm vị trí [position] là do ta định nghĩa, nó không phải là giá trị của các phần tử trong danh sách. Vị trí có thể là đồng nhất với vị trí lưu trữ phần tử hoặc không.
Các phép toán được định nghĩa trên danh sách là:
INSERT_LIST[x,p,L]: xen phần tử x [ kiểu ElementType ] tại vị trí p [kiểu position] trong danh sách L. Tức là nếu danh sách là a1, a2, . , ap-1, ap ,. . , an thì sau khi xen ta có kết quả a1, a2, . . ., ap-1, x, ap, . . . , an. Nếu vị trí p không tồn tại trong danh sách thì phép toán không được xác định.
LOCATE[x,L] thực hiện việc định vị phần tử có nội dung x đầu tiên trong danh sách L. Locate trả kết quả là vị trí [kiểu position] của phần tử x trong danh sách. Nếu x không có trong danh sách thì vị trí sau phần tử cuối cùng của danh sách được trả về, tức là ENDLIST[L].
RETRIEVE[p,L] lấy giá trị của phần tử ở vị trí p [kiểu position] của danh sách L; nếu vị trí p không có trong danh sách thì kết quả không xác định [có thể thông báo lỗi].
DELETE_LIST[p,L] chương trình con thực hiện việc xoá phần tử ở vị trí p [kiểu position] của danh sách. Nếu vị trí p không có trong danh sách thì phép toán không được định nghĩa và danh sách L sẽ không thay đổi.
ENDLIST[L]: Trả về vị trí sau phần tử cuối cùng của List.
NEXT[p,L] cho kết quả là vị trí của phần tử [kiểu position] đi sau phần tử p; nếu p là phần tử cuối cùng trong danh sách L thì NEXT[p,L] cho kết quả là ENDLIST[L]. Next không xác định nếu p không phải là vị trí của một phần tử trong danh sách.
PREVIOUS[p,L] cho kết quả là vị trí của phần tử đứng trước phần tử p trong danh sách. Nếu p là phần tử đầu tiên trong danh sách thì Previous[p,L] không xác định. Previous cũng không xác định trong trường hợp p không phải là vị trí của phần tử nào trong danh sách.
FIRST[L] cho kết quả là vị trí của phần tử đầu tiên trong danh sách. Nếu danh sách rỗng thì ENDLIST[L] được trả về.
EMPTY_LIST[L] cho kết quả TRUE nếu danh sách có rỗng, ngược lại nó cho giá trị FALSE.
MAKENULL_LIST[L] khởi tạo một danh sách L rỗng.
Trong thiết kế các giải thuật sau này chúng ta dùng các phép toán trừu tượng đã được định nghĩa ở đây như là các phép toán nguyên thủy.
Muốn thêm phần tử vào đầu hay cuối danh sách ta gọi phép toán nào và gọi phép toán đó như thế nào?
Ví dụ: Dùng các phép toán trừu tượng trên danh sách, viết một chương trình con nhận một tham số là danh sách rồi sắp xếp danh sách theo thứ tự tăng dần [giả sử các phần tử trong danh sách thuộc kiểu có thứ tự].
Giả sử SWAP[p,q] thực hiện việc đổi chỗ hai phần tử tại vị trí p và q trong danh sách, chương trình con sắp xếp được viết như sau:
void sort[List* L] {
Position p,q;
//kiểu vị trí của các phần tử trong danh sách
p= FIRST[*L];
//vị trí phần tử đầu tiên trong danh sách
while [p!=ENDLIST[*L]]{
q=NEXT[p,*L];
//vị trí phần tử đứng ngay sau phần tử p
while [q!=ENDLIST[*L]]{
if [RETRIEVE[p,*L] > RETRIEVE[q,*L]]
Swap[p,q,*L]; // hoán đổi nội dung 2 phần tử
q=NEXT[q,*L];
}
p=NEXT[p,*L];
}
}
Tuy nhiên, cần phải nhấn mạnh rằng, đây là các phép toán trừu tượng do chúng ta định nghĩa, nó chưa được cài đặt trong các ngôn ngữ lập trình. Do đó để cài đặt giải thuật thành một chương trình chạy được thì ta cũng phải cài đặt các phép toán thành các chương trình con trong chương trình. Hơn nữa, trong khi cài đặt cụ thể, một số tham số hình thức trong các phép toán trừu tượng không đóng vai trò gì trong chương trình con cài đặt chúng, do vậy ta có thể bỏ qua nó trong danh sách tham số của chương trình con. Ví dụ: phép toán trừu tượng INSERT_LIST[x,p,L] có 3 tham số hình thức: phần tử muốn thêm x, vị trí thêm vào p và danh sách được thêm vào L. Nhưng khi cài đặt danh sách bằng con trỏ [danh sách liên kết đơn], tham số L là không cần thiết vì với cấu trúc này chỉ có con trỏ tại vị trí p phải thay đổi để nối kết với ô chứa phần tử mới. Trong bài giảng này, ta vẫn giữ đúng những tham số trong cách cài đặt để làm cho chương trình đồng nhất và trong suốt đối với các phương pháp cài đặt của cùng một kiểu dữ liệu trừu tượng.
3. Cài đặt danh sách
a. Cài đặt danh sách bằng mảng [danh sách đặc]
Ta có thể cài đặt danh sách bằng mảng như sau: dùng một mảng để lưu giữ liên tiếp các phần tử của danh sách từ vị trí đầu tiên của mảng. Với cách cài đặt này, dĩ nhiên, ta phải ước lượng số phần tử của danh sách để khai báo số phần tử của mảng cho thích hợp. Dễ thấy rằng số phần tử của mảng phải được khai báo không ít hơn số phần tử của danh sách. Nói chung là mảng còn thừa một số chỗ trống. Mặt khác ta phải lưu giữ độ dài hiện tại của danh sách, độ dài này cho biết danh sách có bao nhiêu phần tử và cho biết phần nào của mảng còn trống như trong hình II.1. Ta định nghĩa vị trí của một phần tử trong danh sách là chỉ số của mảng tại vị trí lưu trữ phần tử đó + 1[vì phần tử đầu tiên trong mảng là chỉ số 0].
Hình II.2
Như vậy, nếu ta xét thứ tự các phần tử bằng cơ chế chỉ đến này thì ta có một danh sách: Bắc, Đông, Nam, Tây. Hơn nữa để có danh sách này thì ta cần và chỉ cần giữ địa chỉ của Bắc.
Trong cài đặt, để một ô có thể chỉ đến ô khác ta cài đặt mỗi ô là một mẩu tin [record, struct] có hai trường: trường Element giữ giá trị của các phần tử trong danh sách; trường next là một con trỏ giữ địa chỉ của ô kế tiếp.Trường next của phần tử cuối trong danh sách chỉ đến một giá trị đặc biệt là NULL. Cấu trúc như vậy gọi là danh sách cài đặt bằng con trỏ hay danh sách liên kết đơn hay ngắn gọn là danh sách liên kết.
Hình II.3 Danh sách liên kết đơn
Để quản lý danh sách ta chỉ cần một biến giữ địa chỉ ô chứa phần tử đầu tiên của danh sách, tức là một con trỏ trỏ đến phần tử đầu tiên trong danh sách. Biến này gọi là chỉ điểm đầu danh sách [Header] . Để đơn giản hóa vấn đề, trong chi tiết cài đặt, Header là một biến cùng kiểu với các ô chứa các phần tử của danh sách và nó có thể được cấp phát ô nhớ y như một ô chứa phần tử của danh sách [hình II.3]. Tuy nhiên Header là một ô đặc biệt nên nó không chứa phần tử nào của danh sách, trường dữ liệu của ô này là rỗng, chỉ có trường con trỏ Next trỏ tới ô chứa phần tử đầu tiên thật sự của danh sách. Nếu danh sách rỗng thì Header->next trỏ tới NULL. Việc cấp phát ô nhớ cho Header như là một ô chứa dữ liệu bình thường nhằm tăng tính đơn giản của các giải thuật thêm, xoá các phần tử trong danh sách.
Ở đây ta cần phân biệt rõ giá trị của một phần tử và vị trí [position] của nó trong cấu trúc trên. Ví dụ giá trị của phần tử đầu tiên của danh sách trong hình II.3 là a1, Trong khi vị trí của nó là địa chỉ của ô chứa nó, tức là giá trị nằm ở trường next của ô Header. Giá trị và vị trí của các phần tử của danh sách trong hình II.3 như sau:
1 | a1 | HEADER 1 |
2 | a2 | 1 |
... | ... | ... |
n | an | [n-1] |
Sau phần tử cuối cùng | Không xác định | N và n->next có giá trị là NULL |
Như đã thấy trong bảng trên, vị trí của phần tử thứ i là [i-1], như vậy để biết được vị trí của phần tử thứ i ta phải truy xuất vào ô thứ [i-1]. Khi thêm hoặc xoá một phần tử trong danh sách liên kết tại vị trí p, ta phải cập nhật lại con trỏ trỏ tới vị trí này, tức là cập nhật lại [p-1]. Nói cách khác, để thao tác vào vị trí p ta phải biết con trỏ trỏ vào p mà con trỏ này chính là [p-1]. Do đó ta định nghĩa p-1 như là vị trí của p. Có thể nói nôm na rằng vị trí của phần tử ai là địa chỉ của ô đứng ngay phía trước ô chứa ai. Hay chính xác hơn, ta nói, vị trí của phần tử thứ i là con trỏ trỏ tới ô có trường next trỏ tới ô chứa phần tử ai Như vậy vị trí của phần tử thứ 1 là con trỏ trỏ đến Header, vị trí phần tử thứ 2 là con trỏ trỏ ô chứa phần tử a1, vị trí của phần tử thứ 3 là con trỏ trỏ ô a2, ..., vị trí phần tử thứ n là con trỏ trỏ ô chứa an-1. Vậy vị trí sau phần tử cuối trong danh sách, tức là ENDLIST, chính là con trỏ trỏ ô chứa phần tử an [xem hình II.3].
Theo định nghĩa này ta có, nếu p là vị trí của phần tử thứ p trong danh sách thì giá trị của phần tử ở vị trí p này nằm trong trường element của ô được trỏ bởi p->next. Nói cách khác p->next->element chứa nội dung của phần tử ở vị trí p trong danh sách.
Các khai báo cần thiết là
typedef ... ElementType; //kiểu của phần tử trong danh sách
typedef struct Node{
ElementType Element;//Chứa nội dung của phần tử
Node* Next; /*con trỏ chỉ đến phần tử kế tiếp trong danh sách*/
};
typedef Node* Position; // Kiểu vị trí
typedef Position List;
Trong khai báo trên, tại sao phải đặt tên kiểu Node trước khi đưa ra các trường trong kiểu đó?
Cách khai báo sau còn đúng không?
typedef struct
{
ElementType Element;
Node* Next;
} Node;
Tạo danh sách rỗng
Như đã nói ở phần trên, ta dùng Header như là một biến con trỏ có kiểu giống như kiểu của một ô chứa một phần tử của danh sách. Tuy nhiên trường Element của Header không bao giờ được dùng, chỉ có trường Next dùng để trỏ tới ô chứa phần tử đầu tiên của danh sách. Vậy nếu như danh sách rỗng thì trường ô Header vẫn phải tồn tại và ô này có trường next chỉ đến NULL [do không có một phần tử nào]. Vì vậy khi khởi tạo danh sách rỗng, ta phải cấp phát ô nhớ cho HEADER và cho con trỏ trong trường next của nó trỏ tới NULL.
void MakeNull_List[List *Header]{
[*Header]=[Node*]malloc[sizeof[Node]];
[*Header]->Next= NULL;
}
Kiểm tra một danh sách rỗng
Danh sách rỗng nếu như trường next trong ô Header trỏ tới NULL.
int Empty_List[List L]{
return [L->Next==NULL];
}
Xen một phần tử vào danh sách :
Xen một phần tử có giá trị x vào danh sách L tại vị trí p ta phải cấp phát một ô mới để lưu trữ phần tử mới này và nối kết lại các con trỏ để đưa ô mới này vào vị trí p. Sơ đồ nối kết và thứ tự các thao tác được cho trong hình II.4.
Hình II.4: Thêm một phần tử vào danh sách tại vị trí p
void Insert_List[ElementType X, Position P, List *L]{
Position T;
T=[Node*]malloc[sizeof[Node]];
T->Element=X;
T->Next=P->Next;
P->Next=T;
}
Tham số L [danh sách] trong chương trình con trên có bỏ được không? Tại sao?
Xóa phần tử ra khỏi danh sách
Hình II.5: Xoá phần tử tại vị trí p
Tương tự như khi xen một phần tử vào danh sách liên kết, muốn xóa một phần tử khỏi danh sách ta cần biết vị trí p của phần tử muốn xóa trong danh sách L. Nối kết lại các con trỏ bằng cách cho p trỏ tới phần tử đứng sau phần tử thứ p. Trong các ngôn ngữ lập trình không có cơ chế thu hồi vùng nhớ tự động như ngôn ngữ Pascal, C thì ta phải thu hồi vùng nhớ của ô bị xóa một các tường minh trong giải thuật. Tuy nhiên vì tính đơn giản của giải thuật cho nên đôi khi chúng ta không đề cập đến việc thu hồi vùng nhớ cho các ô bị xoá. Chi tiết và trình tự các thao tác để xoá một phần tử trong danh sách liên kết như trong hình II.5. Chương trình con có thể được cài đặt như sau:
void Delete_List[Position P, List *L]{
Position T;
if [P->Next!=NULL]{
T=P->Next; /*/giữ ô chứa phần tử bị xoá để thu hồi vùng nhớ*/
P->Next=T->Next; /*nối kết con trỏ trỏ tới phần tử thứ p+1*/ free[T]; //thu hồi vùng nhớ
}
}
Định vị một phần tử trong danh sách liên kết
Để định vị phần tử x trong danh sách L ta tiến hành tìm từ đầu danh sách [ô header] nếu tìm thấy thì vị trí của phần tử đầu tiên được tìm thấy sẽ được trả về nếu không thì ENDLIST[L] được trả về. Nếu x có trong sách sách và hàm Locate trả về vị trí p mà trong đó ta có x = p->next->element.
Position Locate[ElementType X, List L]{
Position P;
int Found = 0; P = L;
while [[P->Next != NULL] && [Found == 0]]
if [P->Next->Element == X] Found = 1;
else P = P->Next;
return P;
}
Thực chất, khi gọi hàm Locate ở trên ta có thể truyền giá trị cho L là bất kỳ giá trị nào. Nếu L là Header thì chương trình con sẽ tìm x từ đầu danh sách. Nếu L là một vị trí p bất kỳ trong danh sách thì chương trình con Locate sẽ tiến hành định vị phần tử x từ vị trí p.
Xác định nội dung phần tử:
Nội dung phần tử đang lưu trữ tại vị trí p trong danh sách L là p->next->Element Do đó, hàm sẽ trả về giá trị p->next->element nếu phần tử có tồn tại, ngược lại phần tử không tồn tại [p->next=NULL] thì hàm không xác định.
ElementType Retrieve[Position P, List L]{
if [P->Next!=NULL]
return P->Next->Element;
}
Hãy thiết kế hàm Locate bằng cách sử dụng các phép toán trừu tượng cơ bản trên danh sách?
c. So sánh hai phương pháp cài đặt
Không thể kết luận phương pháp cài đặt nào hiệu quả hơn, mà nó hoàn toàn tuỳ thuộc vào từng ứng dụng hay tuỳ thuộc vào các phép toán trên danh sách. Tuy nhiên ta có thể tổng kết một số ưu nhược điểm của từng phương pháp làm cơ sở để lựa chọn phương pháp cài đặt thích hợp cho từng ứng dụng:
- Cài đặt bằng mảng đòi hỏi phải xác định số phần tử của mảng, do đó nếu không thể ước lượng được số phần tử trong danh sách thì khó áp dụng cách cài đặt này một cách hiệu quả vì nếu khai báo thiếu chỗ thì mảng thường xuyên bị đầy, không thể làm việc được còn nếu khai báo quá thừa thì lãng phí bộ nhớ.
- Cài đặt bằng con trỏ thích hợp cho sự biến động của danh sách,
danh sách có thể rỗng hoặc lớn tuỳ ý chỉ phụ thuộc vào bộ nhớ tối đa của máy. Tuy nhiên ta phải tốn thêm vùng nhớ cho các con trỏ [trường next].
- Cài đặt bằng mảng thì thời gian xen hoặc xoá một phần tử tỉ lệ với số phần tử đi sau vị trí xen/ xóa. Trong khi cài đặt bằng con trỏ các phép toán này mất chỉ một hằng thời gian.
- Phép truy nhập vào một phần tử trong danh sách, chẳng hạn như PREVIOUS, chỉ tốn một hằng thời gian đối với cài đặt bằng mảng, trong khi đối với danh sách cài đặt bằng con trỏ ta phải tìm từ đầu danh sách cho đến vị trí trước vị trí của phần tử hiện hành.Nói chung danh sách liên kết thích hợp với danh sách có nhiều biến động, tức là ta thường xuyên thêm, xoá các phần tử.
Cho biết ưu khuyết điểm của danh sách đặc và danh sách liên kết?
d. Cài đặt bằng con nháy
Một số ngôn ngữ lập trình không có cung cấp kiểu con trỏ. Trong trường hợp này ta có thể "giả" con trỏ để cài đặt danh sách liên kết. Ý tưởng chính là: dùng mảng để chứa các phần tử của danh sách, các "con trỏ" sẽ là các biến số nguyên [int] để giữ chỉ số của phần tử kế tiếp trong mảng. Để phân biệt giữa "con trỏ thật" và "con trỏ giả" ta gọi các con trỏ giả này là con nháy [cursor]. Như vậy để cài đặt danh sách bằng con nháy ta cần một mảng mà mỗi phần tử xem như là một ô gồm có hai trường: trường Element như thông lệ giữ giá trị của phần tử trong danh sách [có kiểu Elementtype] trường Next là con nháy để chỉ tới vị trí trong mảng của phần tử kế tiếp. Chẳng hạn hình II.6 biểu diễn cho mảng SPACE đang chứa hai danh sách L1, L2. Để quản lí các danh sách ta cũng cần một con nháy chỉ đến phần tử đầu của mỗi danh sách [giống như header trong danh sách liên kết]. Phần tử cuối cùng của danh sách ta cho chỉ tới giá trị đặc biệt Null, có thể xem Null = -1 với một giả thiết là mảng SPACE không có vị trí nào có chỉ số -1.
Trong hình II.6, danh sách L1 gồm 3 phần tử : f, o ,r. Chỉ điểm đầu của L1 là con nháy có giá trị 5, tức là nó trỏ vào ô lưu giữ phần tử đầu tiên của L1, trường next của ô này có giá trị 1 là ô lưu trữ phần tử kế tiếp [tức là o]. Trường next tại ô chứa o là 4 là ô lưu trữ phần tử kế tiếp trong danh sách [tức là r]. Cuối cùng trường next của ô này chứa Null nghĩa là danh sách không còn phần tử kế tiếp.
Phân tích tương tự ta có L2 gồm 4 phần tử : w, i, n, d
Hình II.6 Mảng đang chứa hai danh sách L1 và L2
Khi xen một phần tử vào danh sách ta lấy một ô trống trong mảng để chứa phần tử mới này và nối kết lại các con nháy. Ngược lại, khi xoá một phần tử khỏi danh sách ta nối kết lại các con nháy để loại phần tử này khỏi danh sách, điều này kéo theo số ô trống trong mảng tăng lên 1. Vấn đề là làm thế nào để quản lí các ô trống này để biết ô nào còn trống ô nào đã dùng? một giải pháp là liên kết tất cả các ô trống vào một danh sách đặc biệt gọi là AVAILABLE, khi xen một phần tử vào danh sách ta lấy ô trống đầu AVAILABLE để chứa phần tử mới này. Khi xoá một phần tử từ danh sách ta cho ô bị xoá nối vào đầu AVAILABLE. Tất nhiên khi mới khởi đầu việc xây dựng cấu trúc thì mảng chưa chứa phần tử nào của bất kỳ một danh sách nào. Lúc này tất cả các ô của mảng đều là ô trống, và như vậy, tất cả các ô đều được liên kết vào trong AVAILABLE. Việc khởi tạo AVAILABLE ban đầu có thể thực hiện bằng cách cho phần tử thứ i của mảng trỏ tới phần tử i+1.
Các khai báo cần thiết cho danh sách
#define MaxLength ... //Chieu dai mang
#define Null -1 //Gia tri Null
typedef ... ElementType; /*kiểu của các phần tử trong danh sách*/
typedef struct{
ElementType Elements; /*trường chứa phần tử trong danh sách*/
int Next; //con nháy trỏ đến phần tử kế tiếp
} Node;
Node Space[MaxLength]; //Mang toan cuc
int Available;
Hình II.7: Khởi tạo Available ban đầu
Khởi tạo cấu trúc – Thiết lập available ban đầu
Ta cho phần tử thứ 0 của mảng trỏ đến phần tử thứ 1,..., phần tử cuối cùng trỏ Null. Chỉ điểm đầu của AVAILABLE là 0 như trong hình II.7
void Initialize[]{
int i;
for[i=0; i