TT algoritmusok szoveg v014.pdf

A L G O R I T M U S O K
B M F K V K M A I
INFORMATIKA 1. Laborgyakorlat tananyag
Összeállította: Dr Tuzson Tibor docens
tuzson.tibor@kvk.bmf.hu; tuzsont@hdsnet.hu
2009. tavaszi félév
Tartalom jegyzék:
1. Bevezetı
1.1. Algoritmus fogalma
1.2. Algoritmus története
1.3. Komplexitás elmélet
2. Algoritmus C programok építı elemei, alap függvények
2.1. Két elem egyszerő cseréje.
2.2. Két elem cseréje: animáció késleltetı függvénnyel
3. Rendezı algoritmusok
3.1. Közvetlen beszúrás rendezés
3.2. Csere rendezés
3.3. Buborék rendezés
3.3.1. Buborék rendezés animálva
3.4. Shell rendezés
3.5. Rendezések: Összefoglalva menü rendszerbe
4. Keresı algoritmusok:
4.1. Szekvenciális keresés
4.1.1. Szekvenciális keresés egy tömbben az elsı egyezésig
4.1.2. Az összes elıfordulás szekvenciális keresése.
4.2. Szekvenciális és bináris ismétlıdı keresés függvények segítségével, de csak az elsı
egyezésig.
4.3. Legnagyobb és legkisebb egész keresése tömbben.
5. Oszthatósággal kapcsolatos algoritmusok:
5.1. Egy szám osztói.
5.1.1. Egy szám osztóinak kiszámítása for ciklussal
5.1.2. Egy szám osztóinak kiszámítása while ciklussal
5.1.3. Egy szám osztóinak kiszámítása do-while ciklussal
5.1.4. Egy szám osztóinak kiszámítása mindhárom elızı módszerre
5.2. Egy szám prímtényezıs felbontása szorzat és hatványkitevıs formátumban.
5.3. Legnagyobb közös osztó és legkisebb közös többszörös kiszámítása
5.3.1. LKO és LKT próbálkozásos módszerrel.
5.3.2. LKO és LKT törzszényezıs felbontással.
5.3.3. LKO és LKT Euklideszi algoritmussal.
6. Következtetések
7. Irodalomjegyzék
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
1/38

1. Bevezetı
Ez a rövid oktatási segédlet labor gyakorlatokat, mintaprogramokat tartalmaz a C programozást
tanuló hallgatók számára, minimális elméleti kiegészítésekkel. Nem helyettesíti az elıadások
anyagát!
Kizárólag az „algoritmusokkal foglalkozó” labor feladatokat tekinti át, a teljesség igénye nélkül. A
komplexebb programokat kis lépésekben építjük fel, így egyes elemek (pl. függvények)
ismétlıdnek. A tananyaghoz tartozó alapelemeket is változatosan igyekszik használni, ilyenek
például a ciklusok, feltételes utasítások, tömbkezelés, kiírás–beolvasás, függvények érték és
címszerinti átadással, stb.
A C programok egyszerőn másolva, CTR C / CTR V áthelyezhetıek a DEVC++ fejlesztı
programba. A mellékelt exe file-okkal meg leellenırizhetı, hogy mit is kell a programnak
végrehajtani. Ha valami hiba történ, ez segítséget nyújthat.
Az elméleti részt az elıadások és az irodalomjegyzékben szereplı bármelyik forrás szolgáltatja,
kiemelten az elıadások jegyzetei [1.], [2.], [3.], továbbá [4.], [5.], [6.], [7.], [8.].
Külön melléklet tartalmazza az összes önálló C forrás kódját és az exe futtatható file-ket is.
1.1. Algoritmus fogalma
Algoritmuson, vagy inkább eljáráson olyan módszert, utasítás(sorozato)t, részletes útmutatást,
receptet értünk, amely valamely felmerült probléma megoldására alkalmas [13], [14].
1.2. Algoritmus története
Az „algoritmus” kifejezés a perzsa tudós, al-Hvárizmí (Abú Dzsafar Muhammad bin Múszá al-
Hvárizmí) munkásságához kapcsolódik. Neve más írásmódban Muhammad ibn Musa Khwarizmi,
vagy Al-Khvorizmi, Al-Khorizmi, eredetiben:
Élt kb. 780-tól kb. 845-ig, szülıvárosa a perzsa Khwārizm, a mai Uzbekistanban van. Az algoritmus
szó szülıvárosából sdodó nevének eltorzított, rosszul latinra fordított változatából ered.[15]
1.3. Komplexitás elmélet
A Komplexitás elmélet a problémák (algoritmusok) megoldásának nehézségi fokával foglalkozik. A
komplexitással az algoritmust jellemezzük, ezért technológia független kell legyen. Tehát egy
algoritmus esetében mindegy, hogy még csöves számítógéppel, vagy már szubmikronos CMOS
eszközökkel implementáljuk. Ebben a fejezetben a témakör erısen leegyszerősítve kerül
bemutatásra. [17.], [18.], [19.], [20.].
Kétféle komplexitást defineálhatunk.
• A „térbeli” komplexitás: általában a feladat megoldásához szükséges tároló elemek, vagy
kapcsoló elemek (tranzisztorok, csövek) számával jellemezhetjük.
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
,
2/38

• Az „idıbeni” komplexitást nem a szükséges futási fizikai idıvel jellemzünk, ami
technológiafüggı paraméter, hanem a megoldáshoz szükséges kapcsolások, mőveletek vagy
utasítások számával.
Az egyik legfontosabb kérdés, hogy a bemenet növekedésével hogyan változik a komplexitás. De
mit is jelent a „bemenet”? Ha a bemenet számszerő, akkor figyelembe vehetjük a számok értékét.
Praktikusabb és elterjedtebb, amikor a bemenet nagyságán a bináris reprezentáció bitszámát értjük.
Gyakori az olyan helyzet, amikor nem tudjuk pontosan megbecsülni az algoritmus komplexitását,
de bizonyítani tudjuk, hogy biztosan nem komplexebb, mint egy ismert feladat.
f(n) =O(g(n))
n0
c.g(n)
f(n)
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
n
1. ábra: Nagy O jelölés [17.], [18.]
A „Nagy O” jelölés:
Az 1. ábra jelölései:
• n: a bejövı adatok mérete, általában bitekben.
• Függıleges tengely: Idı vagy térbeli
komplexitás.
• f(n): a vizsgált algoritmusunk komplexitása
• g(n): egy ismert algoritmus komplexitása
• Akkor mondjuk, hogy f(n) algoritmus
komplexitása O(g(n)), ha létezik egy n0 érték,
amitıl felfele, pontosabban, ha n>n0, c.g(n)
biztososan komplexebb mint f(n).
• c: egy konstans szám.
Ezzel egy felsı komplexitási határt határozunk meg
a vizsgált algoritmusunkra nézve.
A g(n) szokásos értékei: n; n 2 ; log n. Amennyiben a növekedést egy n változójú polinommal ki
lehet fejezni akkor polinomiális komplexitású algoritmusokról beszélünk. Ennek két osztályát
különböztetjük meg:
• P komplexitási osztály: amelyik determinisztikus algoritmusokkal polinomiális idıben fut.
Ebbe tartoznak, például a rejtjelezı algoritmusok.
• NP komplexitási osztály: amelyik nem determinisztikus algoritmusokkal polinomiális idıben
fut. Remélik, hogy ebbe tartoznak a rejtjelezést feltörı algoritmusok.
Az eddig körülírtak matematikai háttere jól kidolgozott. A kriptográfiában a kérdés éppen fordított.
A támadó algoritmusoknál, nem az a kérdés, hogy egy ismert algoritmus komplexitásánál biztosan
nem nehezebb a feladat, hanem fordítva, az a kérdés, hogy bizonyíthatóan minél nem könnyebb a
támadás. Ez a kérdés viszont új és a matematikai tudományok eddig nem adtak kellı megoldásokat
erre. Legalábbis a civil világban.
Érdemes megemlíteni, hogy a nagy O jelölésen kívül léteznek még: kis o, nagy Θ, nagy Ω, kis ω
komplexitási jelölések.
A 2. ábrán [17.], [18.], [19.] több komplexitási szint látható, de az említetteken kívül a többiek ma
nem játszanak szerepet a gyakorlati tudományokban.
3/38

2. ábra: Komplexitás osztályok [17.], [18.], [19.]
2. Algoritmus C programok építı elemei,
alap függvények
2.1. Menü szerkezet:
A késıbbi gyakorlatok egy része menü szerkezetbe lesz szervezve, ezért itt egy egyszerő
bevezetı példa függvény hívással:
/*MENUKEZELES EGYSZERU PELDA*/
#include
#include
void menu(int *sorszam);
EXPTIME - Complete
EXPTIME
PSPACE - Complete
PSPACE
NP-Complete
NP
P
int main()
{
int a=111 ,b=5,c, sor;
do
{
menu(&sor); /* cim szerinti parameter atadas*/
switch (sor)
{
case 1: c=a+b;
printf("\n Egesz osszeadas:\t%i=%i+%i\n",c,a,b);
break;
case 2: c=a-b;
printf("\n Egesz kivonas:\t\t%i=%i-%i\n",c,a,b);
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
4/38

eak;
case 3: c=a*b;
printf("\n Egesz szorzas:\t\t%i=%i*%i\n",c,a,b);
break;
case 4: c=a/b;
printf("\n Maradekos osztasn:\t%i=%i/%i\n",c,a,b);
break;
case 5: c=a%b;
printf("\n Maradekos osztas maradeka:\t%i=%i %%
%i\n",c,a,b);
break;;
}
fflush(stdin);
printf("\nESC: kilepes.\t\tENTER: Folytatas.\n");
}
while(getch()!=27);
return 0;
}
void menu(int *sorszam)
{
int kod;
do
{
printf("\n Valasszon aritmetikai muveletet: \n");
printf(" 1. Szamolja ki a+b\n");
printf(" 2. Szamolja ki a-b\n");
printf(" 3. Szamolja ki a*b\n");
printf(" 4. Szamolja ki a/b\n");
printf(" 5. Szamolja ki a %% b\n");
printf("\nA feladat sorszama: ");
scanf("%d",&kod);
}
while (kod 5);
*sorszam = kod; /* cim szerinti parameter atadas,
tehat nem return-nel*/
printf("\n");
}
/*Keszitette: Dr Tuzson Tibor*/
2.2. Két elem egyszerő cseréje.
A rendezı algoritmusok alap építıeleme két elem cseréje [7.]. Erre látunk itt egy egyszerő példát:
/*ALGORIMUSOK - RENDEZES - KET EGESZ CSEREJA KEPERNYO KIJELZESSEL
A program celja ket egesz felcserelese, ami
a rendezo algoritmusok alapja.*/
#include
#include
typedef int tomb[2]; // Tipusdefinicio
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
5/38

int main()
{
tomb a; /*legfeljebb 2 elemes tomb, lasd typedef*/
int i,s=0;
/* Beolvasas*/
printf("Ket elem csereje.\n Irjon be ket egesz szamot\n\n");
for (i = 0; i

int main()
{
tomb a; /*legfeljebb 2 elemes tomb, lasd typedef*/
int i,s=0,db=2;
/* Beolvasas*/
printf("Ket elem csereje.\n Irjon be ket egesz szamot\n\n");
for (i = 0; i

{
}
int i;
for (i = 0; i

}
system("PAUSE");
fflush(stdin);
return 0;
void olvas(tomb a, int *n) /* beolvaso függvény*/
{
int i, db;
do
{
printf("Elemek szama (max. 30): ");
scanf("%d",n);
}
while (*n < 2 || *n >20);
for (i = 0; i

}
/*Kiinduló forras: Computerbooks Benko Tiborne - Dr. Poppe Andras
Egyutt Konnyebb A Programozos - C Programozas
Programot módosította Dr Tuzson Tibor 2009*/
3.2. Csere rendezés
Az algoritmus elmélete részletesen megtalálható a [3.]-ban. A szoftver a [7.]-ben található
módosított változata.
/*ALGORIMUSOK - RENDEZES – CSERE max 30 elemes tombon
KEPERNYO KIJELZESSEL, FUGGVENYEKKEL ÉS ANIMACIO NELKUL*/
#include
#include
typedef int tomb[30]; /* Tipusdefinicio */
/*Függvenyek deklaracioi:*/
void olvas(tomb a, int *n); /*Tonbmeret es adatok beolvasasa, max
30 elem*/
void kiir(tomb a, int n); /* Tömb kiirás a képernyre*/
void csere(tomb a, int n); /* buborek rendezes*/
int main(void)
{
tomb x; /*legfeljebb 30 elemes tomb, lasd typedef*/
int i,s=0,db ,sor;
olvas(x,&db);
printf("\nCSERE rendezesi modszer novekvo
sorrendben\nKiindilasi tomb:\n\n\t\t");
kiir(x,db);
csere(x,db);
kiir(x,db);
system("PAUSE");
fflush(stdin);
return 0;
}
void olvas(tomb a, int *n) /* beolvaso függvény*/
{
int i, db;
do
{
printf("Elemek szama (max. 30): ");
scanf("%d",n);
}
while (*n < 2 || *n >20);
for (i = 0; i

}
}
void kiir(tomb a, int n) /* kiiro függvény*/
{
int i;
printf("Aktualis tomb =");
for (i = 0; i

*Függvenyek deklaracioi:*/
void olvas(tomb a, int *n); /* Tonbmeret es adatok beolvasasa,
max 30 elem */
void kiir(tomb a, int n); /* Tömb kiirás a képernyre*/
void buborek(tomb a, int n); /* buborek rendezes*/
int main()
{
tomb x; /*legfeljebb 30 elemes tomb, lasd typedef*/
int i,s=0,db ,sor;
olvas(x,&db);
printf("\nBuborek rendezesi modszer novekvo
sorrendben\nKiindilasi tomb:\n\n\t\t");
kiir(x,db);
buborek(x,db);
kiir(x,db);
system("PAUSE");
fflush(stdin);
return 0;
}
void olvas(tomb a, int *n) /* beolvaso függvény*/
{
int i, db;
do
{
printf("Elemek szama (max. 30): ");
scanf("%d",n);
}
while (*n < 2 || *n >20);
for (i = 0; i

void buborek(tomb a, int n)
{
int i,j, t;
for (i = 1; i=0 && a[j]>a[j+1]; j--) /* Ez a felteteles
csere*/
{
t = a[j];
a[j] = a[j+1];
a[j+1] = t;
printf(" %i Lepes: ",i-j);
kiir(a,n);
}
printf("\n%i Fordulo: ",i);
kiir(a,n);
}
}
/*Kiinduló forras: Computerbooks Benko Tiborne - Dr. Poppe Andras
Egyutt Konnyebb A Programozos - C Programozas
Programot módosította Dr Tuzson Tibor 2009*/
3.3.1. Buborék rendezés animálva
A következıben a buborékrendezést kiegészítettük egy késleltetı függvénnyel és animációval.
Remélhetıleg így izgalmasabban követhetıek a program lépései. A „delay” saját függvény név nem
túl szerencsés, mert az egy C függvényt is jelöl. Javasoljuk átírni „dly”-ra.
/*ALGORIMUSOK - RENDEZES - BUBOREK max 30 elemes tombon
KEPERNYO KIJELZESSEL, FUGGVENYEKKEL ÉS ANIMACIOVAL de meg hibas
nem megyy a delay */
#include
#include
typedef int tomb[30]; /* Tipusdefinicio */
/*Függvenyek deklaracioi:*/
void delay(int k); /* Kesleltetes, hogy animalni
lehessen a kepernyot*/
void olvas(tomb a, int *n); /* Tonbmeret es adatok beolvasasa,
max 30 elem */
void kiir(tomb a, int n); /* Tömb kiirás a képernyre*/
void buborek(tomb a, int n); /* buborek rendezes*/
int main()
{
tomb x; /*legfeljebb 30 elemes tomb, lasd typedef*/
int i,s=0,db ,sor,d=50000;
olvas(x,&db);
printf("\nBuborek rendezesi modszer novekvo
sorrendben\nKiindilasi tomb:\n\n\t\t");
kiir(x,db);
buborek(x,db);
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
13/38

}
kiir(x,db);
system("PAUSE");
fflush(stdin);
return 0;
void delay(int k) /* késleltetı föggvény*/
{
int m,n,l;
for(m=0;m

delay(1000);
for (j = i-1; j>=0 && a[j]>a[j+1]; j--) /* Ez a felteteles
csere*/
{
delay(1000);
t = a[j];
a[j] = a[j+1];
a[j+1] = t;
printf(" %i Lepes: ",i-j);
kiir(a,n);
}
printf("\n%i Fordulo: ",i);
kiir(a,n);
}
}
/*Kiinduló forras: Computerbooks Benko Tiborne - Dr. Poppe Andras
Egyutt Konnyebb A Programozos - C Programozas
Programot módosította Dr Tuzson Tibor 2009*/
3.4. Shell rendezés
Az algoritmus elmélete részletesen megtalálható a [3.]-ban. A szoftver a [7.]-ben található adaptált
változata.
/*ALGORIMUSOK - RENDEZES - SHELL max 30 elemes tombon
KEPERNYO KIJELZESSEL, FUGGVENYEKKEL ÉS ANIMACIO NELKUL*/
#include
#include
typedef int tomb[30]; /* Tipusdefinicio */
/*Függvenyek deklaracioi:*/
void olvas(tomb a, int *n); /* Tonbmeret es adatok beolvasasa,
max 30 elem */
void kiir(tomb a, int n); /* Tömb kiirás a képernyre*/
void shell(tomb a, int n); /* kozvetlen beszúrásos rendezes*/
int main()
{
tomb x; /*legfeljebb 30 elemes tomb, lasd typedef*/
int i,s=0,db ,sor;
olvas(x,&db);
printf("\n Shell rendezesi modszer novekvo
sorrendben\nKiindilasi tomb:\n\n\t");
kiir(x,db);
shell(x,db);
printf("\t");
kiir(x,db);
system("PAUSE");
fflush(stdin);
return 0;
}
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
15/38

void olvas(tomb a, int *n) /* beolvaso függvény*/
{
int i, db;
do
{
printf("Elemek szama (max. 30): ");
scanf("%d",n);
}
while (*n < 2 || *n >20);
for (i = 0; ia[j+k]; j -= k)
{
t = a[j];
a[j] = a[j+k];
a[j+k] = t;
printf("Lepes: ");
kiir(a,n);
}
printf("\nFordulo:");
kiir(a,n);
}
}
}
/*Kiinduló forras: Computerbooks Benko Tiborne - Dr. Poppe Andras
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
16/38

Egyutt Konnyebb A Programozos - C Programozas
Programot módosította Dr Tuzson Tibor 2009*/
3.5. Rendezések: Összefoglalva menü rendszerbe
Az algoritmus elmélete részletesen megtalálható a [3.]-ban. A szoftver a [7.]-ben található adaptált
változata. Az eddigi rendezú algoritmusok összefoglalálsa menüvel ellátott egy mintaprogramban,.
/*RENDEZESEK*/
#include
#include
typedef int tomb[30];
void menu(int *sorszam);
void olvas(tomb a, int *n);
void kiir(tomb a, int n);
void buborek(tomb a, int n);
void csere(tomb a, int n);
void kozvetlen(tomb a, int n);
void shell(tomb a, int n);
int main()
{
tomb x;
int db ,sor;
menu(&sor);
switch (sor)
{
case 1: olvas(x,&db); csere(x,db);
printf("\nCsere modszer\n"); kiir(x,db);
break;
case 2: olvas(x,&db); kozvetlen(x,db);
printf("\nKozvetlen beszuras\n"); kiir(x,db);
break;
case 3: olvas(x,&db); buborek(x,db);
printf("\nBuborek modszer\n"); kiir(x,db);
break;
case 4: olvas(x,&db); shell(x,db);
printf("\nShell modszer\n"); kiir(x,db);
break;
case 5: ;
}
fflush(stdin);
system("PAUSE");
return 0;
}
void olvas(tomb a, int *n)
{
int i, db;
do
{
printf("Elemek szama (max. 20): "); scanf("%d",n);
}
while (*n < 2 || *n >20);
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
17/38

for (i = 0; i

}
a[j] = a[j+1];
a[j+1] = t;
}
void shell(tomb a, int n)
{
int i,j, t, k;
for (k = n/2; k>0; k = k/2)
{
for (i = k; i=0 && a[j]>a[j+k]; j -= k)
{
t = a[j];
a[j] = a[j+k];
a[j+k] = t;
}
}
}
}
void menu(int *sorszam)
{
int kod;
do {
printf(" Rendezes modszerei \n");
printf(" 1. Csere\n");
printf(" 2. Kozvetlen beszuras\n");
printf(" 3. Buborek\n");
printf(" 4. Shell\n");
printf(" 5. Kilepes\n");
printf("\nA modszer sorszama: ");
scanf("%d",&kod);
}while (kod 5);
*sorszam = kod;
printf("\n");
}
4. Keresı algoritmusok:
Az algoritmus elmélete részletesen megtalálható a [3.]-ban. A szoftverek a [7.]-ben találhatóak
módosított változatai. Szekvenciális és bináris keresésre készült gyakorló program.
4.1. Szekvenciális keresés
Gyakorlási céllal kétféle szekvenciális keresı mintaprogram kerül bemutatásra.
4.1.1. Szekvenciális keresés egy tömbben az elsı egyezésig
Ez a mintaprogram egy meghatározott hosszúságú egész tömbben megkeresi a megadott érték elsı
elıfordulását. Az egész tömböt egy megadott hosszig egy saját függvénnyel billentyőzetrıl töltjük
fel.
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
19/38

*KERESES 1x1*/
/* Csak szekvenciális keresés: egyszer keresi az elsı egyezést.
Helyes kérdés: Van-e vagy sincs legalább egy megfelelı érték a
tönbben? */
#include
#define DB 50 /*Maximlis tombméret amiben keresünk*/
typedef int itomb[DB+1];
typedef int ibuff;
void olvas_int(itomb x, int *m);
int seq_keres(itomb, int, ibuff);
int bin_keres(itomb, int, ibuff );
int main()
{
itomb y;
int n, j, k, t;
ibuff adat;
olvas_int(y,&n);
printf("\nSzekvencialis kereses\n");
printf("adat : "); scanf("%d",&adat);
t = seq_keres(y,n,adat);
if(t >= 0)
printf("%d helye %d\n",adat,t);
else printf("%d hibas adat!\n",adat);
}
fflush(stdin);getchar();
return 0;
void olvas_int(itomb x, int *m)
{
int i;
printf("Egesz tipusu adatok beolvasasa\n");
do
{
printf("Az adatok szama, max=%i : ",DB); scanf("%d",m);
if (*m > DB) printf("Az adatok max. szama : %d ",DB);
}
while (*m < 2 || *m > DB);
}
for ( i = 0; i < *m; i++)
{
printf(" [%2d] = ",i); scanf("%d",&x[i]);
}
int seq_keres(itomb x, int m, ibuff adat)
{
int i = 0;
while ( adat != x[i] && i < m ) { i = i+1; }
if (i >= m) return -1;
else return i;
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
20/38

}
/*Kiinduló forras: Computerbooks Benko Tiborne - Dr. Poppe Andras
Egyutt Konnyebb A Programozos - C Programozas
Programot módosította Dr Tuzson Tibor 2009*/
4.1.2. Az összes elıfordulás szekvenciális keresése.
Ez a mintaprogram abban tér el az elızıtıl, hogy a keresett érték összes elıfordulását kilistázza a
képernyıre, de csak egyszer keres. A [7.] alapján adaptálva.
/*KERESES 1x1*/
/* Csak szekvenciális keresés: egyszer keresi az összes egyezést.
Helyes kérdés: Van-e vagy sincs legalább egy megfelelı érték a
tömbben? */
#include
#define DB 50 /*Maximlis tombméret amiben keresunk*/
typedef int itomb[DB+1];
typedef int ibuff;
void olvas_int(itomb x, int *m);
int seq_keres(itomb, int, ibuff);
int main()
{
itomb y;
int n, j, k, t;
ibuff adat;
char c;
olvas_int(y,&n);
printf("\nAy osszes egyezes szekvencialis keresese\n");
while (1)
{
printf("\nadat : ");
scanf("%d",&adat);
t = seq_keres(y,n,adat);
printf ("\nKivanja folytatni? \n n = NEM\n barmi mas =
folytatas\n");
}
if(getch()=='n') break;
}
fflush(stdin);;
return 0;
void olvas_int(itomb x, int *m)
{
int i;
printf("Egesz tipusu adatok beolvasasa\n");
do
{
printf("Az adatok szama, max=%i : \t",DB); scanf("%d",m);
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
21/38

}
if (*m > DB) printf("Az adatok max. szama : %d \n",DB);
}
while (*m < 2 || *m > DB);
for ( i = 0; i < *m; i++)
{
printf(" [%2d] = ",i); scanf("%d",&x[i]);
}
int seq_keres(itomb x, int m, ibuff adat)
{
int i=0;
printf("\n");
for ( i = 0; i < m; i++)
{
if(adat==x[i])
printf("%d helye %d\n",adat,i);
}
}
/*Kiinduló forras: Computerbooks Benko Tiborne - Dr. Poppe Andras
Egyutt Konnyebb A Programozos - C Programozas
Programot módosította Dr Tuzson Tibor 2009*/
4.2. Szekvenciális és bináris ismétlıdı keresés függvények segítségével, de csak az elsı
egyezésig.
/*KERESES*/
/* szekvenciális és bináris keresés */
#include
#define DB 50 /*Maximlis tombméret amiben keresünk*/
typedef int itomb[DB+1];
typedef int ibuff;
void olvas_int(itomb x, int *m);
int seq_keres(itomb, int, ibuff);
int bin_keres(itomb, int, ibuff );
int main()
{
itomb y;
int n, j, k, t;
ibuff adat;
olvas_int(y,&n);
printf("\nSzekvencialis kereses\n");
printf("Keresesek szama: "); scanf("%d",&k);
for (j = 1; j= 0)
printf("%d helye %d\n",adat,t);
else printf("%d hibas adat!\n",adat);
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
22/38

}
}
printf("\nBinaris kereses\n");
printf("Keresesek szama: "); scanf("%d",&k);
for (j = 1; j = 0)
printf("%d helye %d\n",adat,t);
else printf("%d hibas adat!\n",adat);
}
fflush(stdin);getchar();
return 0;
void olvas_int(itomb x, int *m)
{
int i;
printf("Egesz tipusu adatok beolvasasa\n");
do
{
printf("Az adatok szama, max=%i : ",DB); scanf("%d",m);
if (*m > DB) printf("Az adatok max. szama : %d ",DB);
}
while (*m < 2 || *m > DB);
}
for ( i = 0; i < *m; i++)
{
printf(" [%2d] = ",i); scanf("%d",&x[i]);
}
int seq_keres(itomb x, int m, ibuff adat)
{
int i = 0;
while ( adat != x[i] && i < m ) { i = i+1; }
if (i >= m) return -1;
else return i;
}
int bin_keres(itomb x, int m, ibuff adat)
{ int a,f,k, talal;
a = 0; f = m;
talal = 0;
while ( a < f && ! talal)
{
k = (a+f) / 2;
if (adat < x[k]) f = k-1;
else
if (adat > x[k]) a = k+1;
else talal = 1; /* megtalálta */
}
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
23/38

if( talal) return k;
else return -1; /* nem talált */
} /* bin_keres */
/*Kiinduló forras: Computerbooks Benko Tiborne - Dr. Poppe Andras
Egyutt Konnyebb A Programozos - C Programozas
Programot módosította Dr Tuzson Tibor 2009*/
4.3. Legnagyobb és legkisebb egész keresése tömbben.
A billentyőzetrıl feltöltött egész tömbben keresi a maximum és a minimum értékeket. A program,
egy késleltetı függvény segítségével animáltan írja ki a részeredményeket is
/*ALGORIMUSOK - Minimum - maximum kereses egy 30 elemes tombon,
KEPERNYO KIJELZESSEL, FUGGVENYEKKEL ÉS ANIMACIOVAL */
#include
#include
typedef int tomb[30]; /* Tipusdefinicio */
/*Függvenyek deklaracioi:*/
void olvas(tomb a, int *n); /* Tonbmeret es adatok beolvasasa,
max 30 elem */
int max(tomb a, int n);
int min(tomb a, int n);
void dly(int k);
int main()
{
tomb x; /*legfeljebb 30 elemes tomb, lasd typedef*/
int i,s=0,db ,maximum, minimum;
olvas(x,&db);
printf("\nMaximum kereses:\n\n");
maximum=max(x,db);
printf("\nMinimum kereses\n\n");
minimum=min(x,db);
}
system("PAUSE");
fflush(stdin);
return 0;
void olvas(tomb a, int *n) /* beolvaso függvény*/
{
int i, db;
do
{
printf("Elemek szama (max. 30): ");
scanf("%d",n);
}
while (*n < 2 || *n >30);
for (i = 0; i

}
}
scanf("%d",&a[i]);
int max(tomb a, int n)
{
int i=0,j=0,mx;
mx=a[0];
for (i = 1; i mx)
{
printf("\nAz eddig megtalalt maximum= %i, ami az \t%i-dik
elem a tombben.\n",mx,j);
dly(800);
mx=a[i];
j=i;
}
}
printf("\n A tomb maximuma= %i, az \t%i-dik elem a
tombben.\n\n",mx,j);
return mx;
}
int min(tomb a, int n)
{
int i=0,j=0,mn;
mn=a[0];
for (i = 1; i

{
for(l=0;l

{
if (szam % oszto == 0)
{ printf("%8d",oszto); van++; }
}
if (!van) printf(" Primszam!\n");
}
/*Kiinduló forras: Computerbooks Benko Tiborne - Dr. Poppe Andras
Egyutt Konnyebb A Programozos - C Programozas
Programot módosította Dr Tuzson Tibor 2009*/
5.1.2. Egy szám osztóinak kiszámítása while ciklussal
/*Egy szam osztoit irja ki a kepernyore.
Nem csak a primtenyezoket adja vissza.
Es egyszeru primteszt While ciklussal.*/
#include
#include
void oszto2(long int szam);
int main()
{
int x;
do
{
printf("Szam (>2): "); scanf("%d",&x);
}
while (x

Programot módosította Dr Tuzson Tibor 2009*/
5.1.3. Egy szám osztóinak kiszámítása do-while ciklussal
/*Egy szam osztoit irja ki a kepernyore. Nem csak a primtenyezoket
Es egyszeru primteszt do-while ciklussal*/
#include
#include
void oszto3(long int szam);
int main()
{
int x;
do
{
printf("Szam (>2): "); scanf("%d",&x);
}
while (x

*Egy szam osztoit irja ki a kepernyore, harom modszerrel. Nem
csak a primtenyezoket Es egyszeru primteszt.*/
#include
#include
void oszto1(long int szam);
void oszto2(long int szam);
void oszto3(long int szam);
int main()
{
int x;
do
{
printf("Szam (>2): "); scanf("%d",&x);
}
while (x

}
oszto = 2;
while (oszto

#include
int main()
{
int x;
do{
printf("Szam: "); scanf("%d",&x);
}while (x 0)
{
printf("\nTorzstenyezok:\n");
oszto = 2;
while (szam != 1 && szam > 0)
{
while (szam %oszto != 0)
{
oszto++;
}
szam /= oszto;
printf("%d",oszto);
if (szam != 1)
printf(" * ");
}
}
}
void hatvanykitevos(int szam)
/* a szam felbontása hatványkitevıs alakra*/
{
int oszto = 2, hatv = 1, elozo = 1;
if (szam != 1 && szam > 0)
{
printf("\n\nHatvanykitevos alak:\n");
while (szam != 1 && szam > 0)
{
while (szam % oszto != 0)
{
oszto++;
}
szam /= oszto;
if (oszto == elozo)
hatv++;
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
31/38

else
{
if (elozo != 1)
{
if (hatv > 1)
printf("%d^%d*",elozo, hatv);
else
printf("%d*",elozo);
}
hatv = 1;
}
elozo = oszto;
if (szam == 1)
if (hatv > 1)
printf("%d^%d",oszto,hatv);
else
printf("%d",oszto);
}
}
}
/*Kiinduló forras: Computerbooks Benko Tiborne - Dr. Poppe Andras
Egyutt Konnyebb A Programozos - C Programozas
Programot módosította Dr Tuzson Tibor 2009*/
15.3. Legnagyobb közös osztó (LKO) és legkisebb közös többszörös (LKT) kiszámítása
A következı mintaprogramok az LKO és LKT kiszámításával foglalkozik. Három módszer fogunk
látni, a próbálkozásos (leglassúbb), a törzstényezıs felbontásos és az Euklideszi algoritmuson
alapuló megoldásokat.
5.3.3. LKO és LKT próbálkozásos módszerrel.
/* Az LKO és LKT kiszámítása próbálkozásos módszerrel.*/
#include
#include
void Vegigprobal(int szam1, int szam2);
int main(void)
{
unsigned int x, y;
do
{
printf("1. Szam: "); scanf("%d",&x);
}
while (x < 2);
do
{
printf("2. Szam: "); scanf("%d",&y);
}
while (x < 2);
Vegigprobal(x,y);
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
32/38

}
fflush(stdin);
getchar();
return 0;
void Vegigprobal(int szam1, int szam2)
{
unsigned int eddig, oszto, kozos =1, v;
printf("\nVegigprobal modszerrel\n\n");
if (szam1 > 0 && szam2 > 0)
{
eddig = szam1;
if (szam2 < eddig)
eddig = szam2;
for (oszto = 2; oszto

}
getchar();
return 0;
void Torzstenyezok_lnko(int szam1, int szam2)
{
int s1, s2, lktobb, oszto1, oszto2, v;
printf("\n\nTorzstenyezokre bontas modszerrel\n\n");
if (szam1 > 0 && szam2 > 0)
{
s1 = szam1;
s2 = szam2;
lktobb = 1;
while (szam2 != 1 || szam1 != 1)
{
oszto1 = 2;
oszto2 = 2;
while (szam1 != 1)
{
while (szam1 % oszto1 != 0)
{
oszto1++;
}
if (szam2 % oszto1 == 0)
szam2 /= oszto1;
lktobb*= oszto1;
szam1 /= oszto1;
}
while (szam2 != 1)
{
while (szam2 % oszto2 != 0)
{
oszto2++;
}
szam2 /=oszto2;
lktobb*=oszto2;
}
}
v = s1*s2/lktobb;
printf("Legnagyobb kozos oszto: %d\n",v);
printf("Legkisebb kozos tobbszoros: %d",lktobb);
}
}
/*Kiindulo forras: Computerbooks Benko Tiborne - Dr. Poppe Andras
Együtt Konnyebb a Programozas - C Programozas
Programot modosította Dr Tuzson Tibor 2009*/
5.3.3. LKO és LKT Euklideszi algoritmussal [17.], [18.].
Az Euklideszi algoritmus, ismételt maradékos egész osztásokból áll. Az algoritmus
eredményeképpen a b és a c legnagyobb közös osztóját (LKO) kapjuk meg. A program végén
kiszámítjuk az LKT-t is.
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
34/38

A jelölések:
• b: kiinduló osztandó (nagyobbik egész szám)
• c: kiinduló osztó (kisebbik egész szám)
• qn: egész osztás eredménye (C nyelven a b/c mővelet eredménye). Ez érdektelen a LKO
számításnál.
• rn: egész osztás maradéka (C nyelven a b%c mővelet eredménye). Ez, amit ki kell számolni,
mert az Euklideszi algoritmus ciklusaiban ez megy tovább.
r
r
b
c
1
n − 2
r
n − 1
tehát
( b , c )
=
igy
=
=
=
( r
r
n − 1
:
r
cq
1
=
2
=
q
q
:
r
=
r
,
1
2
3
n − 1
n
M
( c ,
r
+
+
q
n
+
q
r
r
r
n
n + 1
)
1
2
r
3
=
1
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
+
+
)
r
n
r
0
=
n
( b , c )
( r
=
1
r
, 0
, 0
, 0
,
n
r
2
<
<
<
)
r
r
r
, 0
=
3
1
2
<
<
<
<
, 0
r
c
r
r
n
=
1
2
<
r
r
n + 1
( euk
Az Euklideszi algoritmust a fentebb látható képletekkel írhatjuk le. Itt található annak a bizonyítása
is, hogy az utolsó nem nulla maradék, valójában a kiinduló két szám, b és c LKO-ja. [17.], [18.].
Érdemes megfigyelni, hogy egy kicsit „nehezebb” matematikai módszer segítségével a
bonyolultnak látszó LKO számítása, valójában egyetlen mővelet (%) és két adatmozgató utasításból
áll. Leszámítva a ciklusszervezı és a printf-scanf beolvasó-kiíró mőveleteket.
L
M
n − 1
2 )
/* Az LKO, Legnagyobb Kozos Oszto szamitasa az Euklideszi
algoritmus segitsegevel.
Maximalis szam 4 byte, azaz
int változók esetében: 0x7FFFFFFF = 2147483647
unsignek int esetében: 0xFFFFFFFF = 4294967294
LKT esetében az eredmény kell ebbe beleférjen
Fermat Primek
FP1 = 0x00010001 = 2^16+1=65537
FPn = 3, 5, 17, 257 (?)
Javasolét teszt szamparok:
LKO=3 : 196611 51
35/38

LKO=7 : 458759 238
LKO=11 7929977 407
LKO=1578 103417386 36294
*/
#include
#include
int lko(unsigned int x, unsigned int y);
int lkt(unsigned int x, unsigned int y, unsigned int z);
int main(void)
{
unsigned int a,b,l,t; /* b < a*/
printf("Kerek egy szamot szamot:\t"); scanf("%i",&a);
printf("\nKerem egy masik szamot:\t");scanf("%i",&b);
l=lko(a,b);
printf("\n\nAz %i es %i legnagyobb kozosd osztoja LKO=
%i\n",a, b,l);
t=lkt(a,b,l);
printf("\n\nAz %i es %i legnagyobb kozosd osztoja LKT=
%i\n\n",a, b,t);
system("PAUSE");
return 0;
}
int lko(unsigned int x, unsigned int y) /* y < x */
{
unsigned int m; /* Ha y > x akkor csere */
if(y>x)
{
m=x;
x=y;
y=m;
}
while (y != 0)
{
m = x % y;
x = y;
y = m;
}
return x;
}
int lkt(unsigned int x, unsigned int y, unsigned int z)
{
unsigned int v;
v= x*y/z;
return v;
}
/*Keszitette: Dr Tuzson Tibor*/
Érdemes megjegyezni, hogy az Euklideszi algoritmus kibıvitett változata alkamlas a modilo egész
multiplikaív inverzek számítására is.
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
36/38

6. Következtetések
Ez az oktatási segédlet, a teljesség igény nélkül, a C programnyelven megírt algoritmusok
alaptípusaival foglalkozik. Változatosan próbálja alkalmazi az alap programozási megoldásokat.
A teljességhez számos további alkalmazás bemutatása is hasznos lenne. A rendelkezésre álló 30 óra
Informatika 1. laborgyakorlat, sajnos még ezek gyakorlására sem elégséges. Ennek dacára néhány
jelentıs algoritmus további bemutatása, a legjobb, legszorgalmasabb hallgatók érdeklıdésének
megfelelıen, a késöbbiekben meg fog történni. Csak néhény példát említve:
• A kis és nagy Fermát tétel bemutatása.
• DFT (Diskret Fourie Transzformált) egyszerő diszkrét spektrum analízis példája.
• Shanon mintavételi tételének érzékeltetése, a filmekben ismert Western Szekér kerekének a
visszafele forgásának szimulálásával.
• Modulo egész multiplikatív inverz számítása a kibıvitet Euklideszi algoritmussal.
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
37/38

7. Irodalomjegyzék:
[1.] Dr. Schuster György-Dr. Simán István: C programozás Borland C++ 3.11 környezetben;
2006, BMF
[2.] Sándor Tamás: Algoritmusok; Kézírat
[3.] Sándor Tamás. Takács Gergı: Informatika alapjai II. Távoktatás CD:
Dr. Schuster György Sándor Tamás: Algoritmusok
[4.] http://kvkmai.uw.hu/tantargy.php: BMF KVK MAI honlapja.
[5.] http://venekeiatt.uw.hu/ Venekei Attila honlapja.
[6.] http://mohos.uw.hu/2008_9_1/ Mohos Pál honlapja.
[7.] Benkı Tiborné - Dr. Poppe AndrÁs - Együtt Könnyebb a Programozás - C Programozás
Computerbooks 1994
[8.] http://www.cprogramming.com/tutorial.html : Programming Tutorials
[9.] Cormen, Leiserson, Rivest: Algoritmusok; Mőszaki kk. 1997
[10.] Pere László: UNIX – GNU/Linux; Programozás C nyelven
[11.] http://maven.smith.edu/~thiebaut/java/sort/
D. Thiebaut, -- Smith College;
Rendezı algoritmusok ötféle animációja.
[12.] http://www.cs.pitt.edu/~kirk/cs1501/animations/Sort1.html
(University of Pittsburg, Dpt. of Computer Science). Rendezı algoritmusok ötféle
animációja.
[13.] http://en.wikipedia.org/wiki/Algorithm
Algorithm: From Wikipedia, the free encyclopedia
[14.] http://hu.wikipedia.org/wiki/Algoritmus Algoritmus
[15.] http://hu.wikipedia.org/wiki/Algoritmus#Az_algoritmusfogalom_t.C3.B6rt.C3.A9nete Az
algoritmusfogalom története
[16.] http://hu.wikipedia.org/wiki/Legnagyobb_k%C3%B6z%C3%B6s_oszt%C3%B3
Legnagyobb közös osztó
[17.] Dr Tuzson Tibor: Adatbiztonság és kriptográfia; BMF KVK fakultatív tanfolyam oktatási
segédlete
[18.] Dr Tuzson Tibor: Adat és Információ Védelem; BMF BGK BT tanfolyam oktatási segédlete
[19.] Alfred J. Menezes, Paul C. van Oorschot and Scott A. Vanstone: Handbookof Applied
Cryptography, CRC Press 2001
[20.] Bruce Schneier: Applied Cryptography: Protocols, Algorithms, and Source Code in C,
Second Edition, John Wiley and Sons Inc., New York, 1996.
[21.] How-Shen Chang: International Data Encryption Algorithm; CS-627-1; Fall 2004. James
Madison University, Harrisonburg
https://users.cs.jmu.edu/abzugcx/public/Student-Produced-Term-Projects/Cryptology-2002-
SPRING/IDEA-by-How-Shen-Chang-2004-FALL.doc
[22.] B. W. Kernighan, D. M. Ritchie.: A C programozási nyelv Mőszaki Könyvkiadó, 1985.
ALGORITMUSOK: Informatika 1. Laborgyakorlat; Összeállította: Dr Tuzson Tibor docens
38/38