Alapalgoritmusok – sorozatszámítás

1. – Összegzés

Feladata:
Megkapja egy számsorozat elemeit és ezeket összeadja.
Pseudo - kód Magyarázat
Függvény Összegzés(A : sorozat) : Elemtip A metódus egy Összegzés nevű, Elemtip (var)
visszatérési értékű függvény lesz, mely
paraméterében egy A sorozatot vár.
Változók Az S változóban számoljuk az értéket, az I
S: Elemtip; változó a ciklusváltozó.
I: Egész;

Algoritmus
S ← 0; S kezdőértéke 0.
Ciklus I ← (1...N) For ciklusnak felel meg. N = az A sor hossza.
S ← S + A[I]; Az S változót minden körben megnöveljük az A
sorozat I-edik elemének értékével.
CVége
Összegzés ← S; Az eredményt visszaadja (return).
FVége;

Programkód
int Összegzés(int[] A)
{
int S = 0;

for (int I = 0; I < A.Length; I++)

{
S += A[I];
}
return S;
}
2. Megszámlálás

Feladata:
Megkap egy sorozatot és az azokon értelmezett T tulajdonságot, majd megszámolja, hogy a sorozat
hány tagja rendelkezik ezzel a tulajdonsággal.

Pseudo - kód Magyarázat

Függvény Megszámlálás(A : sorozat) : egész A metódus egy Megszámlálás nevű, egész (int)
visszatérési értékű függvény lesz, mely
paraméterében egy A sorozatot vár.
Változók A DB változóban számoljuk az értéket, az I
DB: egész; változó a ciklusváltozó.
I: Egész;

Algoritmus
DB ← 0; DB kezdőértéke 0.
Ciklus I ← (1...N) For ciklusnak felel meg. N = az A sor hossza.
HA (T(A[I])) AKKOR Az A sorozat I-edik elemére igaz T tulajdonság?
(if-nek felel meg).
DB ← DB + 1; Ha az adott körben a feltétel teljesül, a DB
változót egyel növeljük.
HVÉGE
CVége
Megszámlálás ← DB; Az eredményt visszaadja (return).
FVége;

Programkód (T = Páros számok):

int Megszámlálás(int[] A)
{
int DB = 0;

for (int I = 0; I < A.Length; I++)

{
if(A[I] % 2 == 0)
{
DB++;
}
}
return DB;
}
2. Kiválogatás

Feladata:
Megkap egy sorozatot és az azokon értelmezett T tulajdonságot, majd a sorozat azon elemeit,
amikre passzol a T tulajdonság, egy külön sorozatba gyűjti.

Pseudo - kód Magyarázat

Függvény Kiválogatás(A : sorozat) : B sorozat A metódus egy Kiválogatás nevű, B sorozat
visszatérési értékű függvény lesz, mely
paraméterében egy A sorozatot vár.
Változók B az a sorozat, amibe a megfelelő elemeket
B: sorozat; gyűjtjük. Az Y a B sorozat számlálója.
I, Y: egész;

Algoritmus
Y = 0; A B sorozat számlálóját 0-ra állítjuk.
Ciklus I ← (1...N) For ciklusnak felel meg. N = az A sor hossza.
HA (T(A[I])) AKKOR Az A sorozat I-edik elemére igaz T tulajdonság?
(if-nek felel meg).
B[Y] ← A[I] Ha az adott körben a feltétel teljesül, az elemet a
B sorozatba másoljuk.

Y←Y+1 Ebben az esetben a B sorozat számlálóját egyel

növeljük.
HVÉGE
CVége
Kiválogatás ← B; Az eredményt visszaadja (return).
FVége;

Programkód (T = Páros számok):

int[] Kiválogatás(int[] A)
{
int[] B = new int[A.Length];
int Y = 0;

for (int I = 0; I < A.Length; I++)

{
if (A[I] % 2 == 0)
{
B[Y] = A[I];
Y++;
}
}
return B;
}
3. Minimum és maximum érték kiválasztása

Feladat:
A függvény egy A sorozatnak megkeresi a legnagyobb elemét és annak értékét visszaadja. (A
bemutatás a minimum értékkel fog zajlani, a maximum megkereséséhez a legbelső „if” relációt kell
megfordítani!).

Pseudo - kód Magyarázat

Függvény MinimumÉ(A : sorozat) : Elemtip A metódus egy MinimumÉ nevű, Elemtip
visszatérési értékű függvény lesz, mely
paraméterében egy A sorozatot vár.
Változók A MinÉ-ben fogjuk tárolni az eddig megtalált
MinÉ: Elemtip; legkisebb elemet.
I: egész;

Algoritmus
MinÉ ← A[1]; Feltételezzük, hogy az A sorozat 1. eleme a
legkisebb.
Ciklus I ← (2...N) For ciklusnak felel meg. N = az A sor hossza.
A 2. elemtől indulunk, mert a ciklus első
futásakor a sorozat első eleme már be van töltve.
HA A[I] < MinÉ AKKOR Az A sorozat I-edik elemére igaz T tulajdonság,
hogy kisebb a jelenlegi MinÉ értéknél? (if-nek
felel meg).
MinÉ ← A[I] Ha az adott körben a feltétel teljesül, az A
sorozat I-edik elemét értékül adjok a MinÉ
változónak.
HVÉGE
CVége
Kiválogatás ← MinÉ; Az eredményt visszaadja (return).
FVége;

Programkód
int MinimumÉ(int[] A)
{
int MinÉ = A[0];

for (int I = 0; I < A.Length; I++)

{
if(A[I] < MinÉ)
{
MinÉ = A[I];
}
}
return MinÉ;
}
4. Minimum és maximum érték helyének kiválasztása

Feladat:
A függvény egy A sorozatnak megkeresi a legnagyobb elemét és annak helyét visszaadja. (A
bemutatás a minimum értékkel fog zajlani, a maximum megkereséséhez a legbelső „if” relációt kell
megfordítani!).

Pseudo - kód Magyarázat

Függvény MinimumH(A : sorozat) : egész A metódus egy MinimumH nevű, egész
visszatérési értékű függvény lesz, mely
paraméterében egy A sorozatot vár.
Változók A MinH-ban fogjuk tárolni az eddig megtalált
MinH: egész; legkisebb elemet.
I: egész;

Algoritmus
MinH ← 1; Feltételezzük, hogy az A sorozat 1. eleme a
legkisebb.
Ciklus I ← (2...N) For ciklusnak felel meg. N = az A sor hossza.
A 2. elemtől indulunk, mert a ciklus első
futásakor a sorozat első eleme már be van töltve.
HA A[I] < A[MinH] AKKOR Az A sorozat I-edik elemére igaz T tulajdonság,
hogy kisebb a jelenlegi MinH értéknél lévő
elemnél? (if-nek felel meg).
MinH ← I Ha az adott körben a feltétel teljesül, az I értékül
adódik MinH-nak.
HVÉGE
CVége
Kiválogatás ← MinH; Az eredményt visszaadja (return).
FVége;

Programkód
int MinimumH(int[] A)
{
int MinH = A[0];

for (int I = 0; I < A.Length; I++)

{
if (A[I] < A[MinH])
{
MinH = I;
}
}
return MinH;
}
 Keresés, rendezés
1. Eldöntés
Megvizsgálja, hogy a sorozatban van-e T-tulajdonságú elem
Pseudo - kód Magyarázat
Függvény Eldöntés(A : sorozat) : logikai A metódus egy Eldöntés nevű, logikai
visszatérési értékű függvény lesz, mely
paraméterében egy A sorozatot vár.
Változók
I: egész;

Algoritmus
I ← 1; Feltételezzük, hogy az A sorozat 1. eleme a
legkisebb.
Ciklus_Míg (I <= N) ÉS (Nem T(A[I])) While ciklusnak felel meg. Addig fut, míg I
kisebb, mint A hossza, és az aktuális elem nem
felel meg T tulajdonságnak.
I ← I + 1; Ha a ciklus nem ugrott ki, I-t növeljük egyel.

CVége Megvizsgáljuk, hogy a ciklus után I kisebb vagy

Eldöntés ← (I <= N); egyenlő-e A sorozat hosszával. Ha nem teljesül a
FVége; reláció, vagyis I nagyobb A hosszánál, akkor a
sorozatban nem szerepel T tulajdonságú elem,
emiatt az eredmény „hamis” lesz. Ha teljesül a
reláció, akkor szerepel T tulajdonságú elem, az
eredmény „Igaz” lesz.

Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód (T → az elem páros)
bool Eldöntés(int[] A)
{
int I = 0;

while (I < A.Length && A[I] % 2 != 0)

{
I++;
}
return I <= A.Length;
}
2. Lineáris keresés

Feladat:
Megkeresi a sorban a T tulajdonságú elemet és logikai változóval jelöli, hogy talált-e. Ezen felül
visszaadja az elem helyét egy külső változó formájában.

Pseudo - kód Magyarázat

Függvény LinKer(A : sorozat, Hely: egész) : A metódus egy LinKer nevű, logikai visszatérési
logikai értékű függvény lesz, mely paraméterében egy A
sorozatot vár. Egy paraméterben bekért
változóba kiadja a talált elem helyét is.
Változók
I: egész;

Algoritmus
I ← 1;
Ciklus_Míg (I <= N) ÉS (Nem T(A[I])) While ciklusnak felel meg. Addig fut, míg I
kisebb, mint A hossza, és az aktuális elem nem
felel meg T tulajdonságnak.
I ← I + 1; Ha a ciklus nem ugrott ki, I-t növeljük egyel.

CVége Megvizsgáljuk, hogy a ciklus után I kisebb vagy

Hely ← I; egyenlő-e A sorozat hosszával. Ha nem teljesül a
Eldöntés ← (I <= N); reláció, vagyis I nagyobb A hosszánál, akkor a
FVége; sorozatban nem szerepel T tulajdonságú elem,
emiatt az eredmény „hamis” lesz. Ha teljesül a
reláció, akkor szerepel T tulajdonságú elem, az
eredmény „Igaz” lesz.
A „Hely” változó megkapja I értékét, amit a
függvényen kívülre közvetít. Ha az eredmény
„Hamis”, akkor a „Hely” változó A sorozat
hosszával lesz egyenlő.

Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód (T → az elem páros)
bool LinKer(int[] A, out int Hely)
{
int I = 0;

while (I < A.Length && A[I] % 2 != 0)

{
I++;
}
Hely = I;
return I <= A.Length;
}
3. Kiválasztás

Feladat:
Adott egy A sorozat és egy T tulajdonság. Tudjuk, hogy a sorozatban legalább egy T tulajdonságú
elem van. A kiválasztás visszaadja az első T tulajdonságú elem helyét.

Pseudo - kód Magyarázat

Eljárás KiVálasztás(A : sorozat, Hely: egész) A metódus egy Kiválasztás nevű, eljárás lesz,
mely paraméterében egy A sorozatot vár. Egy
paraméterben bekért változóba kiadja a talált
elem helyét.
Változók
I: egész;

Algoritmus
I ← 1; Feltételezzük, hogy az A sorozat 1. eleme a
legkisebb.
Ciklus_Míg (Nem T(A[I])) While ciklusnak felel meg. Addig fut, míg I
kisebb, mint A hossza, és az aktuális elem nem
felel meg T tulajdonságnak.
Mivel kikötés, hogy A sorozatban lennie kell T
tulajdonságú elemnek, ezért az I<=N relációt
nem kell vizsgálni.
I ← I + 1; Ha a ciklus nem ugrott ki, I-t növeljük egyel.

CVége A „Hely” változó megkapja I értékét, amit a

Hely ← I; függvényen kívülre közvetít.
EVége;

Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód (T → az elem páros)
void KiVálasztás(int[] A, out int Hely)
{
int I = 0;

while (A[I] % 2 != 0)
{
I++;
}
Hely = I;
}
4. Strázsás keresés

Feladat:
Adott egy A sorozat és egy T tulajdonság. Tudjuk, hogy a sorozatban legalább egy T tulajdonságú
elem van, mert a sorozat végére manuálisan beszúrunk egy T tulajdonságú elemet, egy
„strázsaelemet”. A kiválasztás visszaadja az első T tulajdonságú elem helyét.

Pseudo - kód Magyarázat

Függvény StrázsásKer(A : sorozat, Hely: A metódus egy StrázsásKer nevű, logikai
egész) : logikai visszatérési értékű függvény lesz, mely
paraméterében egy A sorozatot vár. Egy
paraméterben bekért változóba kiadja a talált
elem helyét is.
Változók
I: egész;

Algoritmus
I ← 1; A sorozat végére beszúrunk egy T tulajdonságú
A[N+1] ← TtulajdonságúElem elemet.
Ciklus_Míg (Nem T(A[I])) While ciklusnak felel meg. Addig fut, míg az
aktuális elem nem felel meg T tulajdonságnak.
I ← I + 1; Ha a ciklus nem ugrott ki, I-t növeljük egyel.

CVége Megvizsgáljuk, hogy a ciklus után I kisebb vagy

Hely ← I; egyenlő-e A sorozat hosszával. Ha nem teljesül a
StrázsásKer ← (I <= N); reláció, vagyis I nagyobb A hosszánál, akkor a
FVége; sorozatban nem szerepel T tulajdonságú elem,
emiatt az eredmény „hamis” lesz. Ha teljesül a
reláció, akkor szerepel T tulajdonságú elem, az
eredmény „Igaz” lesz.
A „Hely” változó megkapja I értékét, amit a
függvényen kívülre közvetít. Ha az eredmény
„Hamis”, akkor a „Hely” változó A sorozat
hosszával (a strázsaelemmel együtt) egyenlő.

Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között! (Kódrövidítés érdekében itt dinamikus sort, azaz listát használtam)
Programkód (T → az elem páros)
bool StrázsásKer(List<int> A, out int Hely)
{
int I = 0;
A.Add(2);
while (I < A.Count && A[I] % 2 != 0)
{
I++;
}
Hely = I;
return I <= A.Count;
}
5. Lineáris keresés rendezett sorozatban

Feladat:
A fentiekhez hasonlóan egy sorozatban keres, logikai értékkel jelzi, hogy volt-e egy adott elem. Ám
figyelembe veszi azt a lehetőséget, hogy a sorozat aktuális eleme alapján már nem tartalmazhatja a
keresett elemet. Csak rendezett sorozatoknál működik!

Pseudo - kód Magyarázat

Függvény LinKerRend(A : sorozat, Adat: A metódus egy LinKerRend nevű, logikai
ElemTip, Hely: egész) : logikai visszatérési értékű függvény lesz, mely
paraméterében egy A sorozatot és egy keresendő
adatot vár. Egy paraméterben bekért változóba
kiadja a talált elem helyét is.
Változók
I: egész;

Algoritmus
I ← 1;
Ciklus_Míg (I <= N) ÉS (Adat>A[I]) While ciklusnak felel meg. Addig fut, míg I
kisebb, mint A hossza, és az aktuális elem
kisebb, mint a keresett adat.
I ← I + 1; Ha a ciklus nem ugrott ki, I-t növeljük egyel.

CVége Megvizsgáljuk, hogy a ciklus után I kisebb vagy

Hely ← I; egyenlő-e A sorozat hosszával és A I-edik eleme
Eldöntés ← (I <= N) ÉS (Adat = A[I]); egyenlő-e a keresett adattal. Ezen felül I-t
FVége; mindig visszaadjuk, de csak akkor használható,
ha a függvény értéke „igaz”.

Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód
bool LinKerRend(int[] A, int Adat, out int Hely)
{
int I = 0;

while (I < A.Length && Adat > A[I])

{
I++;
}
Hely = I;
return I <= A.Length && (Adat == A[I]);
}
6. Bináris keresés

Feladat:
A bináris keresés a keresés egyik gazdaságosabb formája, működési elve szerint meg tudja tippelni
a keresett elem helyét és csak a megtippelt részben keresni tovább. Csak rendezett sorozatokon
működik!

Pseudo - kód Magyarázat

Függvény BinKer(A : sorozat, Adat: ElemTip, A metódus egy BinKer nevű, logikai visszatérési
Hely: egész) : logikai értékű függvény lesz, mely paraméterében egy A
sorozatot és egy keresendő adatot vár. Egy
paraméterben bekért változóba kiadja a talált
elem helyét is.
Változók
E, U K: egész;
Az E jelöli a vizsgált részsorozat első elemét, az
Algoritmus U az utolsó elemét. A K a látható módon
E ← 1; keletkezik, ez fogja megkeresni a részsorozatban
U ← N; az elemet.
K ← (E + U) div 2;
Ciklus_Míg (E <= U) ÉS (Adat != A[K]) While ciklusnak felel meg. Addig fut, míg A
sorozat eleje kisebb vagy egyenlő, mint a
sorozat vége, és a keresett elem nem egyezik
meg A sor K-adik elemével
HA Adat<A[K] AKKOR „If”-nek felel meg

U ← K-1; Ha a keresett érték kisebb, mint K, vagyis a

részsorozat első felében van, akkor a
részsorozatot jobbról megfelezzük, vagyis a
végét a K-1 elemre állítjuk.
KÜLÖNBEN „Else”-nek felel meg
E ← K+1; Ha a keresett érték nagyobb, mint K, vagyis a
HVÉGE részsorozat első felében van, akkor a
részsorozatot balról megfelezzük, vagyis a végét
a K+1 elemre állítjuk.
K ← (E + U) div 2; Újra kiszámoljuk az aktuális részsorozat
közepét.
CVége Megvizsgáljuk, hogy a ciklus után Teljesül-e az
Hely ← K; E <= U reláció. Ha igen, akkor a függvény az
Eldöntés ← (E<=U); Adat != A[K] reláció miatt ugrott ki, vagyis
FVége; megtalálta a keresett elemet, amit K-ként kiad.
Ha hamis, akkor a függvény nem találta meg az
elemet.
Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód
bool BinKer(int[] A, int Adat, out int Hely)
{
int E = 0;
int U = A.Length-1;
int K = (E + U) / 2;

while (E <= U && Adat != A[K])

{
if (Adat < A[K])
{
U = K - 1;
}
else
{
E = K + 1;
}
K = (E + U) / 2;
}
Hely = K;
return E<=U;
}
 Rendezés
1. Közvetlen kiválasztás

Feladat:
Vesszük a sorozat első elemét és a többi elemen végigmenve megnézzük, hogy kisebbek-e mint az
első. Ha találunk kisebb elemet, azt kicseréljük a sorozat első elemével, így a sorozat első eleme
lesz a legkisebb.

Pseudo - kód Magyarázat

Eljárás Közv(A : sorozat) A metódus egy KözvKi nevű eljárás lesz, mely
paraméterében egy A sorozatot vár.

Változók Az I a ciklusváltozó, a J-edik elemtől vizsgáljuk

I: egész; a sorozatot és a legkisebb lem is ide fog kerülni
J: egész; (később lesz fontos). A C egy segédváltozó a
C: Elemtip; cseréhez.
Algoritmus Az első elemtől kezdve akarunk vizsgálni és ezt
J ← 1; akarjuk cserélni is.
Ciklus (I ← (J+1...N)) For ciklusnak felel meg. J+1-től bejárjuk a
sorozatot. J-t nem kell belevenni, mert
önmagához nem kell hasonlítani.
HA A[I]<A[J] AKKOR Ha az aktuális elem kisebb, mint a J-edik elem...
C ← A[I]; Megcseréljük a két elemet
A[I] ← A[J];
A[J] ← C;
CVége Az eljárás végén biztosan a legkisebb elem van
EVége; legelöl.

Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód
static void KözvKi(ref int[] A)
{
int J = 0;
int C = 0;
for (int I = J+1; I < A.Length; I++)
{
if (A[I] < A [J])
{
C = A[I];
A[I] = A[J];
A[J] = C;
}
}
}
2. Sorozat rendezése közvetlen kiválasztással

Feladat:
A közvetlen kiválasztás segítségével egy teljes sorozatot rendezünk.

Pseudo - kód Magyarázat

Eljárás KözvRend(A : sorozat) A metódus egy KözvRend nevű eljárás lesz,
mely paraméterében egy A sorozatot vár.
Változók Az I a ciklusváltozó, a J-edik elemtől vizsgáljuk
I: egész; a sorozatot és a legkisebb elem is ide fog
J: egész; kerülni. A C egy segédváltozó a cseréhez.
C: Elemtip;
Algoritmus Az első elemtől kezdve végigvizsgáljuk az egész
Ciklus J ← (1...N-1) sorozatot és kicserélgetjük az elemeket. Az
utolsó előtti elemig kell menni, mert ha az utolsó
előtti helyen van az addigi részsorozat szerinti
legnagyobb elem, akkor az utolsó helyen csak a
legnagyobb elem lehet (plusz a cikluson belül
vizsgáljuk az utolsó elemet is a J+1 miatt).
Ciklus (I ← (J+1...N)) For ciklusnak felel meg. J+1-től bejárjuk a
sorozatot. J-t nem kell belevenni, mert
önmagához nem kell hasonlítani.
HA A[I]<A[J] AKKOR Ha az aktuális elem kisebb, mint a J-edik elem...
C ← A[I]; Megcseréljük a két elemet
A[I] ← A[J];
A[J] ← C;
HVége
CVége;
CVége Az eljárás végén biztosan a legkisebb elem van
EVége; legelöl.
Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód
void KözvRend(ref int[] A)
{
int C = 0;
for (int J = 0; J < A.Length-1; J++)
{
for (int I = J + 1; I < A.Length; I++)
{
if (A[I] < A[J])
{
C = A[I];
A[I] = A[J];
A[J] = C;
}
}
}
}
3. Minimum kiválasztás

Feladat:
A minimum kiválasztás a közvetlen kiválasztásos rendezés továbbfejlesztése: a cserét csak akkor
hajtja végre, ha már megtalálta a részsorozat legkisebb elemét, így növelve a hatékonyságot.

Pseudo - kód Magyarázat

Eljárás MinRend(A : sorozat) A metódus egy MinRend nevű eljárás lesz, mely
paraméterében egy A sorozatot vár.

Változók Az I a ciklusváltozó, a J-edik elemtől vizsgáljuk

MinI: egész a sorozatot és a legkisebb elem is ide fog
I: egész; kerülni. A C egy segédváltozó a cseréhez.
J: egész; A MinI-ben tároljuk azt a sorszámot, ami
C: Elemtip; minden cikluskör végén a részsorozat legkisebb
elemének sorszámával lesz egyenlő.
Algoritmus Az első elemtől kezdve végigvizsgáljuk az egész
Ciklus J ← (1...N-1) sorozatot és kicserélgetjük az elemeket. Az
utolsó előtti elemig kell menni, mert ha az utolsó
előtti helyen van az addigi részsorozat szerinti
legnagyobb elem, akkor az utolsó helyen csak a
legnagyobb elem lehet (plusz a cikluson belül
vizsgáljuk az utolsó elemet is a J+1 miatt).
MinI ← J; A MinI változó értékét alapértelmezetten J-re
állítjuk, ezt fogja először figyelembe venni.
Ciklus (I ← (J+1...N)) For ciklusnak felel meg. J+1-től bejárjuk a
sorozatot. J-t nem kell belevenni, mert
önmagához nem kell hasonlítani.
HA A[I]<A[MinI] AKKOR Ha az aktuális elem kisebb, mint a J-edik elem...
MinI ← I; Elmentjük a talált legkisebb elem sorszámát.
HVége Legközelebbi körben már ehhez képest fog a
program vizsgálni.
CVége; Biztosak lehetünk benne, hogy a ciklus végén a
MinI az aktuális részsorozat legkisebb elemének
sorszámát veszi fel.
HA MinI != J AKKOR Nem kell cserélni abban az esetben, ha a MinI J-
vel egyenlő. Ez azt jelenti, hogy A vizsgált elem
a helyén van.
C ← A[I]; Csere.
A[I] ← A[J];
A[J] ← C;
Hvége;
CVége Az eljárás végén biztosan a legkisebb elem van
EVége; legelöl.
Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód
void MinRend(ref int[] A)
{
int C = 0;
for (int J = 0; J < A.Length - 1; J++)
{
int MinI = J;
for (int I = J + 1; I < A.Length; I++)
{
if (A[I] < A[MinI])
{
MinI = I;
}
}
if (MinI != J)
{
C = A[MinI];
A[MinI] = A[J];
A[J] = C;
}
}
}
4. Buborékrendezés

Feladat:
A buborékrendezés két egymás melletti elemet hasonlít össze és szükség esetén megcseréli azokat.
Így n-1 lépés alatt a legnagyobb elem a sorozat végére kerül. A rendezést n-szer kell végrehajtani,
ám a rendezett részt már nem szükséges figyelembe venni.

Pseudo - kód Magyarázat

Eljárás Buborék(A : sorozat) A metódus egy Buborék nevű eljárás lesz, mely
paraméterében egy A sorozatot vár.

Változók Az I a ciklusváltozó, a J a vizsgálandó

I: egész; részsorozat hossza. A C egy segédváltozó a
J: egész; cseréhez.
C: Elemtip;
Algoritmus A részsorozat feldolgozása.
Ciklus J ← (1...N-1)
Ciklus (I ← (1...N-J)) For ciklusnak felel meg. 1-től N-J-ig bejárjuk a
sorozatot.
HA A[I]<A[I+1] AKKOR Ha az aktuális elem kisebb, mint a J-edik elem...
C ← A[I]; Elmentjük a talált legkisebb elem sorszámát.
A[I] ← A[I+1]; Legközelebbi körben már ehhez képest fog a
A[I+1] ← C; program vizsgálni.
HVége
CVége; Az aktuális részsorozat legnagyobb eleme a
helyére került, a többi pedig egy lépést tett a
helye felé.
CVége Az eljárás végén biztosan a legkisebb elem van
EVége; legelöl.

Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód
void Buborék(ref int[] A)
{
int C = 0;
for (int J = 0; J < A.Length-1; J++)
{
for (int I = 0; I < A.Length-1-J; I++)
{
if (A[I] < A[I+1])
{
C = A[I];
A[I] = A[I+1];
A[I+1] = C;
}
}
}
}
5. Buborékrendezés – javított

Feladat:
A buborékrendezésen sokat lehet javítani különböző módokon.
• izsgáljuk azt, hogy nem vált-e a sorozat idő előtt rendezetté, így kivédhetjuk a felesleges
futásokat.
• Eltároljuk az utolsó csere helyét, így nem kell a már rendezett részsorozatokon fölöslegesen
átfutni.
Pseudo - kód Magyarázat
Eljárás Buborék(A : sorozat) A metódus egy Buborék nevű eljárás lesz, mely
paraméterében egy A sorozatot vár.

Változók Az I a ciklusváltozó, a J a vizsgálandó

I: egész; részsorozat hossza. A C egy segédváltozó a
J: egész; cseréhez.
C: Elemtip;

VoltCsere: logikai;
UtolsóCsereH: egész;
Algoritmus A „VoltCsere” véltozót igazra kell állítani, hogy
J ← 1; a while ciklus elindulhasson.
VoltCsere ← Igaz;

Ciklus_Míg (J <= N-1) ÉS VoltCsere
VoltCsere ← Hamis;
UtolsóCsereH ← 0;
„While” ciklusnak felel me. Ide nem jó a „For”,
mert a VoltCserét is vizsgálni kell. Ha a körben a
VoltCsere hamis marad, az azt jelenti, hogy a
sorozat rendezetté vált, így a feladat befejeződik.
A VoltCsere alapértelmezetten minden körben
hamis.

Ciklus (I ← (1...N-J)) For ciklusnak felel meg. 1-től N-J-ig bejárjuk a

sorozatot.
HA A[I]<A[I+1] AKKOR Ha az aktuális elem kisebb, mint a J-edik elem...
C ← A[I]; A csere után elmentjük a talált legkisebb elem
A[I] ← A[I+1]; sorszámát. Legközelebbi körben már ehhez
A[I+1] ← C; képest fog a program vizsgálni.
UtolsóCsereH ← I;
VoltCsere ← Igaz; Ha az adott körben történt csere, akkor a
VoltCsere „igaz”-ra vált
HVége A sorozatnak már rendezett részénél nincs
CVége; szükség az átfutásra, így J értékét nem mindig
J ← N-UtolsóCsereH; csak 1 értékkel állítjuk nagyobbra. Az Utolsó
CsereH értékét meg kell fordítani az értékadás
előtt!
CVége Az eljárás végén biztosan a legkisebb elem van
EVége; legelöl.
Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód
void BuborékJavított(ref int[] A)
{
int C = 0;
int J = 0;
int UtolsóCsereH = -1;
bool VoltCsere = true;
while (J <= A.Length - 1 && VoltCsere)
{
VoltCsere = false;
for (int I = 0; I < A.Length - 1 - J; I++)
{
if (A[I] < A[I + 1])
{
C = A[I];
A[I] = A[I + 1];
A[I + 1] = C;
UtolsóCsereH = I;
VoltCsere = true;
}
}
J = A.Length-1-UtolsóCsereH;
}
}
6. Koktélrendezés

Feladat:
A koktélrendezés lényegében egy oda és egy vissza működő buborékrendezés-pár. Ezzel a
megoldással az egyes elemek felváltva „nyulak” és „teknősök”, felgyorsítja a buborékrendezésnél
csak egyesével menetelő elemek mozgását. Tehát ha az első belső ciklus balra haladva növekvő
sorrendbe rendez, akkor a második belső ciklus jobbra haladva növekvő sorrendbe rendez.

Pseudo - kód Magyarázat

Eljárás Buborék(A : sorozat) A metódus egy Buborék nevű eljárás lesz, mely
paraméterében egy A sorozatot vár.

Változók Az I a ciklusváltozó, a J a vizsgálandó

I: egész; részsorozat hossza. A C egy segédváltozó a
J: egész; cseréhez.
C: Elemtip;
Algoritmus A részsorozat feldolgozása.
Ciklus J ← (1...N-1)
Ciklus (I ← (1...N-J)) For ciklusnak felel meg. 1-től N-J-ig bejárjuk a
sorozatot.
HA A[I]<A[I+1] AKKOR Ha az aktuális elem kisebb, mint a J-edik elem...
C ← A[I]; Elmentjük a talált legkisebb elem sorszámát.
A[I] ← A[I+1]; Legközelebbi körben már ehhez képest fog a
A[I+1] ← C; program vizsgálni.
HVége
CVége; Az aktuális részsorozat legnagyobb eleme a
helyére került, a többi pedig egy lépést tett a
helye felé.
Ciklus (I ← (N-J...1)) A külső ciklusban elhelyezünk egy második
HA A[I]>A[I-1] AKKOR „for” ciklust, mely ugyanúgy épül fel, mint az
első, de a vastagon jelölt helyeken fordítva
C ← A[I]; működik.
A[I] ← A[I+1];
A[I+1] ← C;
HVége
CVége;
CVége Az eljárás végén biztosan a legkisebb elem van
EVége; legelöl.
Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód
void Koktél(ref int[] A)
{
int C = 0;
for (int J = 0; J < A.Length-1; J++)
{
for (int I = 0; I < A.Length - 1 - J; I++)
{
Console.WriteLine("a");
if (A[I] < A[I + 1])
{
C = A[I];
A[I] = A[I + 1];
A[I + 1] = C;
}
}
for (int I = A.Length-1-J; I > 0; I--)
{
Console.WriteLine("B");
if (A[I] > A[I - 1])
{
C = A[I];
A[I] = A[I - 1];
A[I - 1] = C;
}
}
}
}
7. Beszúró rendezés

Feladat:
Az alapelv szerint mindig egy elem helyét kell megkeresnünk egy rendezett részsorozatban.
Kezdéskor a sorozat első elemét tekintjük a rendezett részsorozatnak, amihez képest helyezzük el a
második elemet. Ezután folytatva N hosszúságú sorozatnál mindig az N+1 -edik elemnek keressük
meg a helyét.

Pseudo - kód Magyarázat

Eljárás RendBeszúró(A : sorozat) A metódus egy RendBeszúró nevű eljárás lesz,
mely paraméterében egy A sorozatot vár.

Változók Az I a ciklusváltozó, a J a vizsgálandó

I: egész; részsorozat hossza. Az X egy segédváltozó a
J: egész; cseréhez.
X: Elemtip;
Algoritmus
Ciklus J ← (1...N-1)
I ← J; Az I jelöli az aktuálisan vizsgált elemet,
kezdetben egyenlő a részsorozat utolsó
elemével.
X ← A[J + 1]; A sorozatba illesztendő elemet X jelöli, ez
mindig az X+1-edik elem.
Ciklus_Míg (I >= 1) ÉS (A[I]>X) For ciklusnak felel meg. Addig megy, amíg a
vizsgált elem nem kisebb a megengedett
legkisebb elemnél és A sorozat I-edik eleme
kisebb a rendezendő elemnél.
A[I + 1] ← A[I]; Ha teljesül az A[I]>X, akkor az elemeket
megcseréljük
I ← I – 1;
CVége; Az aktuális részsorozat legnagyobb eleme a
helyére került, a többi pedig egy lépést tett a
helye felé.
A[I + 1] ← X Befejezzük a cserét.
CVége Az eljárás végén biztosan a legkisebb elem van
EVége; legelöl.
Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód
void RendBeszúró(ref int[] A)
{
for (int J = 0; J < A.Length-1; J++)
{
int I = J;
int X = A[J + 1];

while (I >= 0 && A[I] > X)

{
A[I + 1] = A[I];
I--;
}
A[I + 1] = X;
}
}
8. Shell rendezés

A Shell rendezés a minimumrendezés továbbfejlesztése. Veszünk egy d számértéket és a sorozatot

felbontjuk d számú részsorozatra úgy, hogy a részsorozatok egyes elemei d távolságra vannak
egymástól. Ezeket a részsorozatokat külön rendezzük minimumrendezéssel, majd a sorozatokat
fokozatosan egyesítjük úgy, hogy újra lefuttatjuk az algoritmust és folyamatosan csökkentjük d
értékét. Így a részsorozatok egymásba fésülhetőek. Ezzel az eljárással az egyes elemek gyorsabban
haladnak a helyük felé, hatékonyabbá téve az algoritmust.

Pseudo - kód Magyarázat

Eljárás RendShellMin(A : sorozat) A metódus egyRendShellMin
nevű eljárás lesz, mely
paraméterében egy A sorozatot
vár.
Változók Az I, J és MinH az
I, J, MinH: egész alaprendezés változói.
D: egész; A D az elemek közötti távolság.
K: egész; A K az aktuális rendezősorozat
C: Elemtip; sorszáma.
Algoritmus
D ← N;
Ciklus „do while”-nak felel meg.
D ← D div 3 + 1; A D megkapja a
távolságértéket, mely minden
körben csökken.
Ciklus K ← (1...D) A sorozatnak d-szer kell
lefutni.
J ← K;
Ciklus_Míg (J <= N - D) Mivel nem egyesével ugrálunk,
ezért a sorozatnak nem csak az
utolsó elemét nem kell
vizsgálni.
MinH ←J ;
I←J + D ;
Ciklus_Míg I <=N
HA A[I]<A[MinH] AKKOR
MinH← I;
HVége
I ← I+D; Az egyel való ugrást D-vel való
ugrásra cseréltük.
CVége
HA MinI != J AKKOR
C ← A[I];
A[I] ← A[J];
 A[J] ← C;
Hvége;
J ← J + D; Az egyel való ugrást D-vel való
ugrásra cseréltük.
CVége;
CVége;

Cvége_Amikor D = 1;
EVége;
Példa:

Sorozat
1 2 3 4 5 6 7 8 9 10

Részsorozatok d=3 esetén.

k1 1 4 7 10
k2 2 5 8
k3 3 6 9
Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód (d = 3)
void MinRendShell(ref int [] A)
{
int D = A.Length;
do
{
D = D / 3 + 1;
for (int K = 0; K < D; K++)
{
int J = K;
while (J < A.Length)
{
int MinH = J;
int I = J + D;
while (I < A.Length)
{
if (A[I] < A[MinH])
{
MinH = I;
}
I = I + D;
}
if (MinH != J)
{
int csere = A[J];
A[J] = A[MinH];
A[MinH] = csere;
}
J = J + D;
}
}
} while (D > 1);
}
9. Összefuttatás

Feladat:
Két, azonos módon rendezett sorozatot mos össze egy harmadik rendezett sorozattá, figyelembe
véve a hosszok közötti különbséget is.

Pseudo - kód Magyarázat

Eljárás Összefuttatás(A, B, C : sorozat) A metódus egy Összefuttatás nevű eljárás lesz,
mely paraméterében egy A, B és C sorozatot
vár.
Változók
AI, BI, CI: egész
Algoritmus
AI ← 1;
BI ← 1;
CI ← 1;
Ciklus_Míg (AI <= A.Elemszám ÉS Első körben a két sorozat közös hosszát
BI <= B.Elemszám) vizsgáljuk addig, míg az egyik elemei el nem
fogynak.
HA A[AI]<B[BI] Akkor Ha A[AI]<B[BI], akkor CI helyre Az A sorozat
C[CI] ← A[AI]; aktuális eleme kerül, az A sorozat számlálója
AI ← AI + 1; pedig egyel növekszik.

KÜLÖNBEN Fordított esetben a B sorozat aktuális eleme

Ha A[ AI ] >B[ BI ] Akkor kerül elhelyezésre és a B sorozat számlálója
növekszik.
C[ CI ]←B[ BI ];
BI ←BI + 1;
KÜLÖNBEN Ha a két sorozat eleme egyenlő, akkor egymás
C[ CI ]←A[ AI ]; után kerülnek elhelyezésre.

AI ←AI + 1;
CI←CI + 1;
C[ CI ]←B[ BI ];
BI ←BI + 1;
Hvége;
Hvége;
CI ← CI + 1;
CVége;
Ciklus _Míg ( AI <= A. elemszám ) Ha az egyik sorozat hosszabb mint a másik, a
CI←CI + 1; hosszabb sorozat fennmaradó elemei már
biztos, hogy mind nagyobbak, mint az eddig
C[ CI ]←A[ AI ]; elhelyezett elemek, tehát egyszerűen a végére
AI←AI + 1; kell írni őket C sorozatnak.
 CVége;
Ciklus _Míg ( BI <= B. elemszám )
CI←CI + 1;
C[ CI ]←B[ BI ];
BI←BI + 1;
EVége;

Figyelem!
A C# nyelvben a sorok számozása nullától kezdődik, ez okozhat eltérést a pseudo és a megvalósítás
között!
Programkód
void Összefuttatás(int[]A, int[] B, out int[] C)
{
C = new int[A.Length + B.Length];
int AI = 0;
int BI = 0;
int CI = 0;
while (AI < A.Length && BI < B.Length)
{
if (A[AI]<B[BI])
{
C[CI] = A[AI];
AI++;
}
else if(A[AI] > B[BI])
{
C[CI] = B[BI];
BI++;
}
else
{
C[CI] = A[AI];
AI++;
CI++;
C[CI] = B[BI];
BI++;
}
CI++;
}
while (AI < A.Length)
{
C[CI] = A[AI];
AI++;
}
while (BI < B.Length)
{
C[CI] = B[BI];
BI++;
}
}
 Luhn algoritmus

A kereskedelmi termékek vonalkódján lévő, 13 tagú számsorozat validálására szolgál.

1 2 3 4 5 6 7 8 9 10 11 12 13
Származási hely Gyártó Termék azonosító Ellenőrző

Az ellenőrző kódot úgy képezzük, hogy az első 12 számot paritásától függően 1-el vagy 3-al
megszorozzuk, majd ezeket összegezzük. Az ellenőrző kód az az egyjegyű szám lesz, mellyel az
összeg tízzel oszthatóvá tehető.

Pseudo - kód
Függvény Luhn(A : kód): logikai

Változók
I: egész;
SUM: Elemtip;
Algoritmus
SUM ← 0;
Ciklus J ← (1...N)
HA (I MOD 2)=0 Akkor
HA 2*A[i] > 9 Akkor
SUM ← SUM + 2*A[I] – 9;
KÜLÖNBEN
SUM ← SUM + 2*A[I] ;
Hvége;
KÜLÖNBEN
SUM ← SUM + A[I] ;
Hvége;
CVége
Luhn ← (SUM MOD 10) = 0;
EVége;
 Verem
• A verem egy homogén, szekvenciális adatszerkezet.
• Alapját egy tömb képezi.
• Elemeihez csak az „egyik végén” férünk hozzá, vagyis azt az elemet tudjuk először kivenni,
amit utoljára beletettünk.
• Használható például posztfixes matematikai számítások kiértékelésére. (A posztfixes jelölés
azt jelenti, hogy a képletben az operátor nem az operandusok közé, hanem azok elé kerül.
Pl.: +(2, 5)).

Sor
• A sor a verem fordítottja: egyik végét írni, míg másik végét olvasni lehet.
• A legelőször belekerülő elemet olvashatjuk ki először.
• Homogén adatszerkezet, alapját szintén egy tömb képezi.

Fontosabb fogalmak
• Hatékonyság:
◦ Egy algoritmus hatékonysága az elvégzéséhez szükséges időből és az általa létrehozott
és tárolt adatok mennyiségétől függ.
• Folyamatábra:
◦ Egy algoritmust szemléltető, irányított gráf.
◦ Csomópontjai utasításokat, élei adatokat írnak le.
• Leírónyelv:
◦ A programozáson alapuló, de egyik programnyelvhez sem kötődő nyelv, mellyel
programnyelvektől kötetlenül lehet algoritmusokat tervezni és leírni.
• Vezérlési szerkezetek:
◦ Az algoritmusok utasításainak sorrendjét lehet ezekkel szervezni.
◦ Szekvencia:
▪ Ez a vezérlési szerkezet a benne megadott utasítások egyszeri, minden feltételtől
független, a megadás sorrendjében történő végrehajtását biztosítja
◦ Szelekció (if):
▪ Elágazás.
▪ Adott egy tulajdonság. A Szelekció programsorait csak akkor hajtjuk végre, ha a
tulajdonság igaz.
▪ Lehet egyágú vagy többágú elágazás is.
◦ Iteráció:
▪ A benne szereplő programrészt adott számszor, vagy egy tulajdonságtól függően újra
és újra végrehajtja.
▪ Létezik belőle elöltesztelő, hátultesztelő, igazra kiugró, hamisra kiugró és előírt
lépésszámú.