## 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