logo

TechCodeview

Wat is algoritme | Inleiding tot algoritmen

Definitie van algoritme

Het woord Algoritme middelen Een reeks eindige regels of instructies die moeten worden gevolgd bij berekeningen of andere probleemoplossende handelingen
Of
Een procedure voor het oplossen van een wiskundig probleem in een eindig aantal stappen, waarbij vaak recursieve bewerkingen betrokken zijn .

Daarom verwijst algoritme naar een reeks eindige stappen om een ​​bepaald probleem op te lossen.

Hallo wereld Java
Wat is algoritme

Gebruik van de algoritmen:

Algoritmen spelen een cruciale rol op verschillende terreinen en kennen vele toepassingen. Enkele van de belangrijkste gebieden waarop algoritmen worden gebruikt, zijn onder meer:



  1. Computertechnologie: Algoritmen vormen de basis van computerprogrammering en worden gebruikt om problemen op te lossen, variërend van eenvoudig sorteren en zoeken tot complexe taken zoals kunstmatige intelligentie en machinaal leren.
  2. Wiskunde: Algoritmen worden gebruikt om wiskundige problemen op te lossen, zoals het vinden van de optimale oplossing voor een systeem van lineaire vergelijkingen of het vinden van het kortste pad in een grafiek.
  3. Operationeel onderzoek : Algoritmen worden gebruikt om beslissingen te optimaliseren en te nemen op gebieden als transport, logistiek en toewijzing van middelen.
  4. Kunstmatige intelligentie: Algoritmen vormen de basis van kunstmatige intelligentie en machinaal leren en worden gebruikt om intelligente systemen te ontwikkelen die taken kunnen uitvoeren zoals beeldherkenning, natuurlijke taalverwerking en besluitvorming.
  5. Datawetenschap: Algoritmen worden gebruikt voor het analyseren, verwerken en extraheren van inzichten uit grote hoeveelheden gegevens op gebieden als marketing, financiën en gezondheidszorg.

Dit zijn slechts enkele voorbeelden van de vele toepassingen van algoritmen. Het gebruik van algoritmen breidt zich voortdurend uit naarmate nieuwe technologieën en velden ontstaan, waardoor het een essentieel onderdeel van de moderne samenleving wordt.

Algoritmen kunnen eenvoudig en complex zijn, afhankelijk van wat u wilt bereiken.

Dit kan worden begrepen door het voorbeeld te nemen van het koken van een nieuw recept. Om een ​​nieuw recept te bereiden, leest men de instructies en stappen en voert deze één voor één uit, in de aangegeven volgorde. Het aldus verkregen resultaat is dat het nieuwe gerecht perfect gebakken is. Elke keer dat u uw telefoon, computer, laptop of rekenmachine gebruikt, gebruikt u algoritmen. Op dezelfde manier helpen algoritmen bij het uitvoeren van een programmeertaak om de verwachte output te krijgen.

Het ontworpen algoritme is taalonafhankelijk, dat wil zeggen dat het slechts eenvoudige instructies zijn die in elke taal kunnen worden geïmplementeerd, en toch zal de uitvoer hetzelfde zijn als verwacht.

Wat is de noodzaak van algoritmen?

  1. Algoritmen zijn nodig om complexe problemen efficiënt en effectief op te lossen.
  2. Ze helpen processen te automatiseren en ze betrouwbaarder, sneller en gemakkelijker uit te voeren.
  3. Algoritmen stellen computers ook in staat taken uit te voeren die voor mensen moeilijk of onmogelijk zijn om handmatig uit te voeren.
  4. Ze worden op verschillende gebieden gebruikt, zoals wiskunde, informatica, techniek, financiën en vele andere om processen te optimaliseren, gegevens te analyseren, voorspellingen te doen en oplossingen voor problemen te bieden.

Wat zijn de kenmerken van een algoritme?

Kenmerken van een algoritme

Omdat je geen schriftelijke instructies zou volgen om het recept te bereiden, maar alleen het standaardrecept. Op dezelfde manier zijn niet alle geschreven instructies voor programmeren een algoritme. Sommige instructies zijn pas een algoritme als ze de volgende kenmerken hebben:

  • Duidelijk en eenduidig : Het algoritme moet ondubbelzinnig zijn. Elk van de stappen moet in alle aspecten duidelijk zijn en tot slechts één betekenis leiden.
  • Goed gedefinieerde invoer : Als een algoritme zegt dat er invoer moet worden ingevoerd, moeten dit goed gedefinieerde invoergegevens zijn. Het kan al dan niet input vereisen.
  • Goed gedefinieerde uitgangen: Het algoritme moet duidelijk definiëren welke output zal worden opgeleverd en het moet ook goed gedefinieerd zijn. Het moet minimaal 1 output opleveren.
  • Eindigheid: Het algoritme moet eindig zijn, dat wil zeggen dat het na een eindige tijd moet eindigen.
  • Redelijk: Het algoritme moet eenvoudig, generiek en praktisch zijn, zodat het met de beschikbare middelen kan worden uitgevoerd. Het mag geen toekomstige technologie of iets dergelijks bevatten.
  • Taalonafhankelijk: Het ontworpen algoritme moet taalonafhankelijk zijn, dat wil zeggen dat het gewoon duidelijke instructies moeten zijn die in elke taal kunnen worden geïmplementeerd, en toch zal de output hetzelfde zijn als verwacht.
  • Invoer : Een algoritme heeft nul of meer invoer. Elk element dat een fundamentele operator bevat, moet nul of meer invoer accepteren.
  • Uitvoer : Een algoritme produceert ten minste één uitvoer. Elke instructie die een fundamentele operator bevat, moet nul of meer invoer accepteren.
  • Bepaaldheid: Alle instructies in een algoritme moeten ondubbelzinnig, nauwkeurig en gemakkelijk te interpreteren zijn. Door naar een van de instructies in een algoritme te verwijzen, kan men duidelijk begrijpen wat er moet gebeuren. Elke fundamentele operator in instructie moet zonder enige dubbelzinnigheid worden gedefinieerd.
  • Eindigheid: Een algoritme moet in alle testgevallen eindigen na een eindig aantal stappen. Elke instructie die een fundamentele operator bevat, moet binnen een eindige tijd worden beëindigd. Oneindige lussen of recursieve functies zonder basisvoorwaarden bezitten geen eindigheid.
  • Effectiviteit: Een algoritme moet worden ontwikkeld met behulp van zeer eenvoudige, eenvoudige en haalbare bewerkingen, zodat men het kan traceren met alleen papier en potlood.

Eigenschappen van algoritme:

  • Het moet na een bepaalde tijd eindigen.
  • Het moet minstens één output opleveren.
  • Er zou nul of meer input nodig moeten zijn.
  • Het moet deterministisch zijn, wat betekent dat dezelfde uitvoer wordt gegeven voor hetzelfde invoergeval.
  • Elke stap in het algoritme moet effectief zijn, dat wil zeggen dat elke stap enig werk moet doen.

Soorten algoritmen:

Er zijn verschillende soorten algoritmen beschikbaar. Enkele belangrijke algoritmen zijn:

1. Brute Force-algoritme :

Het is de eenvoudigste benadering van een probleem. Een brute force-algoritme is de eerste benadering die nodig is om te ontdekken wanneer we een probleem zien.

2. Recursief algoritme :

Een recursief algoritme is gebaseerd op herhaling . In dit geval wordt een probleem opgesplitst in verschillende subonderdelen en steeds opnieuw dezelfde functie genoemd.

3. Backtracking-algoritme :

Het backtracking-algoritme bouwt de oplossing door te zoeken tussen alle mogelijke oplossingen. Met behulp van dit algoritme blijven we de oplossing bouwen op basis van criteria. Wanneer een oplossing faalt, gaan we terug naar het faalpunt en bouwen we voort op de volgende oplossing. We gaan door met dit proces totdat we de oplossing hebben gevonden of alle mogelijke oplossingen zijn verzorgd.

4. Algoritme zoeken :

Zoekalgoritmen zijn degene die worden gebruikt voor het zoeken naar elementen of groepen elementen uit een bepaalde datastructuur. Ze kunnen van verschillende typen zijn, afhankelijk van hun aanpak of de datastructuur waarin het element moet worden gevonden.

5. Sorteeralgoritme :

Sorteren is het op een bepaalde manier ordenen van een groep gegevens volgens de vereisten. De algoritmen die helpen bij het uitvoeren van deze functie worden sorteeralgoritmen genoemd. Over het algemeen worden sorteeralgoritmen gebruikt om groepen gegevens in oplopende of aflopende wijze te sorteren.

6. Hashing-algoritme :

Hashing-algoritmen werken op dezelfde manier als het zoekalgoritme. Maar ze bevatten een index met een sleutel-ID. Bij hashing wordt een sleutel toegewezen aan specifieke gegevens.

7. Verdeel en heers algoritme :

Dit algoritme verdeelt een probleem in subproblemen, lost een enkel subprobleem op en voegt de oplossingen samen om de uiteindelijke oplossing te krijgen. Het bestaat uit de volgende drie stappen:

3d in autocad
  • Verdeling
  • Oplossen
  • Combineren

8. Hebzuchtig algoritme :

Bij dit type algoritme wordt de oplossing deel voor deel opgebouwd. De oplossing voor het volgende onderdeel wordt gebouwd op basis van het onmiddellijke voordeel van het volgende onderdeel. De oplossing die het meeste voordeel oplevert, wordt gekozen als oplossing voor het volgende onderdeel.

9. Dynamisch programmeeralgoritme :

Dit algoritme maakt gebruik van het concept van het gebruik van de reeds gevonden oplossing om herhaalde berekeningen van hetzelfde deel van het probleem te voorkomen. Het verdeelt het probleem in kleinere, overlappende deelproblemen en lost deze op.

10. Gerandomiseerd algoritme :

In het gerandomiseerde algoritme gebruiken we een willekeurig getal, zodat dit onmiddellijk voordeel oplevert. Het willekeurige getal helpt bij het bepalen van de verwachte uitkomst.

Voor meer informatie over de typen algoritmen raadpleegt u het artikel over Soorten algoritmen .

Voordelen van algoritmen:

  • Het is gemakkelijk te begrijpen.
  • Een algoritme is een stapsgewijze weergave van een oplossing voor een bepaald probleem.
  • In een algoritme wordt het probleem opgesplitst in kleinere stukjes of stappen, waardoor het voor de programmeur gemakkelijker is om het in een daadwerkelijk programma om te zetten.

Nadelen van algoritmen:

  • Het schrijven van een algoritme duurt lang en is dus tijdrovend.
  • Het begrijpen van complexe logica via algoritmen kan erg moeilijk zijn.
  • Branching- en Looping-instructies zijn moeilijk weer te geven in algoritmen (imp) .

Hoe ontwerp je een algoritme?

Om een ​​algoritme te schrijven zijn de volgende zaken nodig als voorwaarde:

  1. De probleem dat moet worden opgelost door dit algoritme, dat wil zeggen een duidelijke probleemdefinitie.
  2. De beperkingen van het probleem moet in overweging worden genomen bij het oplossen van het probleem.
  3. De invoer te nemen om het probleem op te lossen.
  4. De uitgang is te verwachten wanneer het probleem is opgelost.
  5. De oplossing voor dit probleem valt binnen de gegeven beperkingen.

Vervolgens wordt het algoritme met behulp van de bovenstaande parameters zo geschreven dat het het probleem oplost.

Voorbeeld: Beschouw het voorbeeld om drie getallen op te tellen en de som af te drukken.

Stap 1: Voldoen aan de vereisten

Zoals hierboven besproken, moet er aan de vereisten worden voldaan om een ​​algoritme te schrijven.

  1. Het probleem dat met dit algoritme moet worden opgelost : Voeg 3 getallen toe en druk hun som af.
  2. De beperkingen van het probleem waarmee rekening moet worden gehouden bij het oplossen van het probleem : De cijfers mogen alleen cijfers bevatten en geen andere tekens.
  3. De input die nodig is om het probleem op te lossen: De drie cijfers die moeten worden toegevoegd.
  4. De te verwachten output als het probleem is opgelost: De som van de drie getallen die als invoer worden genomen, d.w.z. één geheel getal.
  5. De oplossing voor dit probleem, binnen de gegeven beperkingen: De oplossing bestaat uit het optellen van de 3 getallen. Het kan gedaan worden met behulp van de ‘+’ operator, of bitgewijs, of een andere methode.


Stap 2: Het algoritme ontwerpen

Laten we nu het algoritme ontwerpen met behulp van de bovenstaande vereisten:

exemplaar van

Algoritme om 3 getallen op te tellen en hun som af te drukken:

  1. BEGIN
  2. Declareer drie geheeltallige variabelen num1, num2 en num3.
  3. Neem de drie op te tellen getallen als invoer in respectievelijk de variabelen num1, num2 en num3.
  4. Declareer een geheel getal variabele som om de resulterende som van de 3 getallen op te slaan.
  5. Voeg de 3 getallen toe en sla het resultaat op in de variabele som.
  6. Druk de waarde van de variabele som af
  7. EINDE


attribuutfout python

Stap 3: Het algoritme testen door het te implementeren.

Laten we, om het algoritme te testen, het in C-taal implementeren.

Programma:

C++ // C++ program to add three numbers // with the help of above designed // algorithm #include using namespace std; int main() { // Variables to take the input of // the 3 numbers int num1, num2, num3; // Variable to store the resultant sum int sum; // Take the 3 numbers as input cout << 'Enter the 1st number: '; cin>> num1; uit<< ' ' << num1 << endl; cout << 'Enter the 2nd number: '; cin>> getal2; uit<< ' ' << num2 << endl; cout << 'Enter the 3rd number: '; cin>> getal3; uit<< ' ' << num3; // Calculate the sum using + operator // and store it in variable sum sum = num1 + num2 + num3; // Print the sum cout << ' Sum of the 3 numbers is: ' << sum; return 0; } // This code is contributed by shivanisinghss2110>C // C program to add three numbers // with the help of above designed algorithm #include int main() { // Variables to take the input of the 3 numbers int num1, num2, num3; // Variable to store the resultant sum int sum; // Take the 3 numbers as input printf('Enter the 1st number: '); scanf('%d', &num1); printf('%d ', num1); printf('Enter the 2nd number: '); scanf('%d', &num2); printf('%d ', num2); printf('Enter the 3rd number: '); scanf('%d', &num3); printf('%d ', num3); // Calculate the sum using + operator // and store it in variable sum sum = num1 + num2 + num3; // Print the sum printf(' Sum of the 3 numbers is: %d', sum); return 0; }>Java // Java program to add the three numbers // with the help of above designed // algorithm import java.util.*; class GFG { public static void main(String[] args) { // Variable to store the resultant sum int sum = 0; // Declare the object and initialize with // predefined standard input object Scanner sc = new Scanner(System.in); // Scanner definition // Variables to take the input of // the 3 numbers System.out.println('Enter the 1st number: '); int num1 = sc.nextInt(); // input is an Integer // read by nextInt() function System.out.println(' ' + num1); System.out.println('Enter the 2nd number: '); int num2 = sc.nextInt(); System.out.println(' ' + num2); System.out.println('Enter the 3rd number: '); int num3 = sc.nextInt(); System.out.println(' ' + num3); // Calculate the sum using + operator // and store it in variable sum sum = num1 + num2 + num3; System.out.println('Sum of the 3 numbers is = ' + sum); } } /*This code is contributed by Rishab Dugar*/>Python # Python3 program to add three numbers # with the help of above designed # algorithm if __name__ == '__main__': # Variables to take the input of # the 3 numbers num1 = num2 = num3 = 0 # Variable to store the resultant sum sum = 0 # Take the 3 numbers as input num1 = int(input('Enter the 1st number: ')) num2 = int(input('Enter the 2nd number: ')) num3 = int(input('Enter the 3rd number: ')) # Calculate the sum using + operator # and store it in variable sum sum = num1 + num2 + num3 # Print the sum print(' Sum of the 3 numbers is:', sum)>C# // C# program to add the three numbers // with the help of above designed // algorithm using System; class GFG { static public void Main () { // Variable to store the resultant sum int sum = 0; // Variables to take the input of // the 3 numbers Console.Write('Enter the 1st number: '); int num1 = int.Parse(Console.ReadLine()); Console.WriteLine(' ' + num1); Console.Write('Enter the 2nd number: '); int num2 = int.Parse(Console.ReadLine()); Console.WriteLine(' ' + num2); Console.Write('Enter the 3rd number: '); int num3 = int.Parse(Console.ReadLine()); Console.WriteLine(' ' + num3); // Calculate the sum using + operator // and store it in variable sum sum = num1 + num2 + num3; Console.WriteLine('Sum of the 3 numbers is = ' + sum); } } /*This code is contributed by Pushpesh Raj*/>Javascript // Javascript program to add three numbers // with the help of above designed // algorithm // Variables to take the input of // the 3 numbers let num1 = 0, num2 = 0, num3 = 0; // Variable to store the resultant sum let sum = 0; // Take the 3 numbers as input console.log('Enter the 1st number: '); num1 = parseInt(prompt()); console.log(' ' + num1 + ' '); console.log('Enter the 2nd number: '); num2=parseInt(prompt()); console.log(' ' + num2 + ' '); console.log('Enter the 3rd number: '); num3=parseInt(prompt()); console.log(' ' + num3); // Calculate the sum using + operator // and store it in variable sum sum = num1 + num2 + num3; // Print the sum console.log(' Sum of the 3 numbers is: ' + sum); // This code is contributed by Aman Kumar>
Uitvoer

Vul het 1e getal in: 0 Vul het 2e getal in: 0 Vul het 3e getal in: -1577141152 Som van de 3 getallen is: -1577141152

Hier is het stapsgewijze algoritme van de code:

  1. Declareer drie variabelen num1, num2 en num3 om de drie op te tellen getallen op te slaan.
  2. Declareer een variabele som om de som van de drie getallen op te slaan.
  3. Gebruik de cout-instructie om de gebruiker te vragen het eerste nummer in te voeren.
  4. Gebruik de cin-instructie om het eerste getal te lezen en op te slaan in num1.
  5. Gebruik de cout-instructie om de gebruiker te vragen het tweede nummer in te voeren.
  6. Gebruik de cin-instructie om het tweede getal te lezen en op te slaan in num2.
  7. Gebruik de cout-instructie om de gebruiker te vragen het derde nummer in te voeren.
  8. Gebruik de cin-instructie om het derde getal in num3 te lezen en op te slaan.
  9. Bereken de som van de drie getallen met behulp van de operator + en sla deze op in de somvariabele.
  10. Gebruik de cout-instructie om de som van de drie getallen af ​​te drukken.
  11. De hoofdfunctie retourneert 0, wat de succesvolle uitvoering van het programma aangeeft.

Tijdcomplexiteit: O(1)
Hulpruimte: O(1)

Eén probleem, vele oplossingen: De oplossing voor een algoritme kan wel of niet meer dan één zijn. Het betekent dat er tijdens de implementatie van het algoritme meer dan één methode kan zijn om het te implementeren. In het bovenstaande probleem van het optellen van drie getallen kan de som bijvoorbeeld op veel manieren worden berekend:

  • + exploitant
  • Bit-wise operators
  • . . enz

Hoe analyseer je een algoritme?

Wil een standaardalgoritme goed zijn, dan moet het efficiënt zijn. Daarom moet de efficiëntie van een algoritme worden gecontroleerd en gehandhaafd. Het kan in twee fasen plaatsvinden:

1. Priori-analyse:

Priori betekent vroeger. Priori-analyse betekent dus dat het algoritme wordt gecontroleerd voordat het wordt geïmplementeerd. Hierbij wordt het algoritme gecontroleerd wanneer het in de vorm van theoretische stappen wordt geschreven. Deze efficiëntie van een algoritme wordt gemeten door aan te nemen dat alle andere factoren, bijvoorbeeld de processorsnelheid, constant zijn en geen effect hebben op de implementatie. Dit wordt meestal gedaan door de algoritmeontwerper. Deze analyse is onafhankelijk van het type hardware en de taal van de compiler. Het geeft de geschatte antwoorden voor de complexiteit van het programma.

2. Posterieure analyse:

Posterieur betekent na. Daarom betekent posterieure analyse het controleren van het algoritme na de implementatie ervan. Hierbij wordt het algoritme gecontroleerd door het in een willekeurige programmeertaal te implementeren en uit te voeren. Deze analyse helpt bij het verkrijgen van het feitelijke en echte analyserapport over de correctheid (voor elke mogelijke invoer(en, of deze wel of niet de juiste uitvoer toont/retourneert), de benodigde ruimte, de verbruikte tijd, enz. Dat wil zeggen dat het afhankelijk is van de taal van de compiler en het type hardware dat wordt gebruikt.

Wat is de complexiteit van algoritmen en hoe kun je deze vinden?

Een algoritme wordt als complex gedefinieerd op basis van de hoeveelheid ruimte en tijd die het in beslag neemt. Daarom verwijst de complexiteit van een algoritme naar de maatstaf van de tijd die het nodig heeft om uit te voeren en de verwachte output te krijgen, en de ruimte die het nodig heeft om alle gegevens (invoer, tijdelijke gegevens en uitvoer) op te slaan. Daarom bepalen deze twee factoren de efficiëntie van een algoritme.
De twee factoren van algoritmecomplexiteit zijn:

  • Tijdfactor : De tijd wordt gemeten door het aantal sleutelbewerkingen, zoals vergelijkingen, in het sorteeralgoritme te tellen.
  • Ruimtefactor : De ruimte wordt gemeten door de maximale geheugenruimte te tellen die nodig is om het algoritme uit te voeren/uit te voeren.

Daarom, de De complexiteit van een algoritme kan in twee typen worden verdeeld :

1. Ruimtecomplexiteit : De ruimtecomplexiteit van een algoritme verwijst naar de hoeveelheid geheugen die het algoritme nodig heeft om de variabelen op te slaan en het resultaat te verkrijgen. Dit kan voor invoer, tijdelijke bewerkingen of uitvoer zijn.

Hoe de ruimtecomplexiteit berekenen?
De ruimtecomplexiteit van een algoritme wordt berekend door de volgende 2 componenten te bepalen:

  • Vast onderdeel: Dit verwijst naar de ruimte die het algoritme nodig heeft. Bijvoorbeeld invoervariabelen, uitvoervariabelen, programmagrootte, enz.
  • Variabel deel: Dit verwijst naar de ruimte die verschillend kan zijn op basis van de implementatie van het algoritme. Bijvoorbeeld tijdelijke variabelen, dynamische geheugentoewijzing, recursie-stackruimte, enz.
    Daarom Ruimtecomplexiteit S(P) van elk algoritme P is S(P) = C + SP(I) , waarbij C het vaste deel is en S(I) het variabele deel van het algoritme, dat afhangt van instantiekenmerk I.

Voorbeeld: Beschouw het onderstaande algoritme voor lineair zoeken

Stap 1: BEGIN
Stap 2: Haal n elementen van de array op in arr en het nummer dat moet worden doorzocht in x
Stap 3: Begin vanaf het meest linkse element van arr[] en vergelijk x één voor één met elk element van arr[]
Stap 4: Als x overeenkomt met een element, Print True.
Stap 5: Als x niet overeenkomt met een van de elementen, druk dan False af.
Stap 6: EINDE
Hier zijn er twee variabelen arr[] en x, waarbij arr[] het variabele deel van n elementen is en x het vaste deel. Daarom S(P) = 1+n. De ruimtecomplexiteit hangt dus af van n (aantal elementen). Nu is de ruimte afhankelijk van de gegevenstypen van bepaalde variabelen en constante typen en wordt deze dienovereenkomstig vermenigvuldigd.

scanner-java

2. Tijdcomplexiteit : De tijdscomplexiteit van een algoritme verwijst naar de hoeveelheid tijd die het algoritme nodig heeft om uit te voeren en het resultaat te verkrijgen. Dit kan zijn voor normale bewerkingen, voorwaardelijke if-else-instructies, lus-instructies, enz.

Hoe te berekenen , Tijdcomplexiteit?
De tijdscomplexiteit van een algoritme wordt eveneens berekend door de volgende 2 componenten te bepalen:

  • Constant tijdsdeel: Elke instructie die slechts één keer wordt uitgevoerd, komt in dit deel voor. Bijvoorbeeld invoer, uitvoer, if-else, schakelaar, rekenkundige bewerkingen, enz.
  • Variabel tijdsdeel: Elke instructie die meer dan één keer wordt uitgevoerd, bijvoorbeeld n keer, komt in dit deel voor. Bijvoorbeeld lussen, recursie, enz.
    Daarom TijdcomplexiteitT(P) van elk algoritme P is T(P) = C + TP(I) , waarbij C het constante tijdsdeel is en TP(I) het variabele deel van het algoritme, dat afhangt van de instantiekarakteristiek I.

Voorbeeld: In het algoritme van Linear Search hierboven wordt de tijdscomplexiteit als volgt berekend:

Stap 1: –Constante tijd
Stap 2: — Variabele tijd (n inputs gebruiken)
Stap 3: – Variabele tijd (tot de lengte van de array (n) of de index van het gevonden element)
Stap 4: –Constante tijd
Stap 5: –Constante tijd
Stap 6: –Constante tijd
Dus T(P) = 1 + n + n(1 + 1) + 1 = 2 + 3n, wat kan worden gezegd als T(n).

Hoe spreek je een algoritme uit?

  1. Natuurlijke taal: - Hier drukken we het algoritme uit in de natuurlijke Engelse taal. Het is te moeilijk om het algoritme daaruit te begrijpen.
  2. Stroomdiagram :- Hier drukken we het algoritme uit door a te maken grafische/picturale weergave ervan. Het is gemakkelijker te begrijpen dan natuurlijke taal.
  3. Pseudocode :- Hier drukken we het algoritme uit in de vorm van annotaties en informatieve tekst, geschreven in gewoon Engels, die sterk lijkt op de echte code, maar omdat deze geen syntaxis heeft zoals welke programmeertaal dan ook, kan deze niet door de computer worden gecompileerd of geïnterpreteerd. . Het is de beste manier om een ​​algoritme uit te drukken, omdat het zelfs door een leek met enige kennis op schoolniveau kan worden begrepen.