31_tétel
 Beillesztéses rendezés tétele
(Algoritmus, használati lehetőségek, példák a használatra)

Példa:Adott az X sorozat (3,5,2,8,11,7) rendezzük sorba a kártyalapok
rendezésének megfelelő eljárással.
|   |Leíró nyelven megfogalmazva        |Pascal nyelven megfogalmazva      |
|[pi|Algoritmus                         |Program Kivalogatas;              |
|c] | Konstans                          |Const N=6;                        |
|   |      N=6;                         |      X:array[1..N] of byte=      |
|   |      X:array[1..N] of byte=       |           (3,5,2,8,11,7);        |
|   |                                   |Var   K,I:Byte;                   |
|   |(3,5,2,8,11,7);                    |      Seged:Byte;                 |
|   | Változó                           |                                  |
|   |     K, I : egész                  |                                  |
|   |     Segéd : egész                 |                                  |
|[pi| Algoritmus törzs                  |Begin                             |
|c] |   K:=1                            |   K:=1;                          |
|   |   Ismételd mialatt K<=N           |    While K<=N do                 |
|   |        Seged:=X[K]                |    Begin                         |
|   |        I:=K-1                     |        Seged:=X[K];              |
|   |       Ismételd                    |        I:=K-1;                   |
|   |mialatt(I>=1)És(Seged<=X[I])       |        While                     |
|   |            X[I+1]:=X[I]           |(I>=1)And(Seged<=X[I]) Do         |
|   |            I:=I-1                 |        Begin                     |
|   |        Ismétlés vége              |            X[I+1]:=X[I];         |
|   |        X[I+1]:=Seged              |            I:=I-1;               |
|   |        K:=K+1                     |        End;                      |
|   |    Ismétlés vége                  |        X[I+1]:=Seged;            |
|   |End.                               |        K:=K+1;                   |
|   |                                   |    End;                          |
|   |                                   |End.                              |

 Rendezés egyszerű cserés módszerrel
    Közös jellemző: Növekvő sorrend esetén, vesszük az első helyen álló
elemet. Az utána következőkhöz hasonlítjuk. Ha kisebbet találunk, akkor
azzal kicseréljük, majd ezzel folytatjuk az összehasonlítást. Az első
ciklus eredményeként az első helyen a legkisebb elem áll majd. A következő
ciklusokban egy-egy helyre találjuk meg a megfelelőt. Végül az utolsó
helyre a legnagyobb marad.
Írj programot, mely egy rendezetlen számtömböt az egyszerű cserés
módszerrel növekvő  sorba rendez!
|Feladatvizsgálat:                                                       |
|1. Bemenő adatok:                                                       |
|  n: a tömb elemeinek száma, byte típusú.                               |
|  a: ebben a feladatban integer elemeket tartalmazó tömb, de ugyanígy   |
|működik más típusokkal is.                                              |
|2. Kimenő adatok:                                                       |
|  a: ugyanaz a tömb, csak rendezetten.                                  |
|3. Matematikai eszközök: reláció                                        |
|4. Belső változók:                                                      |
|  i, j: futóváltozók, miközben az i számon tartja, hogy sorban, hányadik|
|elem helyére keressük a mögötte állókból a legkisebbet, addig a j       |
|vágigfut a mögötte állókon, hogy a program kisebbet keressen.           |
|  c: a cserékhez szükséges segédváltozó.                                |
|5. A program logikája: ha talál a soron következő, megfigyelés alatt    |
|álló elemnél kisebbet az utána következők között,  azzal rögtön         |
|kicseréli a vizsgált elemet. Így minden körben eggyel későbbi elem a    |
|végleges helyére kerül.                                                 |
|Folyamatábra:                                                           |
|[pic]                                                                   |
|Program:                                                                |
|                                                                        |
|procedure cse_rendez_8a(n:byte; var a:tomb);                            |
|var i,j :byte;                                                          |
|     c:integer;                                                         |
|begin                                                                   |
|    {Egyszerű cserés rendezés: ha találunk az elem után egy kisebbet,   |
|     azzal rögtön kicseréljük, így az első körben az első helyre        |
|     megtaláljuk a legkisebbet, stb.}                                   |
|  for i:=1 to n-1 do                                                    |
|  for j:=i+1 to n do                                                    |
|  if a[i]>a[j] then begin c:=a[i]; a[i]:=a[j]; a[j]:=c; end;            |
|end;                                                                    |
|                                                                        |