SieuHoTro.Com
 
Home My Account Register Domain Transfer Domain Contact Us Whois Documentation
 
Forum Home Forum Home > Information Technology > The programming language > Turbo Pascal,Turbo C
  New Posts New Posts RSS Feed: SỰ SẮP XẾP
  FAQ FAQ  Forum Search   Register Register  Login Login
If this is your first visit, be sure to check out theForum by clicking the link above. You may have toregister before you can post: click the register link above to proceed. To start viewing messages, select the forum that you want to visit from the selection below.
ASG Vietnam

SỰ SẮP XẾP

 Post Reply Post Reply
Author
Poster View Drop Down
Guest
Guest
Avatar

Joined: 23 January 2008
Online Status: Offline
Posts: 378
  Quote Poster Quote  Post ReplyReply Direct Link To This Post Topic: SỰ SẮP XẾP
    Posted: 21 August 2008 at 20:02

SỰ SẮP XẾP.
(Sorting)
          Cũng như bài toán tìm kiếm, bài toán sắp xếp một nhóm các mục dữ liệu cũng rất quan trọng. Hai vấn đề này liên quan với nhau, có thể dùng một số thuật toán có hiệu quả chỉ khi dữ liệu được tổ chức trong một danh sách có thứ tự. Trong phần này chúng ta sẽ xét bài toán sắp xếp thứ tự một danh sách:
                             X1,X2,...,Xn
theo một trường khoá nào đó.
 
1. Một vài sơ đồ sắp xếp với độ phức tạp O(n2).
          Có 3 phương pháp sắp xếp đơn giản thông dụng:
          - lựa chọn đơn giản (simple selection sort),
          - sắp xếp nổi bọt (buble sort)
          - sắp xếp kiểu chèn (insertion sort).
  Cả 3 đều rất đơn giản, nhưng kiểu thứ ba được ưa dùng hơn, nhất là với danh sách nhỏ.
 
a) Sắp xếp bằng lựa chọn đơn giản.
          Sơ đò sắp xếp kiểu này là đi qua nhiều lần danh sách hay một phần của nó, và mỗi lần đi qua có một phần tử được sắp xếp theo đúng vị trí mong muốn.
1) THUẬT TOÁN SẮP XẾP KIỂU LỰA CHỌN ĐƠN GIẢN CHO
CÁC DANH SÁCH ĐƯỢC CÀI ĐẶT BẰNG MẢNG.
 
PROCEDURE  SAP_CHON_A ( Var A:mg; m:Integer);
    Var SmallPos,Smallest: Integer;
     BEGIN
        FOR I:=1 TO M-1 DO
         Begin
           SmallPos:=i;
           Smallest:=A[SmallPos];
           For j:=i+1 to m DO
              If (A[j] <Smallest) then
                   Smallest:=A[j];
           A[SmallPos]:=Smallest;
        End;
     END;
 
          Đối với các danh sách liên kết ta cũng làm như vậy chỉ cần thay các chỉ số i, j bằng các con trỏ chạy trong danh sách và danh sách con.
 
PROCEDURE  SAP_CHON_P( Var List:PointerType);
    Var
          Smallest:ElementType;
          P,Q,SmallPtr: PointerType;
  BEGIN
        P:=List;
        While P<> NIl do
              Begin     {Chọn phần tử nhỏ nhất trong danh sách con Xi toi Xn}
                   SmallPtr:=P;
                   Smallest:=SmallPtr^.Data;
                   Q:=P^.Next;
                   WHILE Q<>nil DO
                             Begin
                                      If (Q^.Data <Smallest) then
                                                Begin
                                                                   SmallPtr:=Q;
                                                                   Smallest:=Q^.Data;
                                                End;
                                      Q:=Q^.Next;
                             End;
                             { Chuyển phần tử nhỏ nhất đến đầu danh sách con}
                   SmallPtr^.Data:=P^.Data;
                   P^.Data:=Smallest;
                   P:=P^.Next;
               End;
     END;
         
          Lần đầu tiên đi qua danh sách, để tìm phần tử nhỏ nhất ta phải thực hiện n phép so sánh, lần thứ hai là n-1,...Như vậy tất cả là:
          (n-1) + (n-2)+... +2+1 = n(n-1)/2
lần so sánh, nghĩa là độ phức tạp của cách sắp xếp này là O(n2) trong mọi trường hợp.
 
b) Sắp xếp kiểu nổi bọt.
          Cách sắp xếp này cũng đi qua nhiều lần danh sách và các danh sách con. Mỗi lần đi qua từng cặp phần tử được so sánh và sắp lại (hoán vị) cho đúng thứ tự. Sau lần duyệt qua danh sách đầu tiên, phần tử “nhẹ nhất” nổi lên trên, t.l ở vị trí cuối danh sách. Quá trình đó lặp lại đối với danh sách con là danh sách của bước trước bỏ đi phần tử cuối cùng. Kết thúc chương trình khi đạt tới danh sách con có chỉ một phần tử. Ta có thể dùng thuật toán lặp kép hay đệ quy nhe sau:
 
PROCEDURE SAP_NOI_BOT( Var A:mg; m:Integer);
     Var tg:integer;
      begin
           if m>1 then
             begin
              For I:=1 to m-1 do
                 If A > A[i+1] then  {Đổi chỗ }
                    Begin
                        TG:=A; A:=A[i+1]; A[i+1]:=TG;
                    End;
             Sap_noi_Bot(A,m-1);
            end;
      end;
 
          Trường hợp tồi nhất trong cách sắp nổi bọt là khi danh sách có thứ tự ngược lại. Lần đầu thực hiện n-1 phép so sánh và hoán vị, lần 2 là n-2,...Vì vậy tổng cộng có:
                   (n-1) + (n-2)+... +2+1 = n(n-1)/2
lấn so sánh, hay độ phức tạp của thuật toán là O(n2).
 
b) Sắp xếp kiểu chèn.
          Thuật toán sắp kiểu chèn được xây dựng trên cơ sở chèn phần tử mới vào một danh sách đã được sắp thứ tự để nhận được danh sách mới cũng có thứ tự đúng. Phương pháp này tương tự như khi một người chơi tú-lơ-khơ, mỗi lần nhận được con bài được chia, anh ta chèn đúng theo thứ tự định trướcvào các con bài đã ở trên tay anh ta (không tính đến màu và chất).
          Thuật toán dưới đây mô tả thủ tục chèn này vào danh sách được lưu trữ trong mảng. Trong giai đoạn thứ i, phần tử Xi được chèn vào đúng vị trí của nó trong danh sách các phần tử X1,X2,..,Xi-1 đã dược sắp thứ tự. Ta thực hiện điều này bằng cách so sánh Xi với các phần tử này bắt đầu từ bên phải và dịch sang bên trái khi cần thiết. Vị trí 0 của mảng được giả sử nhận giá trị câm nào đó (kí hiệu là -¥ ) nhỏ hơn mọi phần tử của danh sách để tránh “ rơi sang bên trái “ khỏi danh sách.
 
PROCEDURE  XEPCHEN( Var A:mg; m:Integer);
        Begin
           for i:=2 to M do
              Begin
                ptchen:=A;
                if (ptchen <A[i-1]) then
                  Begin
                      j:=i-1;
                      While (ptchen < A[j])  Do
                         begin
                           a[j+1]:=a[j];
                           J:=j-1;
                        end;
                     A[j+1]:=ptchen;
                  End;
              End;
       End;
 
Trường hợp tồi tệ nhất là khi danh sách có thứ tự ngược lại. Chèn X[2] cần 2 lần so sánh (với  X[1] và X[0] ), chèn X[3] cần 3 lần,...Tổng số là:
                  
vậy thời gian tính là O(n2).
          Có thể áp dụng cách sắp xếp kiểu chèn cho các danh sách liên kết.
          Nói chung cả 3 kiểu sắp xếp trên đều không tốt lắm và không có gì khảng định thuật toán nào được ưu tiên hơn. Tuy nhiên do số lần hoán vị ít mà sắp xếp kiểu chèn được ưa chuộng hơn cách lựa chọn và cách nổi bọt, nhất là đối với danh sách nhỏ (có chừng 15 - 20 phần tử) và các danh sách đã được sắp một phần.
 
2. Khối (Heap) và HeapSort.
          Ba kiểu sắp xếp trên đều có độ phức tạp là O(n2) trong trường hợp tồi và trường hợp trung bình. Còn có các thuật toán khác với độ phức tạp là O(n.log2 n), t.l hiệu quả hơn các thuật toán trên trong đa số trường hợp. Ta sẽ mô tả một thuật toán như thế, gọi là HeapSort, nó là biến thức của kiểu chọn đơn giản. Để dùng được thuật toán này cần phải tổ chức lại dữ liệu theo một cấu trúc gọi là khối (Heap).
         
a)Định nghĩa khối (Heap) .
          Cũng như cây tìm kiếm nhị phân (BST), khối là loại cây nhị phân đặc biệt. Nó khác với BST ở hai điểm:
          1. Nó là đầy đủ, nghĩa là các lá nằm nhiều nhất ở hai mức liên tiếp nhau, và các lá ở mức thấp nằm ở vị trí bên trái nhất.
          2. Giá trị của mục dữ liệu ở nút bố lớn hơn giá trị của mục tương ứng ở các nút con của nó.
 
          Để cài đặt khối ta có thể dùng cấu trúc liên kết giống như BST, nhưng thường người ta dùng mảng để việc tìm kiếm có hiệu quả hơn. Ta đánh số các nút trong khối  từ trên ( gốc) xuống dưới, ở mỗi mức các nút được đánh số từ trái qua phải. Dữ liệu ở nút thứ i được lưu trữ tại vị trí thứ i của mảng. Tính đầy đủ của Khối đảm bảo các mục dữ liệu được lưu trữ trong các vị trí liên tiếp ở đầu mảng .
9
                                                1
                                     
                                    2                       3
                                                                                                         
 

                              4          5              6         7            
 
 
Một mảng Heap như thế có thể được khai báo như sau:
 
          CONST      
                   HeapLimit = . . . {giới hạn số nút trong khối}
          TYPE
                   ElementType= . . , {Kiểu của mục dữ liệu }
                   HeapType=ARRAY[1.. HeapLimit] OF ElementType;
          VAR
                   Heap: HeapType;
 
          Các mục trong khối ở trên được lưu trữ như sau:
                   Heap[1]=9, Heap[2]=8, Heap[3]=4,
                   Heap[4]=6, Heap[5]=2, Heap[6]=3;
          Chú ý. Bằng cách cài đặt như vậy, các nút con của nút i sẽ nằm ở vị trí thứ 2i và 2i+1, và nút bố của nút j sẽ là nằm ở vị trí  ( j div 2).
 
          Gỉa sử ta cần sắp xếp n phần tử theo thứ tự tăng dần (giảm dần). Trước tiên ta cài đặt n phần tử này thành cây nhị phân đầy đủ. Nếu có một thuật toán chuyển cây này thành khối thì khi đó phần tử lớn nhất sẽ nằm ở gốc của cây, tức là phần tử đầu tiên của mảng. Đổi chỗ phần tử này cho phần tử cuối cùng. Tiếp theo ta lại áp dụng thuật toán này cho cây con gồm (n-1) phần tử đầu tiên. Phần tử lớn nhất lại để ở vị trí ( n-1) của mảng. Qúa trình này tiếp tục đến khi cây con chỉ có 2 nút, ta chỉ cần hoán vị là nhận được danh sách theo thứ tự tăng dần.
 
b) Thuật toán hoán-vị-xuống (SwapDown).
          Trước tiên ta xét thuật toán chuyển cây nhị phân đầy đủ thành khối trong trường hợp giản đơn nhất, khi cây đã gần như là khối, t.l cả hai cây con từ nút gốc đã là các khối ( nhưng bản thân cây chưa là khối). Ví dụ:
 
 2
                            
 9
 4
 
 
 

                            
 
 1
 5
 3
 
 

 3
 5
 1
 4
 2
 9
          Cây này đầy đủ và cả hai cây con là các khối , lý do để nó không là khối vì giá trị của mục gốc lại nhỏ hơn ở một trong nút con của nó. Bước đầu tiên ta hoán vị mục ở gốc với nút con lớn hơn,  ở đây là nút con trái.
 
 
 
 
 
 
 
 
 
 
 
          Điều này đảm bảo cho mục ở gốc lớn hơn cả hai nút con, và một trong hai cây con, trường hợp này là cây phải, vẫn là khối. Cây con kia có thể là khối và cũng có thể là không. Nếu nó cũng là khối thuật toán chấm dứt. Nếu nó không là khối thì các cây con của nó cũng là khối, t.l có thể áp dụng thuật toán hoán-vị-xuống cho cây con này. Quá trình này lặp lại chi tới khi cả hai cây con ở nút đang xét là khối, hoặc tới cây chỉ có lá. Nếu cây này chưa là khối ta chỉ cần hoán vị gốc với lá lớn là xong. Thuật toán kết thúc.
         
Thuật toán trên được cài đặt như sau:
PROCEDURE  SwapDown(VAR Heap: HeapType;r,n:Integer);
      {Input: Heap la cay con day du voi cac nut tu r toi n, trong do r la nut
                 goc. Cac cay con ben phai va ben trai cua no da tao thanh khoi.
       OutPut: Heap thanh KHOI, t.l co phan tu o nut r lon nhat  }
 
        VAr
          Child:Integer;
          Done:Boolean;
        PROCEDURE  Interchange (VAR A,B :ElementType);
          VAR
              Temp:ElementType;
          Begin
                   Temp:=A;
                   A:=B;
                   B:=Temp;
           End; 
 
        BEGIN                   { cua SwapDown}
           Done:=False;
           Child:=2*r;
           WHILE (NOT DONE) and (Child<=n) DO
              Begin
                 { Tim con lon nhat }
                 IF Child <n then
                   IF (Heap[Child] < Heap[Child+1] ) then Child:=Child+1;
   { Hoan vi nut con lon nhat neu can roi chuyen xuong cay con tiep theo}
                 IF Heap[r]<Heap[Child] THEN
                    Begin
                          Interchange(Heap[r],Heap[Child]);
                          r:=Child;
                          Child:=2*r;
                    End
                   ELSE
                     Done:=True;
              End; { of While}
        END;
 
c) Thuật toán Heapify.
          Đói với bài toán tổng quát chuyển cây nhị phân đầy đủ thành khối, ta bắt đầu từ nút cuối cùng không phải là lá ( nút có vị trí là n div 2), dùng thuật toán SwapDown để chuyển cây con này thành khối. Tiếp theo chuyển lên nút trước đó và lại áp dụng SwapDown, ..Cuối cùng ta đạt tới nút gốc của cây. Thuật toán chuyển cây đầy đủ sang khối như sau:
 
PROCEDURE  Heapify(VAR Heap: HeapType; n:Integer);
        { Chuyen cay nhi phan day du luu o vi tri 1..n cua bang Heap
         thanh khoi, tuc la co phan tu dau tien la lon nhat.}
      Var
         r:Integer;
      Begin
         FOR r:= (n div 2) DOWNTO 1 DO   {Bat dau tu nut cuoi khong la la}
             SwapDown (Heap,r,n);
      End;
 
d) Thuật toán Heapsort.
          Để sắp xếp các phần tử trong mảng X theo thứ tự tăng dần được tiến hành như sau:
          1. xem X như cây nhị phân và dùng Heapify để chuyển nó thành khối.
          2. FOR I= n div 2 TO 2  làm các việc sau;
                   a. Hoán vị X[1] và X để đưa phần tử lớn nhất trong danh sách
                              con đến cuối của danh sách ấy.
                   b. Dùng thuật toán SwapDown để chuyển cây nhị phân từ nút 1
                              tới nút i-1 thành khối.
 
PROCEDURE HeapSort (VAR X: HeapType; n:Integer);
          { Sắp xếp mảng X gồm n phần tử theo thứ tự tăng dần}
    VAR
        I:Integer;
    BEGIN                                    
         Heapify(x,n);
         FOR I:=n DOWNTO 2 DO
           Begin
            Interchange(X[1],X);
            SwapDown(X,1,i-1);       {Bien cay con tu nut 1 toi i-1 thanh khoi}
           End;
    END;                                            
 

  Share Topic     
Back to Top
Poster View Drop Down
Guest
Guest
Avatar

Joined: 23 January 2008
Online Status: Offline
Posts: 378
  Quote Poster Quote  Post ReplyReply Direct Link To This Post Posted: 21 August 2008 at 20:03
3. Thuật toán sắp xếp kiểu Quicksort.
          Trong các cách sắp xếp trước, ý tưởng cơ bản là chọn phần tử nhỏ nhất hay lớn nhất của danh sách con nào đó của danh sách đã cho, rồi đặt vào đúng vị trí của nó.
          Bây giờ ta xét sơ đồ sắp xếp khác gọi là Quicksort nó cũng chọn một mục và định vị mục ấy, nhưng không nhất thiết phải là phần tử nhỏ nhất hay lớn nhất. Ta sẽ định vị mục này bằng cách sắp xếp lại danh sách con sao cho tất cả các phần tử  bên trái là nhỏ hơn hay bằng nó, còn tấ cả các phần tử bên phải lớn hơn nó. Như vậy danh sách ( con) được chia làm hai danh sách con nhỏ hơn ( cháu) và bằng cách đó các danh sách con này lại được sắp xếp một cách độc lập.  Phương pháp “chia để trị”  dẫn đến thuật toán sắp xếp đệ quy.
          Sơ đồ này sẽ hoạt động tốt nhất nếu nếu phần tử đựoc chọn không là phần tử biên mà là một giá trị nào đó ở giữa danh sách.
          Ví dụ ta xét danh sách sau:
                   75, 70, 65, 84, 98, 78, 100, 93, 55, 61, 81, 68
           Để đơn giản ta chọn phần tử đầu tiên là 75 để xác định đúng vị trí của nó, tức là các số 70, 65, 55, 61và 68 đứng bên trái 75 còn 84, 98, 78, 100, 93 và 81 ở bên phải, thứ tự của các danh sách con này ta không quan tâm.
          Thực hiện hai lần tìm kiếm, một là tìm các số nhỏ hơn hay bằng 75 từ bên phải, và sau đó là tìm phần tử lơn hơn 75 từ bên trái.
                  
          75,  70,  65,  84,  98,  78,  100,  93,  55,  61,  81,  68
 

          Sau khi hoán vị hai phần tử này ta lại tìmm phân tử nhơ hơn hay bằn 75 từ bên phải và phần tử lớn hơn 75 từ bên trái.
 

          75,  70,  65,  68,  98,  78,  100,  93,  55,  61,  81,  84
 

          Các phần tử 61 và 98 lại được hoán vị, cứ tiếp tục quá trình này ta đI đến tình cảnh sau:
 

          75,  70,  65,  68,  61, 55,  100,  93,  78,  98,   81,  84
 
 

Hai con trỏ trái phải gặp nhau, báo hiệu kết thúc thuật toán. Bây giờ ta chỉ việc hoán vị 75 với 55 là xong:
 
          55,  70,  65,  68,  61, 75100,  93,  78,  98,   81,  84
 
          Đó chính là nội dung của thủ tục SPLIT dưới đây:
 
PROCEDURE SPLIT (Var X:MG;Low,High:Integer;Var Pos:Integer);
          {Input: X mang co chi so dau la Low va chi so cuoi la High
                   OutPut: Pt dau duoc dat dung vi tri theo thu tu tai Pos }
    Var
       Item: ElementType;
       Left,Right:Integer;          {chi so trai, phai de tim vi tri cho Item }
    Begin
       Item:=X[Low];               { Chon Item la pt dau }
       Left:=Low;
       Right:=High;
       While Left<Right do  { hai chi so chua trung nhau }
           Begin
               While X[Right] >Item do
                   Right:=Right-1; { dung tai pt nho hon Item}
               While (Left< Right) and (X[Left] <= Item) do
                    Left:=Left+1;     { dung tai pt lon hon hay bang Item}
          
                   { Hoan vi hai pt neu hai con tro chua gap nhau}
               If Left< Right  then  Interchange(X[Left],X[Right]);
           End; {of while}
        Pos:=Right;
        Interchange(X[Low],X[Pos]); {Dat pt dau vao Pos tim duoc}
   End;
 
          Bây giờ ta có thể viết được thủ tục đệ quy Quicksort như sau. Nếu số phần tử nhỏ hơn hay bằng 1 thì không cần phải làm gì. Ngược lại dùng SPLIT chia thành 2 danh sách con, và sau đó lại dùng đệ quy Quicksort cho 2 danh sách đó.
 
PROCEDURE QUICKSORT( Var X: MG; Low, High: Integer);
        { sap xep cac pt cua mang theo thu tu, bang de quy}
     Var
        Pos:Integer;
     Begin
       If (0<High-Low) then                {danh sach nhieu hon mot muc}
          Begin
               Split(X,Low,High,Pos);           {chia thanh 2 ds con}
               QuicKSort(X,Low,Pos-1);  {Sap xep danh sach con trai}
               QuicKSort(X,Pos+1,High); {Sap xep danh sach con phai}
            End;
     End;
 
          Chương trình đầy đủ ứng dụng kiểu Quicksort với việc chọn phần tử trung bình là phần tử giữa của 3 pần tử Low , High và Mid, và đối với danh sách ít hơn 20 phần tử thì dùng xếp chèn, khi số phần tử nhiều hơn mới dùng Quicksort để tăng thêm hiệu quả.
 
PROGRAM   QUICK_SORT;
   Uses Crt;
   CONST MAXSIZE=100;
   Type
     ElementType= Real;
     MG = ARRAY[1..MAXSIZE]  OF ElementType;
 
   Var N,i: Integer;
       DANHSACH:MG;
 
   PROCEDURE  Interchange (VAR A,B :ElementType);
       VAR
          Temp:ElementType;
       Begin
          Temp:=A;
          A:=B;
          B:=Temp;
       End;
  PROCEDURE  DOC(Var X: MG);
        { Tao mang co gia tri thuc ngau nhien }
    BEGIN
       ClrScr;
      Write('doc n = '); Readln(n);
      FOR I:=1 TO n DO
          X:=-10*Random+Random(n);
     END;
 
 PROCEDURE  XEPCHEN( Var A: MG; m:Integer);
    Var
      ptchen: ElementType;
      J,I:Integer;
        Begin
           for I:=2 to M do
              Begin
                ptchen:=a;
                if (ptchen <a[i-1]) then                  {tim vi tri chen}
                  begin
                    J:=i-1;
                    while (ptchen <a[j]) and (j>=1) do
                       begin
                          a[j+1]:=a[j];              {dich sang phai tao cho trong}
                          J:=j-1;
                       end;
                    a[j+1]:=ptchen;
                  end;
              End;
        end;
 
   FUNCTION  MID_OF_THREE (A,B,C: ElementType):ElementType;
     Var Y: MG;
     Begin
        Y[1]:=a;y[2]:=B;y[3]:=c;
        xepchen(Y,3);
        mid_of_three:=y[2];
     End;
 
PROCEDURE  SPLIT ( Var X:MG; Low,High:Integer;Var Pos:Integer);
      {Input: X mang co chi so dau la Low va chi so cuoi la High
                   OutPut: Dat pt dau vao dung vi tri theo thu tu tai Pos }
    Var
       Item,tb: ElementType;
       Mid,Left,Right:Integer; {chi so trai, phai de tim vi tri cho Item }
 
    Begin
       { Chon Item la pt trung binh cua 3 pt Low,High va Mid de 2
         danh sach con gan bang nhau, nang hieu qua Quicksort}
       Mid:= (Low+High) div 2;
       Item:= Mid_of_three (X[Low],X[Mid],X[High]);
       Item:=X[Low];             { Dat Item la pt dau }
       Left:=Low;
       Right:=High;
       While Left<Right do  { hai chi so chua trung nhau }
         Begin
           While X[Right] >Item do
                   Right:=Right-1; { chi vao  pt nho hon Item}
           While (Left< Right) and (X[Left] <= Item) do
             Left:=Left+1;          { chi vao pt lon hon hay bang Item}
           { Hoan vi hai pt neu hai con tro chua gap nhau}
 
           If Left< Right then  Interchange(X[Left],X[Right]);
         End; {of while}
         Pos:=Right;
         Interchange(X[Low],X[Pos]);
   End; {Split}
 
   PROCEDURE QUICKSORT( Var X:MG; Low,High:Integer);
        { sap xep cac pt cua mang theo thu tu, bang de quy}
     Var
        Pos:Integer;
     Begin
       If (0<High-Low) then                   {danh sach nhieu hon mot muc}
         If (High-Low<20) then               {danh sach nho hon 20 muc }
                  XEPCHEN(X,High-Low)
           Else                  {danh sach lon dung Quicksort}
            Begin
               Split(X,Low,High,Pos);                 {chia thanh 2 ds con}
               QuicKSort(X,Low,Pos-1);            {Sap xep ds con trai}
               QuicKSort(X,Pos+1,High);           {Sap xep ds con phai}
            End;
     End;                                                       {QuickSort}
 
 
 PROCEDURE  HIEN( X:MG);
  BEGIN
   FOR I:=1 TO n DO
            Write(X:6:2,'  ');
        Writeln;
  END;
 
 BEGIN
    ClrScr;
    DOC (danhsach);
    HIEN(DANHSACH);
    Quicksort(danhsach,1,n);
    HIEN(DANHSACH);
    Readln;
END.
 
          Nếu Quicksort được dùng nhiều nên viết dưới dạng lặp.
 

Back to Top
 Post Reply Post Reply

Forum Jump Forum Permissions View Drop Down



This page was generated in 0.156 seconds.
[Free Express Edition]
Copyright ©2001-2009 Web Wiz
Support: raovatphanmem Support: Info hanoi software
Online(s): 66.
Visitors Counter:37420393, AVERAGE/day(3561) is: 10508
Begin count is day 02/16/2009

You are browsing this site with: CCBot/2.0 (https://commoncrawl.org/faq/)
Your IP address is: 54.234.13.175
The DNS lookup of the IP address is: 54.234.13.175
The method used to call the page: GET
The server's domain name: sieuhotro.com
The link
BaoKyNam Viêm gan b Thẩm mỹ viện Hoa Kỳ