Alapvető algoritmusok C# függvények formában

Az alábbiakban ismertetünk néhány egyszerű algoritmust C# nyelvi függvények formájában megírva. A függvények paraméterként fogadják a vektorokat, és a működésükhöz szükséges további adatokat.

Feltöltés billentyűzetről I.

Egy 'N' elemű 'int' vektor elemeinek bekérése, feltöltés billentyűzetről.

public static void Feltoltes_Billentyuzetrol(int[] t)
{
for(int i=0;i<t.Length;i++)
{
Console.Write("Kerem a tomb {0}. elemenek erteket:",i);
int x = int.Parse( Console.ReadLine() );
t[i] = x;
}
}

Feltöltés billentyűzetről II.

Egy 'N' elemű 'int' vektor elemeinek bekérése, feltöltés billentyűzetről. Egyszerű szabály alkalmazása a bekért értékekre, pl. csak [1,100] közötti számokat fogadhatunk el:

public static void Feltoltes_Billentyuzetrol(int[] t)
{
int i=0;
while (i<t.Length)
{
Console.Write("Kerem a tomb {0}. elemenek erteket:",i);
int x = int.Parse( Console.ReadLine() );
if (1<=x && x<=100)
{
t[i] = x;
i++;
}
else Console.WriteLine("Nem elfogadható érték.");
}
}

Feltöltés billentyűzetről III.

Egy 'N' elemű 'int' vektor elemeinek bekérése, feltöltés billentyűzetről. Kivételtekezelés alkalmazása a hibás értékbevitel kiszűrésére, és a program leállásának megakadályozására:

public static void Feltoltes_Billentyuzetrol(int[] t)
{
int i=0;
while (i<t.Length)
{
Console.Write("Kerem a tomb {0}. elemenek erteket:",i);
int x;
try
{
x = int.Parse( Console.ReadLine() );
t[i] = x;
i++;
}
catch { Console.WriteLine("Nem feldolgozgató érték, nem egész szám."); }
}
}

Feltöltés véletlen értékekkel

Egy adott 'N' elemű 'int' vektor feltöltése véletlen értékekkel valamely ['a','b'] intervallumból. Az intervallum 'a' és 'b' értékei is paraméterként adottak:

public static void Feltoltes_VeletlenSzamokkal(int[] t, int a, int b)
{
Random rnd = new Random();
for (int i=0;i<t.Length;i++)
{
t[i] = rnd.Next(a,b+1);
}
}

Vektor feltöltése véletlen értékekkel, ismétlődés nélkül

Egy adott 'N' elemű 'int' vektor feltöltése véletlen értékekkel valamely ['a','b'] intervallumból. Az intervallum 'a' és 'b' értékei is paraméterként adottak. A vektoron belül nem választhatunk ki két egyforma értéket, tehát a feltöltés során ismétlődés nem lehet (halmazszerű eredmény):

public static void Feltoltes_NincsIsmetlodes(int[] t, int a, int b)
{
Random rnd = new Random();
int i = 0;
while (i<t.Length)
{
int x = rnd.Next(a,b+1);
bool egyenlo_e = false;
for (int j=0;j<i;j++)
{
if (x==t[j])
{
egyenlo_e=true;
break;
}
}
if (egyenlo_e==false)
{
t[i]=x;
i++;
}
}
}

Vektor feltöltése eleve rendezett, de véletlenszerű értékekkel

Egy adott 'N' elemű 'int' vektor feltöltése véletlen értékekkel. A feltöltött tömb eleve rendezett állapotban lesz, de véletlenszerűnek tűnő módon. Választhatnánk azt is, hogy feltöltjük véletlen számokkal, majd a tömböt rendezzük valamely rendezőalgoritmussal, de ezen mód, amely a következőkben ismertetésre kerül eleve ezt az eredményt adja:

public static void Feltoltes_Rendezett(int[] t, int a, int b, int c)
{
Random rnd = new Random();
t[0] = rnd.Next(a,b+1);
for (int i=1;i<t.Length;i++)
{
t[i] = t[i-1]+rnd.Next(1,c+1);
}
}

Vektor feltöltése eleve rendezett, de véletlenszerű értékekkel

Egy adott 'N' elemű 'int' vektor feltöltése véletlen értékekkel, melyek egy adott intervallumból kerülnek ki. Ezen intervallum első eleme paraméterként adott ('a'). Az intervallum szélessége megegyezik a tömb számosságával, vagyis az intervallumból minden elem bekerül a tömbbe, és minden elem csakis egyszer kerül kiválasztásra (ismétlődés nem fordulhat elő):

public static void Feltoltes_IntervallumMindenEleme(int[] t, int a)
{
for (int i=0;i<t.Length;i++)
t[i]=a+i;

Random rnd = new Random();
for (int i=0;i<t.Length;i++)
{
int j = rnd.Next(t.Length);
int k = rnd.Next(t.Length);
int x = t[j];
t[j]=t[k];
t[k]=x;
}
}

Vektor elemeinek összegzése

Állapítsuk meg, mennyi egy adott 'N' elemű vektorban lévő elemek összege:

public static int Oszzegkepzes(int[] t)
{
int sum = 0;
for(int i=0;i<t.Length;i++)
sum += t[i];
return sum;
}

Vektor elemeinek átlagának meghatározása

Állapítsuk meg, mennyi egy adott 'N' elemű vektorban lévő elemek átlaga:

public static double Atlagkepzes(int[] t)
{
int sum = 0;
for(int i=0;i<t.Length;i++)
sum += t[i];
return (double)sum/t.Length;
}

Vektor elemeinek szorzatát

Állapítsuk meg egy adott 'N' elemű vektor elemeinek szorzatát:

public static int SzorzatKepzes(int[] t)
{
int prod = 1;
for(int i=0;i<t.Length;i++)
prod *= t[i];
return prod;
}

Eldöntés tétele I. (while)

Állapítsuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték):

public static bool Eldontes_WHILE(int[] t)
{
// T tulajdonsßg: 80tˇl nagyobb szßm
int i=0;
while (i<t.Length && !(t[i]>80)) i++;
bool van = i<t.Length;
return van;
// if (van==true)Console.WriteLine("Van benne 80tól nagyobb elem");
// else Console.WriteLine("Nincs benne ilyen elem"); }
}

Eldöntés tétele II. (for)

Állapítsuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték):

public static bool Eldontes_FOR(int[] t)
{
// T tulajdonsßg: 80tól nagyobb szßm
for (int i=0;i<t.Length;i++)
if (t[i]>80) return true;
return false;
}

Eldöntés tétele III. (foreach)

Állapítsuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték):

public static bool Eldontes_FOREACH(int[] t)
{
// T tulajdonsßg: 80tˇl nagyobb szßm
foreach(int a in t)
if (a>80) return true;
return false;
}

Kiválasztás tétele I. (while, első elem)

Határozzuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték). Ha előfordul, adjuk meg az első ilyen elem indexét. Ha nem fordul elő, akkor '-1'-el jelezzük ezt a tényt:

public static int Kivalasztas_LegelsoElem_WHILE(int[] t)
{
// T tulajdonsßg: 80tól nagyobb szßm
int i=0;
while (i<t.Length && !(t[i]>80)) i++;
if (i<t.Length) return i; // van ilyen elem
return -1; // nincs ilyen elem
}

Kiválasztás tétele II. (for, első elem)

public static int Kivalasztas_LegelsoElem_FOR(int[] t)
{
// T tulajdonsßg: 80tˇl nagyobb szßm
for (int i=0;i<t.Length;i++)
if (t[i]>80) return i;
return -1;
}

Kiválasztás tétele III. (foreach, első elem)

public static int Kivalasztas_LegelsoElem_FOREACH(int[] t)
{
// T tulajdonsßg: 80tól nagyobb szßm
int i=0;
foreach(int a in t)
{
if (a>80) return i;
i++;
}
return -1;
}

Kiválasztás tétele IV. (while, utolsó elem)

Határozzuk meg, hogy egy adott 'N' elemű vektorban előfordul-e adott T tulajdonságú elem (jelen példában 80-nál nagyobb érték). Ha előfordul, adjuk meg az utolsó ilyen elem indexét. Ha nem fordul elő, akkor '-1'-el jelezzük ezt a tényt:

public static int Kivalasztas_LegutolsoElem_WHILE(int[] t)
{
// T tulajdonság: 80tól nagyobb szám
int i=t.Length-1;
while (i>=0 && !(t[i]>80)) i--;
if (i>=0) return i; // van ilyen elem
return -1; // nincs ilyen elem
}

Kiválasztás tétele V. (for, utolsó elem)

public static int Kivalasztas_LegutolsoElem_FOR(int[] t)
{
// T tulajdonság: 80tól nagyobb szám
for (int i=t.Length-1;i>=0;i--)
if (t[i]>80) return i;
return -1;
}

Minimumkiválasztás tétele I. (for, érték)

Határozzuk meg, hogy egy adott 'N' elemű vektorban előforduló legkisebb elem értékét:

public static int MinimalisElem_Erteke(int[] t)
{
int min = t[0];
for(int i=1;i<t.Length;i++)
if (min>t[i]) min=t[i];
return min;
}

Minimumkiválasztás tétele II. (for, index, első)

Határozzuk meg, hogy egy adott 'N' elemű vektorban előforduló legkisebb elem indexét. Ha ez az érték többször is előfordulna, akkor az első előfordulás indexét kell megadni:

public static int MinimalisElem_Pozicioja_1(int[] t)
{
int minI = 0;
for(int i=1;i<t.Length;i++)
if (t[minI]>t[i]) minI=i;
return minI;
}

Minimumkiválasztás tétele II. (for, index, utolsó)

Határozzuk meg, hogy egy adott 'N' elemű vektorban előforduló legkisebb elem indexét. Ha ez az érték többször is előfordulna, akkor az utolsó előfordulás indexét kell megadni:

public static int MinimalisElem_Pozicioja_2(int[] t)
{
// ha a minimßlis elem t÷bbsz÷r is szerepel a vektorban
// akkor a legutolsˇ el§fordulßs indexe-t adjuk vissza
int minI = 0;
for(int i=1;i<t.Length;i++)
if (t[minI]>=t[i]) minI=i;
return minI;
}

Bináris keresés

Egy adott 'N' elemű, rendezett vektorban keressünk meg egy adott érték előfordulásának indexét. Ha a keresett elem nincs a tömbben, adjunk vissza '-1'-t. Használjuk ki azt a jellemzőt, hogy a vektor rendezett:

public static int Binaris_Kereses(int[] t, int keresett_elem)
{
int elso = 0;
int utolso = t.Length-1;
int kozep;
do
{
kozep = (elso+utolso)/2;
if (t[kozep]<keresett_elem) elso = kozep+1;
if (t[kozep]>keresett_elem) utolso = kozep-1;
}
while (t[kozep]!=keresett_elem && elso<=utolso);
if (elso<=utolso) return kozep; // A keresett elem indexe: kozep
return -1; // A keresett elem nincs a tömbben
}

Megszámlálás I. (for)

Határozzuk meg egy adott 'N' elemű vektorban valamely T tulajdonságú elemből hány példány van. A jelen kódban a konkrét feladat: számoljuk meg hány 80-tól nagyobb érték van a tömbben:

public static int Megszamlalas_1(int[] t)
{
// T tulajdonsßg: 80tól nagyobb szám
int db = 0;
for(int i=0;i<t.Length;i++)
if (t[i]>80) db++;
return db;
}

Megszámlálás II. (foreach)

Határozzuk meg egy adott 'N' elemű vektorban valamely T tulajdonságú elemből hány példány van. A jelen kódban a konkrét feladat: számoljuk meg hány 80-tól nagyobb érték van a tömbben:

public static int Megszamlalas_2(int[] t)
{
// T tulajdonsßg: 80tˇl nagyobb szßm
int db = 0;
foreach(int a in t)
if (a>80) db++;
return db;
}

Kiválogatás tétele I. (for)

Egy adott, 'N' elemű vektorban szereplő adott T tulajdonságú elemeket válogassuk át egy másik vektorba. A függvény adja meg hány darab ilyen elemet talált, és pakolt át a második vektorba:

public static int VektorKivalogatas_FOR(int[] a, int[] b)
{
// T tulajdonság: 80tól nagyobb szám
int b_db = 0;
for(int i=0;i<a.Length;i++)
if (a[i]>80)
{
b[b_db]=a[i];
b_db++;
}
return b_db; // ennyi elem lett a B vektorban
}

Kiválogatás tétele II. (foreach)

public static int VektorKivalogatas_FOREACH(int[] a, int[] b)
{
// T tulajdonság: 80tól nagyobb szám
int b_db = 0;
foreach(int x in a)
if (x>80)
{
b[b_db]=x;
b_db++;
}
return b_db; // ennyi elem lett a B vektorban
}

Szétválogatás tétele I. (for)

Egy adott, 'N' elemű vektorban szereplő adott T tulajdonságú elemeket válogassuk át egy másik vektorba. A másik vektor elején helyezzük el a T tulajdonságú elemeket. A vektor végére (második fele) helyezzük el a nem T tulajdonságú elemeket. A függvény adja meg hány darab T tulajdonságú elemet talált, és pakolt át a második vektorba (határvonal):

public static int VektorSzetvalogatas_FOR(int[] a, int[] b)
{
// T tulajdonság: 80tól nagyobb szám
int b_el = 0;
int b_ut = a.Length-1;
for(int i=0;i<a.Length;i++)
if (a[i]>80)
{
b[b_el]=a[i];
b_el++;
}
else
{
b[b_ut]=a[i];
b_ut--;
}
return b_el; // ennyi 'jó' elem lett a B vektorban
}

Szétválogatás tétele II. (foreach)

public static int VektorSzetvalogatas_FOREACH(int[] a, int[] b)
{
// T tulajdonsßg: 80tˇl nagyobb szßm
int b_el = 0;
int b_ut = a.Length-1;
foreach(int x in a)
if (x>80)
{
b[b_el]=x;
b_el++;
}
else
{
b[b_ut]=x;
b_ut--;
}
return b_el; // ennyi 'jˇ' elem lett a B vektorban
}

Összefuttatás tétele (ismétlődéssel)

Adott két elemekkel feltöltött, rendezett vektor. Generálni kell egy olyan vektort, mely tartalmazza a két vektor összes elemét, és szintén rendezett. Ha a két vektor mindegyikében előfordul ugyanazon érték, akkor a generált vektorban ezen érték kétszer szerepeljen. A megoldást optimalizáljuk sebességre, tehát ne úgy oldjuk meg, hogy a két vektor elemeit összemásoljuk, majd az eredmény vektort utólag rendezzük, hanem eleve rendezett módon generáljuk az eredmény vektort.

public static void RendezettVektorOsszefuttatasa_Ismetlodessel(int[] a, int[] b, int[] c)
{
int adb=0;
int bdb=0;
int cdb=0;
while (adb<a.Length && bdb<b.Length)
{
if (a[adb]<b[bdb])
{
c[cdb] = a[adb];
adb++;
}
else
{
c[cdb] = b[bdb];
bdb++;
}
cdb++;
}
while (adb<a.Length)
{
c[cdb] = a[adb];
adb++;
}
while (bdb<b.Length)
{
c[cdb] = b[

Hernyák Zoltán

2013-01-24 17:56:44

előző lapkövetkező lap