C# programozási tételek

2021.01.14 beadandó feladat

Összegzés

Általában egy tömb elemeinek összegzését jelenti. Általánosan: összeg=összeg+aktuális elem, vagyis új összeg=régi összeg+aktuális elem

Példa: Állítsunk elő 10db 1-100 közötti véletlen számot, töltsünk fel velük egy tömböt. Számoljuk ki a számok összegét! Ha ez megvan, akkor ennek felhasználásával számoljuk ki az átlagukat is!

 static void Main(string[] args)
        {
            Console.WriteLine("Összegzés"); //10db 0-100 közötti szám átlaga, összege
            int[] a = new int[10];
            int osszeg = 0, i = 0;
            double atlag = 0;
            Random vsz = new Random();
            for (i=0; i&lt;8; i++)
            {
                a[i] = vsz.Next(101);
                osszeg += a[i];   //osszeg=osszeg+a[i];
                Console.Write("{0,5}", a[i]); 
            }
            atlag = Convert.ToDouble(osszeg) / 10;
            Console.WriteLine("A számok összege: {0}", osszeg);
            Console.WriteLine(" A számok átlaga: {0:0.000}", atlag);
            Console.ReadKey();
        }

static void Main(string[] args)

{

Console.WriteLine("Összegzés"); //10db 0-100 közötti szám átlaga, összege

int[] a = new int[10];

int osszeg = 0, i = 0;

double atlag = 0;

Random vsz = new Random();

for (i=0; i<8; i++)

{

a[i] = vsz.Next(101);

osszeg += a[i]; //osszeg=osszeg+a[i];

Console.Write("{0,5}", a[i]);

}

atlag = Convert.ToDouble(osszeg) / 10;

Console.WriteLine("A számok összege: {0}", osszeg);

Console.WriteLine(" A számok átlaga: {0:0.000}", atlag);

Console.ReadKey();

}

Megszámlálás

Megszámoljuk, hogy hány olyan elem van, ami egy megadott feltételnek megfelel.

Példa: Számoljuk meg, hány negatív és hány pozitív szám van egy 10 elemű, -100 100 közötti véletlen számokkal feltöltött tömbben!

  static void Main(string[] args)
        {
            Console.WriteLine("Megszámlálás");
            int[]a=new int[10];
            int pozitivak = 0, negativak = 0, i = 0;
            Random vsz = new Random();
            for (i=0; i&lt;10; i++)
            {
                a[i] = vsz.Next(-100, 101);
                if (a[i] > 0) pozitivak++;
                if (a[i] &lt; 0) negativak++;
                Console.Write("{0,5}", a[i]);

            }
            Console.WriteLine();
            Console.WriteLine(" {0} db pozitív szám van.", pozitivak);
            Console.WriteLine(" {0} db negatív szám van.", negativak);
            Console.ReadKey();
        }

static void Main(string[] args)

{

Console.WriteLine("Megszámlálás");

int[]a=new int[10];

int pozitivak = 0, negativak = 0, i = 0;

Random vsz = new Random();

for (i=0; i<10; i++)

{

a[i] = vsz.Next(-100, 101);

if (a[i] > 0) pozitivak++;

if (a[i] < 0) negativak++;

Console.Write("{0,5}", a[i]);

}

Console.WriteLine();

Console.WriteLine(" {0} db pozitív szám van.", pozitivak);

Console.WriteLine(" {0} db negatív szám van.", negativak);

Console.ReadKey();

}

Eldöntés

Ez az algoritmus eldönti, hogy van-e a tömbben adott tulajdonságú elem. Ha van, a ciklus leáll.

Példa: Állítsunk elő 5 egész számot, egy 0-100 közötti véletlenszámokból, és döntsük el, van-e közöttük 3-mal osztható!

static void Main(string[] args)
        {
            Console.WriteLine("Eldöntés");
            int[] a = new int[5];
            int i = 0;
            bool van = false;
            Random vsz = new Random();
            for (i=0; i&lt;5; i++)
            {
                a[i] = vsz.Next(101);
                Console.Write("{0,5}", a[i]);

            }
            i = 0;
            do
            {
                if (a[i] % 3 == 0) van = true;
                i++;
            }
            while (van == false &amp;&amp; i &lt; 5);
            Console.WriteLine();
            if (van) Console.WriteLine("Van hárommal osztható szám!");
            Console.ReadKey();
        }

static void Main(string[] args)

{

Console.WriteLine("Eldöntés");

int[] a = new int[5];

int i = 0;

bool van = false;

Random vsz = new Random();

for (i=0; i<5; i++)

{

a[i] = vsz.Next(101);

Console.Write("{0,5}", a[i]);

}

i = 0;

{

if (a[i] % 3 == 0) van = true;

i++;

}

while (van == false && i < 5);

Console.WriteLine();

if (van) Console.WriteLine("Van hárommal osztható szám!");

Console.ReadKey();

}

Kiválasztás

Az adatok közül kiválasztunk egy, vagy több olyan elemet, ami a megadott feltételeknek megfelel. Az algoritmus megadja, hogy az adott elem a tömbben hol helyezkedik el.

Példa: Állítsunk elő 10 véletlen számot -100 és 100 között! Írjuk ki az első pozitív szám indexét és értékét! (plusz az tömb összes elemét, hogy ellenőrizni tudjuk)

static void Main(string[] args)
        {
            Console.WriteLine("Kiválasztás");
            int[]a = new int[10];
            int i = 0;
            bool van = false;
            Random vsz = new Random();
            for (i=0; i&lt;10; i++)
            {
                a[i] = vsz.Next(-100, 100);
                Console.Write("{0,5}", a[i]);
            }
            i = 0;
            do
            {
                if (a[i] > 0) van = true;
                i++;
            }
            while (van == false &amp;&amp; i &lt; 10);
            Console.WriteLine();
            if (van) Console.WriteLine("Az 1. pozitív szám: {0} indexe: {1}", a[i - 1], i - 1);
            else
                Console.WriteLine("Nincs pozitív szám!");
            Console.ReadKey();
        }

static void Main(string[] args)

{

Console.WriteLine("Kiválasztás");

int[]a = new int[10];

int i = 0;

bool van = false;

Random vsz = new Random();

for (i=0; i<10; i++)

{

a[i] = vsz.Next(-100, 100);

Console.Write("{0,5}", a[i]);

}

i = 0;

{

if (a[i] > 0) van = true;

i++;

}

while (van == false && i < 10);

Console.WriteLine();

if (van) Console.WriteLine("Az 1. pozitív szám: {0} indexe: {1}", a[i - 1], i - 1);

else

Console.WriteLine("Nincs pozitív szám!");

Console.ReadKey();

}

Maximum/minimum kiválasztás

Rendezetlen elemek közül keressük meg a legnagyobbat. Karakter és szöveg típusú változókra is érvényes. A for ciklus előtt az első elemet tekintjük a legnagyobbnak, majd a for ciklus során megnézzük a 2. elemtől kezdve az utolsóig, hogy van-e ennél nagyobb elem. Ha az aktuálisan vizsgált elem nagyobb, akkor az lesz az új maximum.

Példa: Állítsunk elő 10db 0-500 közötti véletlen számot, és keressük meg, melyik a legnagyobb! Ellenőrzésként írjuk ki a 10db számot is a képernyőre!

  static void Main(string[] args)
        {
            Console.WriteLine("Maximum kiválasztás");
            int[] a = new int[10];
            int i = 0, min=0, max = 0;
            Random vsz = new Random();
            for (i=0; i&lt;10; i++)
            {
                a[i] = vsz.Next(501);
                Console.Write("{0,5}", a[i]);
            }
            min = a[0];
            max = a[0];
            for (i=1; i&lt;10; i++)
            {
                if (a[i] &lt; min) min=a[i];
                if (a[i] > max) max=a[i];                
            }
        Console.WriteLine();
        Console.WriteLine("A legkisebb szám: {0}", min);
        Console.WriteLine("A legnagyobb szám: {0}", max);         
        Console.ReadKey();
        }

static void Main(string[] args)

{

Console.WriteLine("Maximum kiválasztás");

int[] a = new int[10];

int i = 0, min=0, max = 0;

Random vsz = new Random();

for (i=0; i<10; i++)

{

a[i] = vsz.Next(501);

Console.Write("{0,5}", a[i]);

}

min = a[0];

max = a[0];

for (i=1; i<10; i++)

{

if (a[i] < min) min=a[i];

if (a[i] > max) max=a[i];

}

Console.WriteLine();

Console.WriteLine("A legkisebb szám: {0}", min);

Console.WriteLine("A legnagyobb szám: {0}", max);

Console.ReadKey();

}

Kérjünk be 5db karaktert, és írjuk ki az abc sorrend szerint elsőt! (ASCII karaktekkód szerint rendez)

 static void Main(string[] args)
        {
            Console.WriteLine("Minimum kiválasztás");
            char[] a = new char[5];
            int i = 0;
            char min = ' ';
            Console.WriteLine("Kérem a karaktereket: ");
            for (i=0; i&lt;5; i++)
            {
                a[i] = Convert.ToChar(Console.ReadLine());//enter utánuk!
            }
            min = a[0];
            for (i=1; i&lt;5; i++)
            {
                if (a[i] &lt; min) min = a[i];
            }
            Console.WriteLine();
            Console.WriteLine("Az első karakter: {0}", min);
            Console.ReadKey();

        }

static void Main(string[] args)

{

Console.WriteLine("Minimum kiválasztás");

char[] a = new char[5];

int i = 0;

char min = ' ';

Console.WriteLine("Kérem a karaktereket: ");

for (i=0; i<5; i++)

{

a[i] = Convert.ToChar(Console.ReadLine());//enter utánuk!

}

min = a[0];

for (i=1; i<5; i++)

{

if (a[i] < min) min = a[i];

}

Console.WriteLine();

Console.WriteLine("Az első karakter: {0}", min);

Console.ReadKey();

}

Állítson elő véletlenszerűen 28 számot a [-10, 10] tartományból!

Állapítsa meg pozitív vagy negatív számból van-e több? A választ
és a darabszámokat írja a képernyőre!
Hányszor fordult elő a 7-es szám?
Van-e a számok között 0, hanyadik indexe van az elsőnek?
Adja meg a negatív számok átlagát!
Adja meg melyik a legkisebb, és a legnagyobb szám!
Melyik volt a pozitív számok közül a legkisebb?
Melyik volt a negatív számok közül a legnagyobb?

using System;

namespace tetelekgyak
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Gyakorlás");
            int[] tomb = new int[28];
            int db_nulla=0, db_poz = 0, db_neg = 0, i = 0, keresett = 7, db_keresett=0, nulla_indexe=0, osszeg=0;
            int min, poz_min = 0;
            int max, neg_max = 0;
            double atlag = 0;
            bool talalat = false;
            bool nulla = false;
            Random vsz = new Random();
            for (i=0; i&lt;28; i++)
            {
                tomb[i] = vsz.Next(-10, 11);
                if (tomb[i] == keresett)
                {
                    talalat = true;
                    db_keresett++;
                }
                if (tomb[i] == 0)
                {
                    db_nulla++;
                    if (db_nulla==1) nulla_indexe = i;
                }
                if (tomb[i] > 0) db_poz++;
                if (tomb[i] &lt; 0)
                {
                    db_neg++;
                    osszeg += tomb[i];
                }
                Console.Write("{0} ", tomb[i]);
            }
            Console.WriteLine();
            Console.WriteLine("Negatív szám: {0} db, pozitív szám: {1} db", db_neg, db_poz);
            if (db_poz > db_neg)
                Console.WriteLine("Több a pozitív szám!");
            else if (db_neg > db_poz)
                Console.WriteLine("Több a negatív szám!");
            else
                Console.WriteLine("A + és - számok száma egyenlő");
            //van-e 7-es szám?
            if (talalat==true)
                Console.WriteLine("A számok között van 7-es! {0} db", db_keresett);
            else
                Console.WriteLine("A számok között nincs 7-es!");
            if (db_nulla > 0)       
            Console.WriteLine("A számok között van {0} db 0, az első indexe: {1}", db_nulla, nulla_indexe);
            
            atlag = Convert.ToDouble(osszeg) / db_neg;
            Console.WriteLine("A negatív számok átlaga: összeg:{0} / darab {1} = {2}", osszeg, db_neg, atlag);
            max = tomb[0];
            min = tomb[0];           
            for (i = 0; i &lt; 28; i++)
            {
                if (tomb[i] > max) max = tomb[i];
                if (tomb[i] &lt; min) min = tomb[i];               
            }
            poz_min = max;
            neg_max = min;
            for (i = 0; i &lt; 28; i++)
            {
               // legnagyobb negatív szám
                if ((tomb[i] &lt; 0) &amp;&amp; (tomb[i] > neg_max))
                     neg_max = tomb[i];
               // legkisebb pozitív szám
                 if ((tomb[i] > 0) &amp;&amp; (tomb[i] &lt; poz_min))
                    poz_min = tomb[i];
            }

            Console.WriteLine();
            Console.WriteLine("A legnagyobb szám: {0}, a legkisebb szám: {1}", max, min);
            Console.WriteLine("A legnagyobb negatív szám: {0}, a legkisebb pozitív szám: {1}", neg_max, poz_min);
            Console.ReadKey();
        }
    }
}

using System;

namespace tetelekgyak

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine("Gyakorlás");

int[] tomb = new int[28];

int db_nulla=0, db_poz = 0, db_neg = 0, i = 0, keresett = 7, db_keresett=0, nulla_indexe=0, osszeg=0;

int min, poz_min = 0;

int max, neg_max = 0;

double atlag = 0;

bool talalat = false;

bool nulla = false;

Random vsz = new Random();

for (i=0; i<28; i++)

{

tomb[i] = vsz.Next(-10, 11);

if (tomb[i] == keresett)

{

talalat = true;

db_keresett++;

}

if (tomb[i] == 0)

{

db_nulla++;

if (db_nulla==1) nulla_indexe = i;

}

if (tomb[i] > 0) db_poz++;

if (tomb[i] < 0)

{

db_neg++;

osszeg += tomb[i];

}

Console.Write("{0} ", tomb[i]);

}

Console.WriteLine();

Console.WriteLine("Negatív szám: {0} db, pozitív szám: {1} db", db_neg, db_poz);

if (db_poz > db_neg)

Console.WriteLine("Több a pozitív szám!");

else if (db_neg > db_poz)

Console.WriteLine("Több a negatív szám!");

else

Console.WriteLine("A + és - számok száma egyenlő");

//van-e 7-es szám?

if (talalat==true)

Console.WriteLine("A számok között van 7-es! {0} db", db_keresett);

else

Console.WriteLine("A számok között nincs 7-es!");

if (db_nulla > 0)

Console.WriteLine("A számok között van {0} db 0, az első indexe: {1}", db_nulla, nulla_indexe);

atlag = Convert.ToDouble(osszeg) / db_neg;

Console.WriteLine("A negatív számok átlaga: összeg:{0} / darab {1} = {2}", osszeg, db_neg, atlag);

max = tomb[0];

min = tomb[0];

for (i = 0; i < 28; i++)

{

if (tomb[i] > max) max = tomb[i];

if (tomb[i] < min) min = tomb[i];

}

poz_min = max;

neg_max = min;

for (i = 0; i < 28; i++)

{

// legnagyobb negatív szám

if ((tomb[i] < 0) && (tomb[i] > neg_max))

neg_max = tomb[i];

// legkisebb pozitív szám

if ((tomb[i] > 0) && (tomb[i] < poz_min))

poz_min = tomb[i];

}

Console.WriteLine();

Console.WriteLine("A legnagyobb szám: {0}, a legkisebb szám: {1}", max, min);

Console.WriteLine("A legnagyobb negatív szám: {0}, a legkisebb pozitív szám: {1}", neg_max, poz_min);

Console.ReadKey();

}

Kiválogatás

Kiválogatás során egy tömb elemei közül kiválogatjuk azokat, amelyek a megadott feltétel(ek)nek megfelelnek. Ezeket akár egy másik tömbbe is tárolhatjuk.

Generáljunk 20db véletlenszámot 1-100 közötti számokból. Az öttel osztható számokat írassuk ki, és tároljuk egy másik tömbben! Ilyen esetben a másik tömb méretének is célszerű az eredeti tömb méretét megadni, mert akár az is elképzelhető, hogy minden generált szám osztható öttel.

namespace kivalogatas
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Kiválogatás");
            int[] a = new int[20];
            int[] b = new int[20];
            int i = 0, j = 0, db = 0;
            Random vsz = new Random();
            for (i = 0; i &lt; 20; i++)
            {
                a[i] = vsz.Next(101);
                Console.Write("{0} ", a[i]);
                if (a[i] % 5 == 0)
                {
                    b[db] = a[i];
                    db++;
                }
            }
            Console.WriteLine();
            Console.WriteLine("Az öttel osztható számok:");
            for (j=0; j&lt;db; j++)
            {
                Console.Write("{0} ", b[j]);
            }
            Console.ReadKey();
        }
    }
}

namespace kivalogatas

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine("Kiválogatás");

int[] a = new int[20];

int[] b = new int[20];

int i = 0, j = 0, db = 0;

Random vsz = new Random();

for (i = 0; i < 20; i++)

{

a[i] = vsz.Next(101);

Console.Write("{0} ", a[i]);

if (a[i] % 5 == 0)

{

b[db] = a[i];

db++;

}

Console.WriteLine();

Console.WriteLine("Az öttel osztható számok:");

for (j=0; j<db; j++)

{

Console.Write("{0} ", b[j]);

}

Console.ReadKey();

}

Szétválogatás

Szétválogatás esetén egy tömb minden elemét elhelyezzük a megadott feltételek szerint másik tömbben. A szétválogatás utáni tömbök elemszáma megegyezik az eredeti tömb elemszámával.

Állítsunk elő 20db 1-100 közötti véletlen számot! Válogassuk szét a számokat 3 tömbbe: legyenek a ‘ketto’ tömbben a kettővel osztható számok, a ‘harom’-ban a kettővel nem de hárommal oszthatóak, az ‘egyeb’ tömbben az összes többi. Írassuk ki a tömbök tartalmát!

namespace szetvalogatas
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Szétválogatás");
            int[] a = new int[20];
            int[] ketto = new int[20];
            int[] harom = new int[20];
            int[] egyeb = new int[20];
            int i = 0, j = 0, dbketto = 0, dbharom = 0, dbegyeb = 0;
            Random vsz = new Random();
            for (i=0; i&lt;20; i++)
            {
                a[i] = vsz.Next(101);
                Console.Write("{0} ", a[i]);
                if (a[i]%2==0)
                {
                    ketto[dbketto] = a[i];
                    dbketto++;
                }
                else if (a[i]%3==0)
                {
                    harom[dbharom] = a[i];
                    dbharom++;
                }
                else
                {
                    egyeb[dbegyeb] = a[i];
                    dbegyeb++;
                }
            }
            Console.WriteLine();
            Console.WriteLine("A kettővel osztható számok: ");
            for (j = 0; j &lt; dbketto; j++)
                Console.Write("{0} ", ketto[j]);
                Console.WriteLine();
            Console.WriteLine("A kettővel nem de hárommal oszthtó számok: ");
            for (j = 0; j &lt; dbharom; j++)
                Console.Write("{0} ", harom[j]);
                Console.WriteLine();
            Console.WriteLine("Egyéb számok");
            for (j = 0; j &lt; dbegyeb; j++)
                Console.Write("{0} ", egyeb[j]);
            Console.ReadKey();
        }
    }
}

namespace szetvalogatas

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine("Szétválogatás");

int[] a = new int[20];

int[] ketto = new int[20];

int[] harom = new int[20];

int[] egyeb = new int[20];

int i = 0, j = 0, dbketto = 0, dbharom = 0, dbegyeb = 0;

Random vsz = new Random();

for (i=0; i<20; i++)

{

a[i] = vsz.Next(101);

Console.Write("{0} ", a[i]);

if (a[i]%2==0)

{

ketto[dbketto] = a[i];

dbketto++;

}

else if (a[i]%3==0)

{

harom[dbharom] = a[i];

dbharom++;

}

else

{

egyeb[dbegyeb] = a[i];

dbegyeb++;

}

Console.WriteLine();

Console.WriteLine("A kettővel osztható számok: ");

for (j = 0; j < dbketto; j++)

Console.Write("{0} ", ketto[j]);

Console.WriteLine();

Console.WriteLine("A kettővel nem de hárommal oszthtó számok: ");

for (j = 0; j < dbharom; j++)

Console.Write("{0} ", harom[j]);

Console.WriteLine();

Console.WriteLine("Egyéb számok");

for (j = 0; j < dbegyeb; j++)

Console.Write("{0} ", egyeb[j]);

Console.ReadKey();

}

Lineáris keresés

A lineáris keresés nagyon hasonlít az eldöntésre: egy n elemű sorozatban keresünk adott feltételnek megfelelő elemet. Az algoritmusnak el kell döntenie, van-e az adott feltételnek megfelelő elem. Ha igen, akkor ennek az elemnek a sorszámát keressük.

namespace lineariskereses
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Lineáris keresés");
            int[] tomb = new int[15];
            Random vsz = new Random();
            int n = tomb.Length;
            int s = 0;
            for (s = 0; s &lt; n; s++)
            {
                tomb[s] = vsz.Next(21);
                Console.Write("{0} ", tomb[s]);
            }
         
            int keresettSzam = 1;
            int i = 0;
            while (i &lt; n &amp;&amp; tomb[i] != keresettSzam)
                i++;
            if (i &lt; n)
                Console.WriteLine("A keresett szám indexe: {0} ", i);
            else
                Console.WriteLine("A keresett szám nincs benne a tömbben");
            Console.ReadKey();
        }
    }
}

namespace lineariskereses

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine("Lineáris keresés");

int[] tomb = new int[15];

Random vsz = new Random();

int n = tomb.Length;

int s = 0;

for (s = 0; s < n; s++)

{

tomb[s] = vsz.Next(21);

Console.Write("{0} ", tomb[s]);

}

int keresettSzam = 1;

int i = 0;

while (i < n && tomb[i] != keresettSzam)

i++;

if (i < n)

Console.WriteLine("A keresett szám indexe: {0} ", i);

else

Console.WriteLine("A keresett szám nincs benne a tömbben");

Console.ReadKey();

}

RENDEZÉSI ALGORITMUSOK

BUBORÉK RENDEZÉS

Nevét onnan kapta, hogy hasonlóan ahhoz, ahogy a pezsgőspohárban szállnak felfelé a buborékok, a rendezés során is minden egyes menetben a fennmaradó elemek közül a legnagyobbat helyezzük át a tömbszelet végére, tetejére. A rendezés során a tömb fennmaradó – még nem rendezett – részén végighaladva az egymás utáni szomszédos elemeket összehasonlítjuk, és ha szükséges megcseréljük őket, hogy közülük mindig a nagyobb helyezkedjen el feljebb; ezt a műveletet aztán a tömbön feljebb lépve addig ismételjük, amíg a fennmaradó rész végéhez nem érünk. A műveletsor végén a rendezetlen rész tetejére mindig a legnagyobb érték kerül majd fel, amelyet a következő menetben már nem veszünk figyelembe. A ciklust egészen addig ismételjük a fennmaradó – egyre kisebb – halmazon, amíg már csak egyetlen elem marad ebben, amely ebben az esetben a halmaz legkisebb eleme lesz, miközben a tömb fennmaradó része az összes nála nagyobb elemet fogja tartalmazni, növekvő sorrendben.

Az algoritmus műveletigénye a tömb méretének négyzetével arányos, ezért nagy tömböknél nem javasolt a használata, mert rendkívül lassú futáshoz vezet. Ilyen esetekre a gyorsrendezés vagy az összefésülő rendezés használata ajánlott. A minimumkiválasztásos és a beszúrásos rendezések általában hatékonyabbak a buborékrendezésnél.

Egy szemléletes video a YouTube-ról, és egy másik.

namespace buborek_rendezes
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Buborék rendezés");
            int[] tomb = new int[] { 10, 2, 9, 8, 5, 6, 1, 4, 3, 7 };
            int n = tomb.Length;
            //Kiíratás rendezés előtt
            for (int i = 0; i &lt; n; i++)
                Console.Write("{0} ", tomb[i]);
            Console.WriteLine();
            //Buborék rendezés
            for (int i = n - 1; i > 0; i--)
                for (int j = 0; j &lt; i; j++)
                    if (tomb[j] > tomb[j + 1])
                    {
                        int temp = tomb[j + 1];
                        tomb[j + 1] = tomb[j];
                        tomb[j] = temp;
                    }
            //Kiíratás rendezés után
            for (int i = 0; i &lt; n; i++)
                Console.Write("{0} ", tomb[i]);
            Console.WriteLine();
        }
    }
}

namespace buborek_rendezes

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine("Buborék rendezés");

int[] tomb = new int[] { 10, 2, 9, 8, 5, 6, 1, 4, 3, 7 };

int n = tomb.Length;

//Kiíratás rendezés előtt

for (int i = 0; i < n; i++)

Console.Write("{0} ", tomb[i]);

Console.WriteLine();

//Buborék rendezés

for (int i = n - 1; i > 0; i--)

for (int j = 0; j < i; j++)

if (tomb[j] > tomb[j + 1])

{

int temp = tomb[j + 1];

tomb[j + 1] = tomb[j];

tomb[j] = temp;

}

//Kiíratás rendezés után

for (int i = 0; i < n; i++)

Console.Write("{0} ", tomb[i]);

Console.WriteLine();

}

Beszúrásos rendezés

Működése leginkább a kártyalapok egyenként való kézbe vételéhez és a helyükre igazításához hasonlítható. Van a kezünkben 10,9,K,A és felveszünk egy J-t, akkor a 10-es után fogjuk beszúrni, de az előtte levő elemeket is rendezi, tehát 9, 10, J, K, A lesz az eredmény. Ezzel persze nincs ki a sorunk pókernél…

Vesszük a soron következő elemet, és megkeressük a helyét a tőle balra lévő, már rendezett részben, majd a kereséssel párhuzamosan a nagyobb elemeket rendre eggyel jobbra mozgatjuk. Az aktuális elemet egy segédváltozóban tároljuk, mert a mozgatások során értéke felülíródhat egy nagyobb elemmel.

Ezen algoritmus használata akkor igazán előnyös, ha az adatsorunk már részben rendezett. Továbbá akkor igen hatékony, ha egy rendezett sorozatot bővítünk és a bővítés után is szeretnénk, hogy a sorozat rendezett maradjon. Az algoritmus futási ideje legjobb esetben konstans, vagyis a gép sebességétől függ, az elemektől nem. Legrosszabb esetben pedig négyzetes.

using System;

namespace beszurasos_rendezes
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Beszúrásos rendezés!");
            int[] tomb = { 10, 2, 9, 8, 5, 6, 1, 4, 3, 7 };
            for (int i = 0; i &lt; tomb.Length; i++)
                Console.Write("{0} ", tomb[i]);
            Console.WriteLine();
            //beszúrásos rendezés
            for (int i = 1; i &lt; tomb.Length; i++)
            {
                int kulcs = tomb[i];
                int j = i - 1;
                while (j >= 0 &amp;&amp; tomb[j] > kulcs)
                {
                    tomb[j + 1] = tomb[j];
                    j = j - 1;
                }
                tomb[j + 1] = kulcs;
            }
            for (int i = 0; i &lt; tomb.Length; i++)
            Console.Write(tomb[i] + " ");
            Console.WriteLine();

        }
    }
}

using System;

namespace beszurasos_rendezes

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine("Beszúrásos rendezés!");

int[] tomb = { 10, 2, 9, 8, 5, 6, 1, 4, 3, 7 };

for (int i = 0; i < tomb.Length; i++)

Console.Write("{0} ", tomb[i]);

Console.WriteLine();

//beszúrásos rendezés

for (int i = 1; i < tomb.Length; i++)

{

int kulcs = tomb[i];

int j = i - 1;

while (j >= 0 && tomb[j] > kulcs)

{

tomb[j + 1] = tomb[j];

j = j - 1;

}

tomb[j + 1] = kulcs;

}

for (int i = 0; i < tomb.Length; i++)

Console.Write(tomb[i] + " ");

Console.WriteLine();

}

Kategóriák

Friss bejegyzések

PHP – API készítés

JS – API használata