Giáo trình phân tích khả năng sử dụng thuật toán hiệu chỉnh trong đường chạy lập trình p3 pptx

Nếu việc sắp xếp thành công hàm trả về giá trị 1, trong trường hợp ngược lại do có lỗi khi thực hiện các thao tác trên tập tin hàm trả về giá trị –1.. Hàm sử dụng các hàm FileDistribute,

Trang 1

//Chép phần run còn lại trong Ft1 về Fd B17: IF (K1 > L) //Đã chép hết phần run còn lại trong Ft1 về Fd Lặp lại B6

B18: fwrite(&a1, sizeof(T), 1, Fd) B19: K1++

B20: IF (feof(Ft1)) //Đã chép hết các phần tử trong Ft1 Thực hiện B23

B21: fread(&a1, sizeof(T), 1, Ft1) B22: Lặp lại B17

//Chép các phần tử còn lại trong Ft2 về Fd B23: fwrite(&a2, sizeof(T), 1, Fd)

B24: IF (feof(Ft2)) Thực hiện Bkt B25: fread(&a2, sizeof(T), 1, Ft2) B26: Lặp lại B23

//Chép các phần tử còn lại trong Ft1 về Fd B27: fwrite(&a1, sizeof(T), 1, Fd)

B28: IF (feof(Ft1)) Thực hiện Bkt B29: fread(&a1, sizeof(T), 1, Ft1) B30: Lặp lại B27

Bkt: Kết thúc

- Thuật toán sắp xếp trộn thẳng:

B1: L = 1 //Chiều dài ban đầu của các run B2: IF (L ≥ N) //Tập tin Fd chỉ còn 01 run Thực hiện Bkt

B3: Phân_Phối(DataFile, DataTemp1, DataTemp2, L) B4: Trộn(DataTemp1, DataTemp2, DataFile, L) B5: L = 2*L

B6: Lặp lại B2 Bkt: Kết thúc

- Cài đặt thuật toán:

Hàm FileStraightMergeSort có prototype như sau:

int FileStraightMergeSort(char * DataFile);

Hàm thực hiện việc sắp xếp các phần tử có kiểu dữ liệu T trên tập tin có tên DataFile theo thứ tự tăng dựa trên thuật toán sắp trộn trực tiếp Nếu việc sắp xếp thành công hàm trả về giá trị 1, trong trường hợp ngược lại (do có lỗi khi thực hiện các thao tác trên tập tin) hàm trả về giá trị –1 Hàm sử dụng các hàm FileDistribute, FileMerge có prototype và ý nghĩa như sau:

int FileDistribute(char * DataFile, char * DataTemp1, char * DataTemp2, int L);

Hàm thực hiện việc phân phối luân phiên các đường chạy có chiều dài L trên tập tin dữ liệu có tên DataFile về cho các tập tin tạm thời có tên tương ứng là DataTemp1

w

Trang 2

và DataTemp2 Hàm trả về giá trị 1 nếu việc phân phối hoàn tất, trong trường hợp ngược lại hàm trả về giá trị –1

int FileMerge(char * DataTemp1, char * DataTemp2, char * DataFile, int L);

Hàm thực hiện việc trộn từng cặp tương ứng các đường chạy với độ dài L trên hai tập tin tạm thời có tên DataTemp1, DataTemp2 về tập tin dữ liệu ban đầu có tên DataFile thành các đường chạy có chiều dài 2*L Hàm trả về giá trị 1 nếu việc trộn hoàn tất, trong trường hợp ngược lại hàm trả về giá trị –1

Cả hai hàm này đều sử dụng các hàm Finished để làm nhiệm vụ “dọn dẹp” (đóng các tập tin đã mở, hủy vùng nhớ đã cấp phát, …) và trả về một giá trị nguyên để kết thúc Các hàm Finished có prototype như sau:

int Finished (FILE * F1, int ReturnValue);

int Finished (FILE * F1, FILE * F2, int ReturnValue);

int Finished (FILE * F1, FILE * F2, FILE * F3, int ReturnValue);

Nội dung của các hàm như sau:

int Finished (FILE * F1, int ReturnValue) { fclose (F1);

return (ReturnValue);

} //========================================================

int Finished (FILE * F1, FILE * F2, int ReturnValue) { fclose (F1);

fclose (F2);

} //========================================================

int Finished (FILE * F1, FILE * F2, FILE * F3, int ReturnValue);

{ fclose (F1);

fclose (F2);

fclose (F3);

} //========================================================

int FileDistribute(char * DataFile, char * DataTemp1, char * DataTemp2, int L) { FILE * Fd = fopen(DataFile, “rb”);

if (Fd == NULL) return (-1);

FILE * Ft1 = fopen(DataTemp1, “wb”);

if (Ft1 == NULL) return(Finished(Fd, -1));

FILE * Ft2 = fopen(DataTemp2, “wb”);

if (Ft2 == NULL) return(Finished(Fd, Ft1, -1));

T a;

w

Trang 3

int SOT = sizeof(T);

while (!feof(Fd)) { for(int K = 0; K<L && !feof(Fd); K++) { int t = fread(&a, SOT, 1, Fd);

if (t < 1) { if (feof(Fd)) break;

return (Finished(Fd, Ft1, Ft2, -1));

}

t = fwrite(&a, SOT, 1, Ft1);

if (t < 1) return(Finished(Fd, Ft1, Ft2, -1));

} for(K = 0; K<L && !feof(Fd); K++) { int t = fread(&a, SOT, 1, Fd);

if (t < 1) { if (feof(Fd)) break;

}

t = fwrite(&a, SOT, 1, Ft2);

if (t < 1) return(Finished(Fd, Ft1, Ft2, -1));

} } return (Finished(Fd, Ft1, Ft2, 1));

} //========================================================

int FileMerge(char * DataTemp1, char * DataTemp2, char * DataFile, int L) { FILE * Ft1 = fopen(DataTemp1, “rb”);

if (Ft1 == NULL) return (-1);

FILE * Ft2 = fopen(DataTemp2, “rb”);

if (Ft2 == NULL) return (Finished(Ft1, -1);

FILE * Fd = fopen(DataFile, “wb”);

if (Fd == NULL) return (Finished(Ft1, Ft2, -1);

int K1 = 0, K2 = 0;

T a1, a2;

int SOT = sizeof(T);

if (fread(&a1, SOT, 1, Ft1) < 1) return (Finished(Fd, Ft1, Ft2, -1));

if (fread(&a2, SOT, 1, Ft2) < 1) return (Finished(Fd, Ft1, Ft2, -1));

while (!feof(Ft1) && !feof(Ft2)) { if (a1 <= a2)

w

Trang 4

{ int t = fwrite(&a1, SOT, 1, Fd);

if (t < 1) return (Finished(Fd, Ft1, Ft2, -1));

K1++;

t = fread(&a1, SOT, 1, Ft1);

if (t < 1) { if (feof(Ft1)) break;

return (Finished (Fd, Ft1, Ft2, -1));

}

if (K1 == L) { for (; K2 < L && !feof(Ft2); K2++) { t = fwrite(&a2, SOT, 1, Fd);

} }

if (feof(Ft2)) break;

}

if (K1 == L && K2 == L) K1 = K2 = 0;

} else { int t = fwrite(&a2, SOT, 1, Fd);

K2++;

}

if (K2 == L) { for (; K1 < L && !feof(Ft1); K1++) { t = fwrite(&a1, SOT, 1, Fd);

w

Trang 5

} }

if (feof(Ft1)) break;

}

if (K1 == L && K2 == L) K1 = K2 = 0;

} } while (!feof(Ft1)) { int t = fwrite(&a1, SOT, 1, Fd);

} } while (!feof(Ft2)) { int t = fwrite(&a2, SOT, 1, Fd);

} } return (Finished(Fd, Ft1, Ft2, 1));

} //========================================================

int FileStraightMergeSort(char * DataFile) { int Fhd = open(DataFile, O_RDONLY);

if (Fhd < 0) return (-1);

int N = filelength(Fhd)/sizeof(T);

close(Fhd);

if (N < 2) return (1);

int L = 1;

char * Temp1 = “Data1.Tmp”;

char * Temp2 = “Data2.Tmp”;

while (L < N) { if (FileDistribute(DataFile, Temp1, Temp2, L) == -1)

w

Định dạng
Số trang	5
Dung lượng	103,08 KB