Az algoritmus olyan utasítások sorozata, amelyeket előre meghatározott sorrendben hajtanak végre egy probléma megoldása vagy egy munka befejezése érdekében. A függvény egy kódblokk, amely a program más részeiből hívható és végrehajtható.

Útmutató egy probléma megoldásához vagy egy bizonyos tevékenység elvégzéséhez. A számítástechnikában az algoritmusokat a műveletek széles skálájára használják, az alapvető matematikától a bonyolult adatfeldolgozásig.

A C-ben használt egyik gyakori algoritmus a rendezési algoritmus. A rendezési algoritmus az elemek gyűjteményét egy bizonyos sorrendbe rendezi, például numerikusan vagy ábécé szerint.

Számos rendezési algoritmus létezik, mindegyiknek vannak előnyei és hátrányai. A C-ben a leggyakoribb rendezési algoritmusok a gyorsrendezés, az összevonás és a rendezés.

A C egyik legfontosabb jellemzője a mutató támogatása. Ez lehetővé teszi az adatstruktúrák, például tömbök, sorok stb. hatékony kezelését. Ez alkalmassá teszi olyan algoritmusok megvalósítására, amelyek összetett adatmanipulációt igényelnek, mint például a rendezés és az algoritmikus keresés.

A C-ben megvalósított szoftverkönyvtár egyik híres példája a Standard Template Library (STL). Ez a könyvtár algoritmusok széles választékát kínálja olyan feladatokhoz, mint az adatszerkezetek rendezése, keresése és manipulálása.

Az algoritmus jellemzői

Meghatározza az algoritmus számos fontos jellemzőjét, többek között:

Bemenetek: Az algoritmusoknak olyan bemeneteket kell kapniuk, amelyek értékként vagy adatként ábrázolhatók.Kimenet: Az algoritmusnak valamilyen kimenetet kell produkálnia. Ez lehet egy probléma vagy egy annak megoldására tervezett megoldás következménye.Világosság: Az algoritmusokat pontosan meg kell határozni, olyan egyértelmű utasításokat használva, amelyeket a számítógép vagy más rendszer egyértelműen követni tud.Végesség: Az algoritmus korlátozott lépést igényel. Ez azt jelenti, hogy bizonyos számú parancs végrehajtása után ki kell lépni.Érvényesség: Az algoritmusnak érvényesnek kell lennie. Más szóval, képesnek kell lennie arra, hogy olyan megoldást hozzon létre a problémára, amelyet az algoritmus ésszerű időn belül megoldani szeretne.Hatékonyság:Az algoritmusnak hatékonynak kell lennie, vagyis képesnek kell lennie arra, hogy ésszerű időn belül megoldást tudjon előállítani arra a problémára, amelyet megoldani tervez.Általánosság:Egy algoritmusnak általánosnak kell lennie, ami azt jelenti, hogy a problémák széles körére alkalmazható, nem pedig egyetlen problémára.

Algoritmus elemzés

Az algoritmikus elemzés az algoritmus teljesítményének értékelési folyamata a hatékonyság, összetettség és egyéb kritériumok szempontjából. Általában sok algoritmus értékelésére és egy adott probléma vagy szoftver optimális megoldásának kiválasztására szolgál.

Az algoritmusok elemzése általában magában foglalja azok időbeli és térbeli összetettségének mérését.

A térbeli összetettséghez hasonlóan, amely a szükséges memória vagy lemezterület mennyiségét írja le, az időbonyolultság azt írja le, hogy az algoritmus mennyi ideig határozza meg a feladat végrehajtását.

Az algoritmusok időbeli összetettségének elemzésére különböző módok léteznek, például a Big O és az Omega jelölés. Az Omega szimbólum az algoritmus időbeli összetettségének felső korlátját, míg az Omega szimbólum alsó korlátot ad.

Az idő- és térkomplexitás mérésén túl az algoritmuselemzés más kritériumokat is tartalmaz, mint például a stabilitás, a párhuzamosság és a skálázhatóság.

Stabilitás:- Ez arra vonatkozik, hogy az algoritmus képes-e fenntartani az adathalmazban lévő elemek egymáshoz viszonyított sorrendjét.Párhuzamosítás:- Ez a műveletek párhuzamos végrehajtásának képességére vonatkozik több processzoron keresztül.Méretezhetőség:- Másrészt egy algoritmus azon képességére utal, hogy nagy mennyiségű adatot és egyéb bemeneteket kezel.

Kétféle elemzést tartalmaznak.

ők:-

1. Előzetes elemzés.
2. Utólagos elemzés.

Előzetes elemzés

A Prior egy algoritmuselemzési módszer, amely egy algoritmus teljesítményének matematikai tulajdonságai alapján történő becslésére összpontosít anélkül, hogy ténylegesen végrehajtaná az algoritmust.

Ez a megközelítés lehetővé teszi az algoritmusok és egyéb metrikák időbeli és térbeli összetettségének elemzését anélkül, hogy az algoritmusokat implementálni és futtatni kellene.

dinamikus tömb java-ban

Utólagos elemzés

Az utólagos elemzés ezzel szemben egy olyan algoritmuselemzési módszer, amely ténylegesen végrehajtja az algoritmust és méri annak teljesítményét.

Ez a megközelítés pontosabb és részletesebb információkat ad az algoritmus teljesítményéről, de megköveteli az algoritmus megvalósítását és végrehajtását.

Algoritmus összetettsége

Az algoritmus komplexitása az algoritmus hatékonyságának és teljesítményének mérésére szolgáló mérőszám. Az algoritmusokat általában a probléma megoldásához vagy egy meghatározott cél eléréséhez szükséges idő és tér szempontjából értékelik.

Az algoritmus összetettségében két tényezőt használnak.

ők:-

1. Időtényező.
2. Tér tényező.

Időtényező

• Azt az időt, ameddig egy algoritmusnak szüksége van egy feladat elvégzéséhez, időbonyolultságnak nevezzük. Általában azt a műveletek vagy lépések számával mérik, amelyeket az algoritmusnak végre kell hajtania a probléma megoldásához.
• Egy algoritmus időbeli összetettsége fontos, mert meghatározza, hogy mennyi ideig tart a végrehajtás, és jelentős hatással lehet a program és a rendszer teljesítményére.
• Egy algoritmus időbonyolultsága a Big O jelöléssel fejezhető ki, ami egy algoritmus időbonyolultságának felső határának kifejezése.
• Az O(n) időbonyolultságú algoritmus azt jelenti, hogy az algoritmus futtatásához szükséges idő egyenesen arányos a bemeneti adatok méretével (n).
• További gyakori időbonyolítások az O(n^2) kvadratikus komplexitás és az O(log n) logaritmikus komplexitás.

Térelemzés

• Másrészt a tér összetettsége az algoritmus végrehajtásához szükséges memória vagy tárhely mennyiségére utal.
• Ez azért fontos, mert meghatározza az alkalmazás vagy rendszer általános teljesítményét befolyásoló algoritmusok futtatásához szükséges erőforrások számát.
• Ha az algoritmus térbonyolultsága O(n), akkor olyan mennyiségű memóriát használ, amely lineárisan növekszik a bemenet méretével.
• Ha az algoritmus O(1) térkomplexitású, akkor fix mennyiségű memóriát használ, függetlenül a bemenet méretétől.

Hogyan írjunk algoritmust

1. Először határozza meg azt a problémát, amelyet az algoritmus megoldani szeretne.

Tegyük fel például, hogy egy algoritmust akarunk írni, hogy megtaláljuk a maximális értéket egy számlistából.

2. Bontsa le a problémát kisebb, kezelhető lépésekre.

• Inicializálja a 'max' változót a lista első értékére.
• A lista minden további értékénél hasonlítsa össze a „max” értékkel.
• Ha az érték nagyobb, mint a 'max', állítsa a 'max' értéket erre az értékre.
• Folytassa ezt mindaddig, amíg a listában szereplő összes értéket össze nem hasonlította.
• A végső „max” értéket adja vissza.

3. Írja meg az algoritmust pszeudokóddal vagy programozási nyelven.

Pseudo kóddal írt algoritmus:

 MAX (list) max = list[0] For i = 1 the length of the list list IF[i] > max max = list[i] End for Maximum return Maximum end 

4. Tesztelje az algoritmust, hogy megbizonyosodjon arról, hogy helyes és hatékony.

Az algoritmus teszteléséhez különböző számlistákat ír be, és ellenőrizze, hogy a maximális helyes értéket adja vissza. Elemezheti az algoritmus időbeli összetettségét is, hogy meghatározza, mennyire skálázható nagyobb bemenetekhez.

Példa:-

Bemenet: [1, 5, 2, 7, 3]

Kimenet: 7.

Magyarázat: 7 a maximális érték a listában.

5. Optimalizálja az algoritmust.

Keressen módszereket az algoritmusok optimalizálására, hogy gyorsabbá és hatékonyabbá tegye őket. Ez magában foglalhatja a pszeudokód módosítását vagy hatékonyabb adatstruktúrák vagy algoritmusok megvalósítását.

Alapvető algoritmusok írása

Példa: - Két egész szám összege.

1. lépés - Fogj neki

2. lépés - Deklarálunk három a, b, c egész számot

3. lépés - Határozza meg a és b értékét

4. lépés - Adja össze a és b értékét

5. lépés - Mentse el a 4. lépés kimenetét a c

6. lépés - Nyomtatás c

7. lépés - Állj meg

A C nyelvben használt algoritmusok típusa.

1. Rendezési algoritmusok

A C adattípusok és operátorok gazdag készletét kínálja, amelyek különféle rendezési algoritmusok, például buborékos rendezés, beillesztési rendezés és gyors rendezés megvalósítására használhatók.

Ezek az algoritmusok sok alkalmazásban hasznosak, mert különböző méretű és típusú adatok rendezésére használhatók.

Különféle rendezési algoritmusok léteznek.

ők:-

(i) Buborékos rendezés: Egy egyszerű rendezési algoritmus, amely ismételten összehasonlítja a közeli komponenseket, és kikapcsolja azokat, ha nem működnek.

A buborékok rendezési algoritmusa a következő:

1. Kezdje az elemek rendezetlen listájával.
2. Hasonlítsa össze a lista első két elemét. Ha az első elem nagyobb, mint a második elem, cserélje ki őket.
3. Lépjen tovább a következő elempárra, és ismételje meg a 2. lépést, amíg el nem éri a lista végét.
4. A lista minden eleménél ismételje meg még egyszer a 2. és 3. lépést. amit bérletnek neveznek.
5. Ismételje meg a 2-4. lépéseket a teljes listára. A lépések megismétlése közben az elemek „buborékolnak” a megfelelő helyükre a rendezett listában.
6. Amint az átadás befejeződött, és nem történik csere, a lista rendeződik, és az algoritmus leállhat.
7. A végleges rendezett lista kerül visszaadásra.

(ii) Beillesztési rendezés : rendezési módszer, amely egy-egy elemenként rendezett listát hoz létre úgy, hogy mindegyiket a megfelelő helyre helyezi.

A beszúrás rendezési algoritmusa a következő:

1. Inicializálja az üres rendezett listát és a rendezendő elemek rendezetlen listáját.
2. A rendezetlen lista első tagját ki kell venni, és a rendezett listában a megfelelő pozícióba kell helyezni.
3. Ismételje meg a 2. lépést a rendezetlen lista minden következő eleménél.
4. Hasonlítsa össze az aktuális elemet a rendezett lista elemeivel, kezdve a közvetlenül balra lévő elemmel.
5. Cserélje fel a két elemet, ha az aktuális elem kisebb, mint a bal oldali elem.
6. Ha az aktuális elem nagyobb, mint a tőle balra lévő elem, illessze be a megfelelő helyre a rendezett listában.
7. Ismételje meg a 4-6. lépéseket a rendezetlen lista minden következő elemére.
8. Az összes elem feldolgozása után a rendezett lista az összes elemet a megfelelő sorrendben tartalmazza.
9. A válogatási folyamat befejeződött.

(iii) Kijelölés rendezése : olyan rendezési módszer, amely következetesen a rendezetlen listából a legkisebb részlettel kezdi a rendezett listát.

A kiválasztási rendezés algoritmusa a következő:

1. Kezdje azzal, hogy a lista elsődleges elemét állítsa be min elemként.
2. Ismételje meg a lista többi elemét, és hasonlítsa össze mindegyiket az aktuális minimummal.
3. Állítson be új minimumot, ha egy elemet kisebbnek talál a meglévőnél.
4. Módosítsa az aktuális minimumot a lista első elemére, amikor az eléri a következtetést.
5. A lista fennmaradó rendezetlen részéhez ismételje meg a 2–4. lépéseket, de kezdje a lista második elemével (mivel az első elem már rendezve van).
6. Folytassa a lista rendezését ilyen módon, amíg az összes rendezés meg nem történik.

(iv) Gyors válogatás : Oszd meg és uralkodj rendezési algoritmus, amely kiválaszt egy pivot elemet, és a listát allistákra osztja fel attól függően, hogy az elemek kisebbek vagy nagyobbak, mint a pivot. Ezt követően az allistákat a rendszer ismételten rendezi, amíg a teljes listát meg nem rendezik.

A gyors rendezés algoritmusa a következő:

1. Válasszon ki egy pivot elemet a listából. Ez jellemzően az első elem, de lehet véletlenszerű elem vagy a lista mediánja is.
2. Ossza fel a listát két allistára: az egyik a pivotnál kisebb elemeket, a másik pedig a pivotnál nagyobb elemeket tartalmazza.
3. Rekurzívan rendezze a pivotnál kisebb elemeket tartalmazó allistát ugyanezzel a folyamattal.
4. Ugyanezt az eljárást használja a pivotnál nagyobb bejegyzések allistájának rekurzív rendezéséhez.
5. Összefűzi a rendezett részlistákat a közöttük lévő pivot elemmel, hogy egy teljesen rendezett listát hozzon létre.
6. A teljesen rendezett lista visszaadása.

(v) A tétel megy : Az oszd meg és uralkodj rendezési algoritmus a listát két felére osztja, mindegyik felét rendezi, majd a két felét rendezett sorrendben egyesíti.

Összevonási rendezési algoritmus:

1. Készítsen két allistát a listából: az egyiket a pivot alatti elemekkel, a másikat a pivot feletti elemekkel.
2. Új rendezett allistát hoz létre az allisták iteratív egyesítésével, amíg csak egy allista nem létezik. Ez lesz az Ön rendezett listája.
3. A két alkönyvtár egyesítésének lépései: -
4. Hozzon létre egy üres listát a rendezett elemek tárolására.
5. Összehasonlítja az egyes részlisták első elemét.
6. Hozzáadja a kisebb elemet az új listához, és eltávolítja a szülő allistából.
7. Ismételje meg a 2. és 3. lépést, amíg a lista teljesen ki nem ürül.
8. Hozzáadja a többi allisták fennmaradó elemeit egy új listához.
9. Lecseréli az egyesített allistát az új rendezett listára.
10. Ismételje ezt a folyamatot mindaddig, amíg az összes allista egy rendezett listába nem egyesül.

(vi) Halomrendezés : Olyan rendezési algoritmus, amely a kupac nevű adatstruktúra segítségével rendezi az elemeket.

Ez az osztályozási algoritmus:

Maximum kupac építése: Az első nem levél csomóponttól kezdve hasonlítsa össze az egyes csomópontokat a gyermek csomópontjaival, és cserélje ki a csomópontokat a legnagyobb gyermek csomópontokra, hogy megfeleljen a max kupac tulajdonságnak.Cserélje a gyökérelemet az utolsó elemmel: A gyökér (legnagyobb elem) felcserélése a verem utolsó elemével.
1. Rakja egymásra a többi elemet. A gyökértől kezdve minden csomópontot összehasonlít a gyermekeivel, felcserélve a csomópontokat a régebbi gyermekeikkel, amíg a max kupac tulajdonság nem teljesül.
2. Ismételje meg a 2. és 3. lépést az újonnan egymásra helyezett elemekkel, kivéve az utolsó elemet a megfelelő pozícióban.
3. Ismételje meg ezt a folyamatot, amíg csak egy elem marad a veremben. Ez most rendezve van.
Halmozz le: A gyökércsomópontból kiindulva összehasonlítja az elemeket a gyermekeivel, és felcseréli a kettő közül a nagyobbal, amíg a max kupac tulajdonság teljesül.Heapify Up: Kezdje a kupac utolsó elemével, hasonlítsa össze a szülővel, és cserélje fel a szülővel, hogy megfeleljen a max kupac tulajdonságnak.

(vii) Radix rendezés : Olyan rendezési algoritmus, amely az elemeket bináris ábrázolásuk számjegyei vagy számjegyei alapján rendezi.

A Radix rendezés algoritmusa a következő:

1. határozza meg, hogy a beviteli lista legnagyobb eleme hány számjegyet tartalmazzon.
2. Inicializáljon egy változót, mondjuk egy számjegyet, 1-re, ami az aktuális számjegyhelyet jelöli.
3. Hozzon létre egy üres listát minden lehetséges számjegyhez 0 és 9 között.
4. Ismételje meg a beviteli listát, és adja hozzá az egyes elemeket a megfelelő listához az aktuális számjegyhely értéke alapján.
5. Összefűzze az összes listát, hogy létrehozza az új listát a számjegylisták sorrendjében.
6. A következő számjegyre lépéshez szorozza meg a digitPlace értéket 10-zel.
7. Ismételje meg a 4-6. lépéseket minden számjegy helyére, amíg a legnagyobb elem összes számjegyét figyelembe nem vette.
8. A végső lista az elemek számjegyei szerint növekvő sorrendbe kerül.
9. A végleges rendezett lista visszaadása.

2. Keresési algoritmusok

A C a különféle keresési algoritmusok megvalósításához szükséges eszközöket is biztosítja, mint például a lineáris keresés és a bináris keresés. Ezek az algoritmusok gyorsan meg tudnak találni bizonyos elemeket egy adatkészletben, így számos alkalmazáshoz hasznosak lehetnek.

Sokféle keresési algoritmus létezik.

Ők:-

(i) Lineáris keresés : Alapvető keresési algoritmus, amely egyenként megvizsgálja a lista minden elemét, amíg meg nem találja a kívánt elemet.

Algoritmus a lineáris kereséshez: -

1. Határozza meg az algoritmus bemenetét: A lineáris keresési algoritmus bemenete az elemek listája (vagy egy tömb) és egy célelem, amelyet keresünk.
2. Inicializálja az 'index' nevű változót -1-re: Ez a változó a célelem indexének tárolására szolgál, ha megtalálható.
3. Lapozás az elemek listáján: Az első elemtől kezdve, egyenként ellenőrizze a lista minden elemét.
4. Hasonlítsa össze a jelen elemet a kívánt elemmel az értékeléshez: Tartsa meg az aktuális elem indexét az indexváltozóban, és lépjen ki a ciklusból, ha a modern elem és a cél elem azonos.
5. A célelem indexének visszaadása: A ciklus befejezése után adja vissza az indexváltozóban tárolt értéket. Ha a célelem nem található, az index értéke -1 lesz.

(ii) Bináris keresés : Az a keresési algoritmus, amely úgy működik, hogy felosztja a listát, és ezeken a feleken belül keres, nagyobb valószínűséggel tartalmazza az elemet.

Algoritmus a bináris kereséshez: -

1. Bemenet: n elemből és egy x célelemből álló rendezett lista.
2. Változók inicializálása: Állítsa az alacsony indexet 0-ra, a magas indexet n-1-re, a középértéket pedig (alacsony+magas)/2-re.
3. Indítsa el a hurkot: Amíg az alacsony index kisebb vagy egyenlő, mint a magas index, ismételje meg a következő lépéseket.
4. Hasonlítsa össze a középső elemet x-szel: Ha a középső elem egyenlő x-szel, adja vissza a középső indexet.
5. Az alacsony vagy a magas index frissítése: Ha x nagyobb, mint a középső elem, állítsa az alacsony indexet közép + 1 értékre. Ellenkező esetben állítsa a magas indexet közép - 1 értékre.
6. Frissítse a középindexet: Közép = (alacsony+magas)/2.
7. A ciklus vége: Ha az alacsony index nagyobb, mint a magas index, akkor x nincs a listában, és az algoritmus hibát ad vissza.
8. Kimenet: Az x indexe a listában vagy a hibaüzenetben.

(iii) Mélységben történő keresés : Egy keresési algoritmus, amely minden ágat amennyire lehetséges megvizsgál, mielőtt megfordulna.

Az alábbi irányelvek érvényesek a mélységi keresésre:

1. válassza ki a gráf kezdő csúcsát vagy csomópontját a kezdéshez.
2. Adjon hozzá látogatójelet az első csúcshoz.
3. Helyezze a kezdő csúcsot közvetlenül egy verembe.
4. Amíg a verem ki nem ürül, ismételje meg a következő műveleteket: -
   • Távolítsa el a verem felső csúcsát.
   • Jelölje meg látogatottként, és illessze be a verembe a felugró csúcs minden nem látogatott szomszédját.
5. Folytassa ezt a folyamatot, amíg a gráf összes csúcsát meg nem látogatta.
6. Miután az összes csúcsot meglátogattuk, az algoritmus befejeződik, és a gráfon mélységi keresést hajtunk végre.

(iv) Szélesség-első keresés : Keresési algoritmus, amely feltárja a csomópont összes szomszédját, mielőtt a következő szintre lépne.

A szélességi keresés algoritmusa a következő:

1. Kezdje a gyökércsomóponttal vagy a kezdeti állapottal.
2. Adja hozzá a gyökércsomópontot egy sorhoz.
3. Ellenőrizze, hogy a sor üres-e; ha igen, akkor állítsa le az algoritmust.
4. Vegye ki az első elemet a sorból, és jelölje meg látogatottként.
5. Erősítse meg a kortárs csomópontot úgy, hogy az összes nem látogatott szomszédját hozzáadja a sorhoz.
6. Amíg meg nem találja a kívánt csomópontot, vagy amíg a várólista ki nem ürül, ismételje meg a 3–5. lépéseket.
7. Ha a célcsomópont megtalálható, állítsa vissza az útvonalat az előzetes állapotból a célállapotba.
8. Szüntesse meg a szabálykészletet, és jelentse, hogy a célállapot nem került azonosításra, ha a sor üres.

(v) Interpolációs keresés : Olyan keresési algoritmus, amely a keresett elemek értékeit használja az indexben elfoglalt pozíció becslésére.

Fontos, hogy a tömb egyenletesen oszlik el. Ellenkező esetben ez egy algoritmus.

Az elvárásoknak megfelelően működik.

Az algoritmus a következőképpen foglalható össze.

1. Szerezze meg a beviteli listát és a kulcsértéket a kereséshez.
2. Inicializálja az alsó és felső változókat a lista első és utolsó indexénél.
3. Ha az alsó érték kisebb vagy egyenlő nagyobb értékkel, akkor:-
   1. Számítsa ki a becsült helyet a következő képlet segítségével:
      pos = alacsony + ((magas - alacsony) / (arr[magas] - arr[alacsony])) * (x - arr[alacsony]).
   2. Adja vissza a pozíciót, ha a becsült pozícióérték kulcsérték.
   3. c) Ha a becsült pozícióérték kisebb, mint a kulcsérték, állítsa alacsonyabbra.
      Pozíció + 1.
   4. d) Ha a becsült pozíció értéke nagyobb, mint a kulcs Beállított értéke, pozíció - 1 felfelé.
4. Ha a kulcsérték nem található, adja vissza a -1-et, jelezve, hogy az érték nem szerepel a listában.

(vi) Ugráskeresés : Olyan keresési módszer, amely állandó hosszúságú lépésekben iterálja a listát, amíg meg nem találja a releváns elemet, vagy meg nem állapítja, hogy az már nincs jelen.

Az ugráskeresési algoritmus a következő:

1. Először állítsa be az ugrás méretét a tömbelemek számának négyzetgyökére.
2. A 'current' nevű változót állítja be a tömb első elemére.
3. Iterál a tömbön úgy, hogy ugrásméret szerint ugrál, miközben növeli a „jump” nevű változót.
4. Ha a meglévő elem kisebb, mint a kívánt elem, lépjen tovább a következő ugrásra.
5. Ha az aktuális elem nagyobb, mint a célelem, végezzen lineáris keresést az aktuális elem és az előző ugróelem között a célelem megtalálásához.
6. Ha a célelem nem található a tömbben, akkor -1-et ad vissza, jelezve, hogy nincs benne a tömbben.
7. Ha az elem megtalálható, akkor visszaadja az elem indexét a tömbben.

3. Grafikonalgoritmusok

A C mutatók és adatstruktúrák, például tömbök és linkelt listák támogatása alkalmassá teszi a gráfokat manipuláló algoritmusok megvalósítására, például a gráf két csomópontja közötti legrövidebb út megtalálására.

Különféle gráfalgoritmusok léteznek.

ők:-

Dijkstra algoritmusa: Olyan algoritmus, amely megtalálja a legrövidebb utat egy gráf két csomópontja között azáltal, hogy folyamatosan frissíti az egyes csomópontoktól való legrövidebb távolságot.A* algoritmus: Olyan módszer, amely folyamatosan frissíti a legrövidebb útvonalat a grafikon egyes csomópontjaihoz, hogy meghatározza a közöttük lévő legrövidebb utat.Prim algoritmusa: Megközelítés a súlyozott összefüggő gráf legkisebb feszítőfájának meghatározására.Kruskal algoritmusa: Megközelítés a csatolt súlyozott gráf legalacsonyabb feszítőfájának azonosítására.Bellman-Ford algoritmus: Olyan algoritmus, amely még akkor is, ha a gráf negatív élsúlyokkal rendelkezik, megjeleníti a legrövidebb utat egy adott ellátási csomópont és a hálózat összes többi csomópontja között.

4. Kriptográfiai algoritmusok

A C támogatja az alacsony szintű műveleteket és a hatékony adatkezelést, így ideális a kriptográfiában használt algoritmusok, például adattitkosítási és visszafejtő algoritmusok megvalósításához.

Különféle típusú titkosítási algoritmusok léteznek.

Ők:-

Hash algoritmusok: Ezek az algoritmusok fix méretű kimeneteket (hash) állítanak elő tetszőleges méretű bemenetekből. Ilyen például az MD5, SHA-1 és SHA-2.Szimmetrikus kulcsalgoritmusok: Az ilyen algoritmusok titkosítási és visszafejtési lépései ugyanazt a privát kulcsot használják. Az AES, DES és Blowfish néhány példa.Aszimmetrikus kulcs algoritmusok: A nyilvános kulcsot és a nem nyilvános kulcsot ezek a módszerek külön kulcsként használják a titkosításhoz és a visszafejtéshez. Néhány példa az RSA, az ECC és a DSA.Kulcscsere algoritmusok: Ezek az algoritmusok lehetővé teszik két fél számára a kulcsok biztonságos cseréjét egy nem biztonságos csatornán. Például megemlíthetjük a Diffie-Hellmant és az elliptikus görbét a Diffie-Hellmant.

Az algoritmus előnyei

Az algoritmusoknak számos előnye van.

ők:-

Sebesség és hatékonyság: Az algoritmusok nagy mennyiségű adatot tudnak gyorsan és pontosan feldolgozni, így hasznosak lehetnek olyan feladatoknál, amelyek túlságosan időigényesek vagy túlságosan hibásak az emberek számára.Következetesség: Az algoritmusok előre meghatározott irányelveket követnek. Konzisztens eredményeket tud produkálni anélkül, hogy személyes előítéletek és érzelmek befolyásolnák.Automatizálás: Az algoritmusok automatikusan végre tudnak hajtani feladatokat, így az emberek szabadon összpontosíthatnak összetettebb vagy kreatívabb feladatokra.Megnövelt pontosság: Az algoritmusok gyakran magasabb szintű pontosságot tudnak elérni, mint az emberek, különösen akkor, ha nagy mennyiségű adatot kezelnek.Jobb döntéshozatal: Az algoritmusok segítenek megalapozottabb és objektívebb döntéseket hozni az adatok elemzésével, valamint az emberek számára nehezen látható minták és trendek azonosításával.Méretezhetőség: Az algoritmusok könnyen skálázhatók fel vagy le, hogy megfeleljenek a változó igényeknek és munkaterhelésnek.

Az algoritmus hátrányai

Az algoritmusok nagyon hasznosak a programozáshoz, de az algoritmusoknak vannak hátrányai.

ők:-

Korlátozott hatókör: Az algoritmusok csak a hatókörükön belüli problémákat képesek megoldani, és előfordulhat, hogy nem képesek összetett vagy absztrakt problémák megoldására.Elfogultság: Az algoritmusok állandósíthatják és megerősíthetik a képzéshez használt adatok torzítását, ami tisztességtelen eredményekhez vezethet.Elégtelen átláthatóság: Sok algoritmus elrejti azt a folyamatot, amelyen keresztül következtetésekre jut. Ez megnehezítheti az eredmények átgondolását vagy ellenőrzését.Az adatok finomságára való hagyatkozás:A szabályrendszer helyessége erősen függ az oktatásban felhasznált adatok pontosságától és alkalmazhatóságától. A pontatlan vagy pontatlan hatások hibás adatok következményei lehetnek.visszafogott alkalmazkodóképesség:Az algoritmusokat úgy tervezték, hogy kövessék az irányelveket, és nem alkalmazkodnak a változó körülményekhez és feltételekhez.