Algoritmusok

Az algoritmusokban N-nel jelöltük a tömbelemek számát.

Érték hozzárendelése sorozathoz

Összegezés
Az algoritmus meghatározza a tömb elemeinek az összegét (11-1. példa). 
Eljárás
  Összeg := 0
  Ciklus I := 1-től N-ig
    Összeg := Összeg + Tömb(I)
  Ciklus vége
  Ki: Összeg
Eljárás vége
Döntés
A döntési algoritmus meghatározza, hogy van-e legalább egy adott tulajdonságú elem a tömbben (11-2. példa). 
Eljárás
  I := 1
  Ciklus amíg Tömb(I) nem adott tulajdonságú És I < N
    I := I + 1
  Ciklus vége
  Van := Hamis
  Ha Tömb(I) adott tulajdonságú Akkor
    Van := Igaz
  Elágazás vége
  Ki: Van
Eljárás vége
Lineáris keresés
A keresési algoritmus meghatározza a tömb első, megadott tulajdonságú elemének indexét (11-2. példa). 
Eljárás
  I := 1
  Ciklus amíg Tömb(I) nem adott tulajdonságú És I < N
    I := I + 1
  Ciklus vége
  Van := Hamis
  Ha Tömb(I) adott tulajdonságú Akkor
    Van := Igaz
    KeresettIndex = I
  Elágazás vége
  Ki: Van, KeresettIndex
Eljárás vége
Megszámlálás
A megszámlálási algoritmus meghatározza, hogy hány tömbelem rendelkezik a vizsgált tulajdonsággal (11-4. példa). 
Eljárás
  Darab := 0
  Ciklus I := 1-től N-ig
    Ha Tömb(I) adott tulajdonságú Akkor
      Darab := Darab + 1
    Elágazás vége
  Ciklus vége
  Ki: Darab
Eljárás vége
Maximum kiválasztás
Keressük a legnagyobb elemet és a sorszámát a tömbben (11-5. példa). 
Eljárás
  LegnagyobbElem := Tömb(1)
  Hely := 1
  Ciklus I := 2-től N-ig
    Ha Tömb(I) > LegnagyobbElem Akkor
      LegnagyobbElem := Tömb(I)
      Hely := I
    Elágazás vége
  Ciklus vége
  Ki: LegnagyobbElem, Hely
Eljárás vége
Bináris keresés
A bináris keresés algoritmusa meghatározza a tömb megadott értékű elemének indexét, ha a tömb rendezett (11-6. példa). 
Eljárás
  Első := 1 : Utolsó := N
  Talált := Hamis
  Ciklus
    Középső := Int((Első + Utolsó) / 2)
    Ha Tömb(Középső) = KeresettElem Akkor
      Talált := Igaz
    Egyébként ha Tömb(Középső) < KeresettElem Akkor
      Első := Középső + 1
    Egyébként ha Tömb(Középső) > KeresettElem Akkor
      Utolsó := Középső – 1
    Elágazás vége
  amíg Talált = hamis És Első <= Utolsó
  Ciklus vége
  Ki: Talált
  Ha Talált Akkor
    Hely := Középső
    Ki: Hely
  Elágazás vége
Eljárás vége

Rendezési algoritmusok

Minimumkiválasztásos rendezés (11-7. példa) 
Eljárás
  Ciklus I := 1-től N-1-ig
    LegkisebbElem := Tömb(I)
    Hely := I
    Ciklus J := I+1-től N-ig
      Ha Tömb(J) < LegkisebbElem Akkor
        LegkisebbElem := Tömb(J)
        Hely := J
      Elágazás vége
    Ciklus vége
    Tömb(Hely) := Tömb(I)
    Tömb(I) := LegkisebbElem
  Ciklus vége
Eljárás vége
Buborékos rendezés (11-8. példa) 
Eljárás
  Ciklus I := 1-től N-1-ig
    Ciklus J := 2-től N-ig
      Ha Tömb(J–1) > Tömb(J) Akkor
        Tömb(J-1) és Tömb(J) cseréje
      Elágazás vége
    Ciklus vége
  Ciklus vége
Eljárás vége
Módosított buborékos rendezés (11-9. példa) 
Eljárás
  I := N
  Ciklus
    VoltCsere := hamis
    Ciklus J := 2–től I-ig
      Ha Tömb(J-1) > Tömb(J) Akkor
        Tömb(J-1) és Tömb(J) cseréje
        VoltCsere := igaz
      Elágazás vége
    Ciklus vége
    I := I - 1
  amíg VoltCsere = igaz
  Ciklus vége
Eljárás vége
Rendezés beillesztéssel (11-11. példa) 
Eljárás
  Ciklus I := 2-től N-ig
    Temp := Tömb(I)
    J := I – 1
    Ciklus amíg RosszHely(J, Temp)
      Tömb(J + 1) := Tömb(J)
      J := J - 1
    Ciklus vége
    Tömb(J + 1) := Temp
  Ciklus vége
Eljárás vége

Függvény RosszHely(Index, Elem)
  RosszHely := (Index > 0)
  Ha RosszHely Akkor
    RosszHely := (Tömb(Index) > Elem)
  Elágazás vége
Függvény vége
Shell-rendezés (11-12. példa) 
Eljárás
  Lépésköz := 2^Int(Log(N)/Log(2))-1
  Ciklus amíg Lépésköz > 0
    K := 1
      Ciklus I := K + Lépésköz-től N-ig Lépésköz-zel növelve
        Temp := Tömb(I)
        J := I - Lépésköz
        Ciklus amíg Ismétel(J, Temp)
          Tömb(J + Lépésköz) := Tömb(J)
          J := J - Lépésköz
        Ciklus vége
        Tömb(J + Lépésköz) := Temp
      Ciklus vége
      K := K + 1
    Ciklus vége
    Lépésköz := Int(Lépésköz / 2)
  Ciklus vége
Eljárás vége

Sorozatok hozzárendelése sorozatokhoz

Kiválogatás
Egy tömbből kiválogatjuk a megadott tulajdonságú elemeket (11-13. példa). 
Eljárás
  J := 0
  Ciklus I := 1-től N-ig
    Ha Tömb(I) adott tulajdonságú Akkor
      J := J + 1
      ÚjTömb(J) := Tömb(I)
    Elágazás vége
  Ciklus vége
Eljárás vége
Összefésülés
Az összefésülés két rendezett tömb elemeit egyesíti egy harmadik, szintén rendezett tömbben (11-14. példa). 
Eljárás
  I := 1
  J := 1
  K := 1
  Ciklus amíg I <= MaxIndex1 És J <= MaxIndex2
    Ha Tömb1(I) <= Tömb2(J) Akkor
      Fésült(K) := Tömb1(I)
      I := I + 1
    Egyébként
      Fésült(K) := Tömb2(J)
      J := J + 1
    Elágazás vége
    K := K + 1
  Ciklus vége
  Ha I <= MaxIndex1 Akkor
    Ciklus L := I-től MaxIndex1-ig
      Fésült(K) := Tömb1(L)
      K := K + 1
    Ciklus vége
  Egyébként
    Ciklus L := J-től MaxIndex2-ig
      Fésült(K) := Tömb2(L)
      K := K + 1
    Ciklus vége
  Elágazás vége
Eljárás vége
Közös elemek kiválogatása
Két tömb közös elemeit válogatja ki egy újabb tömbben (11-15. példa). 
Eljárás
  K := 0
  Ciklus J := 1-től MaxIndex2-ig
    I := 1
    Ciklus amíg I < MaxIndex1 és Tömb1(I) <> Tömb2(J)
      I := I + 1
    Ciklus vége
    Ha Tömb1(MaxIndex1) <> Tömb2(J) Akkor
      I := I + 1
    Elágazás vége
    Ha I <= MaxIndex1 akkor
      K := K + 1
      Metszet(K) := Tömb2(J)
    Elágazás vége
  Ciklus vége
Eljárás vége
Az elemek uniója
Két tömb elemeit összegyűjti egy harmadik tömbben, de az egyforma értékeket csak egyszer veszi át (11-16. példa). 
Eljárás
  Ciklus I := 1-től MaxIndex1-ig
    Unió(I) := Tömb1(I)
  Ciklus vége
  K := MaxIndex1
  Ciklus J := 1-től MaxIndex2-ig
    I := 1
    Ciklus amíg I < MaxIndex1 És Tömb1(I) <> Tömb2(J)
      I := I + 1
    Ciklus vége
    Ha Tömb1(MaxIndex1) <> Tömb2(J) Akkor
      I := I + 1
    Elágazás vége
    Ha I > MaxIndex1 Akkor
      K := K + 1
      Unió(K) := Tömb2(J)
    Elágazás vége
  Ciklus vége
Eljárás vége

Rekurzív algoritmusok

Gyorsrendezés (quick sort, 11-21. példa) 
Eljárás
  Gyorsrendezés(1, N)
Eljárás vége

Eljárás Gyorsrendezés(Első, Utolsó)
  Temp := Tömb((Első + Utolsó) \ 2)
  Bal := Első
  Jobb := Utolsó
  Ciklus amíg Bal <= Jobb
    Ciklus amíg Tömb(Bal) < Temp
      Bal := Bal + 1
    Ciklus vége
    Ciklus amíg Tömb(Jobb) > Temp
      Jobb := Jobb – 1
    Ciklus vége
    Ha Bal <= Jobb akkor
      Tömb(Bal) és Tömb(Jobb) cseréje
      Bal := Bal + 1
      Jobb := Jobb – 1
    Elágazás vége
  Ciklus vége
  Ha Első < Jobb Akkor Gyorsrendezés(Elso, Jobb)
  Ha Bal < Utolsó Akkor Gyorsrendezés(Bal, Utolsó)
Eljárás vége
Visszalépéses keresés
Legyen N darab sorozatunk, melyek elemeinek száma MaxIndex(1), MaxIndex(2), …, MaxIndex(N). Válasszunk ki mindegyikből egy-egy elemet úgy, hogy a kiválasztott elemek adott kapcsolatban legyenek egymással (11-23. példa). 
Eljárás
  a Választás tömb elemeinek nullázása
  I := 1
  Ciklus amíg I >= 1 És I <= N
    Ciklus
      Választás(I) := Választás(I) + 1
    amíg NemJóElem(I) = igaz
    Ciklus vége
    Ha (Választás(I) <= MaxIndex(I)) Akkor
      I := I + 1
    Egyébként
      Választás(I) := 0
      I := I - 1
    Elágazás vége
  Ciklus vége
  VanMegoldás := (I > N)
Eljárás vége

Függvény NemJóElem(I)
  Ha Választás(I) > MaxIndex(I) Akkor
    NemJóElem := hamis
  Egyébként
    J := 1
    Ciklus amíg J < I És
           az I-edik sorozat Választás(I)-edik eleme és a
           a J-edik sorozat Választás(J)-edik eleme
           megfelelő kapcsolatban van egymással
      J := J + 1
    Ciklus vége
    NemJóElem := (J < I)
  Elágazás vége
Függvény vége