Algoritmusok 1


  1. Algoritmus: lineáris tömb bejárása. Legyen adott az LB alsó és az UB felső indexha- tárú LA lineáris tömb. Az algoritmus bejárja az LA tömböt, és az elemeire a PROCESS (feldolgozás) összefoglaló névvel jelölt műveleteket tartalmazza.
    1. [A számláló kezdőértékének beállítása.] K:=LB.
    2. Repeat 3. és 4. lépés while K<= UB.
    3. [Hozzáférés a tömbelemhez, és az elem feldolgozása.]
      A PROCESS művelet alkalmazása az LA[K] elemre.
    4. [A számláló növelése.] K:=K+1.
      [A 2. lépésben kezdődött ciklus vége.]
    5. Exit.


  2. Algoritmus: lineáris tömb bejárása. Az algoritmus bejárja az LA alsó és az LB felső indexhatárú LA lineáris tömböt, és az elemeire a PROCESS összefoglaló névvel jelölt műveletet alkalmazza.
    1. Repeat for K = LB to UB:
      A PROCESS művelet alkalmazása az LA[K] elemre.
      [A ciklus vége.]
    2. Exit.


  3. Algoritmus: új elem beszúrása lineáris tömbbe; INSERT(LA, N, K, ITEM). Az LA itt N elemű lineáris tömb, a K pedig egy olyan pozitív egész szám, amelyre: K <= N. Ez az algoritmus az LA tömb K-adik pozíciójába szúrja be az ITEM elemet.
    1. [A számláló kezdőértékének beállítása.] J:=N.
    2. Repeat 3. és 4. lépés while J >= K.
    3. [A J-edik elem léptetése.] LA[J+1]:=LA[J].
    4. [A számláló csökkentése.] J:=J-1.
      [ 2. lépésben elkezdődött ciklus vége.]
    5. [Az elem beszúrása.] LA[K]:=ITEM
    6. [Az N értékének aktualizálása.] N:=N+1.
    7. Exit.


  4. Algoritmus: elem törlése a lineáris tömbből; DELETE(LA, N, K, ITEM). Az LA itt N elemű tömb, a K pedig a következő feltételnek eleget tevő pozitív egész szám. K<=N. Ez az algoritmus az LA tömbből kitörli a K-adik elemet.
    1. ITEM:=LA[K].
    2. Repeat for J=K to N-1:
      3. [A J+-edik elem felfelé léptetése.] LA[J]:=LA[J+1]. [A ciklus vége.]
    3. [Az N értékének aktualizálása.] N:=N-1.
    4. Exit


  5. Algoritmus: buborék rendezés; BUBBLE(DATA, N). A DATA tömbnek N eleme van. Az algoritmus rendezi a DATA tömb elemeit.
    1. Repeat 2. és 3. lépés for K = 1 to N-1.
    2. PTR:=1. [A meneteket számon tartó PTR mutató kezdőértékének beállítása.]
    3. Repeat while PTR<=N-K: [A menetbe tartozó műveletek végrehajtása.]
      1. If DATA[PTR]>DATA[PTR+1], then: A DATA[PTR] és a
        DATA[PTR+1] felcserélése.
        [Az If szerkezet vége.]
      2. PTR:=PTR+1.
        [A belső ciklus vége.]
        [Az 1. lépésben elkezdődött külső ciklus vége.]
    4. Exit.


  6. Algoritmus: szekvenciális keresés; LINEAR(DATA, N, ITEM, LOC). A DATA itt N elemet tartalmazó lineáris tömb, az ITEM pedig a megadott keresendő információ. Ez az algoritmus megadja az ITEM információ LOC helyét a DATA tömbben, sikertelen keresés esetén pedig 0-ra állítja be a LOC értékét.
    1. [Az ITEM beszúrása a DATA tömb végére.] DATA[N+1]:=ITEM.
    2. [A számláló inicializálása.] LOC:=1.
    3. [Az ITEM keresése.]
      Repeat while: DATA[LOC] . ITEM:
      LOC:=LOC+1
      [A ciklus vége.]
    4. [Sikeres keresés?] If LOC = N+1, then LOC:=0.
    5. Exit.


  7. Algoritmus: bináris keresés; BINARY(DATA, LB, UB, ITEM, LOC). A DATA itt rendezett tömb, amelyben az LB az alsó, az UB pedig a felső indexértéket jelenti. Az ITEM a keresendő információ. A BEG, az END és a MID változó a DATA elemeiből képzett szegmens elejét, végét, illetve közepét jelöli. Az algoritmus megadja a kere- sendő ITEM adat LOC helyét, vagy NULL-ra állítja be a LOC értékét.
    1. [A szegmenst kezelő változók kezdőértékének beállítása.]
      BEG:=LB, END:=UB, MID:=INT((BEG+END)/2).
    2. Repeat 3. és 4. lépés while BEG<=END and DATA[MID] . ITEM.
    3. If ITEMEND:=END-1.
      Else
      BEG:=MID+1.
      [Az If szerkezet vége.]
    4. MID:=INT((BEG+END))/2.
      [A 2. lépésben elkezdődött ciklus vége.]
    5. If DATA[MID]=ITEM, then:
      LOC:=MID.
      Else:
      LOC:=NULL.
      [Az If szerkezet vége.]
    6. Exit.


    Egy szintet vissza, vagy vissza a főmenübe.