Arbejder med algoritmiske funktioner - dummier

En funktion i matematik er simpelthen en måde at kortlægge nogle input til et svar. Udtrykt på en anden måde er en -funktion en transformation (baseret på matematikoperationer), der omdanner (kort) dit input til et svar.

For bestemte værdier for input (normalt betegnet med bogstaverne x eller n), har du et svar svarende ved hjælp af matematikken, der definerer funktionen. For eksempel fortæller en funktion som f (n) = 2 n, at når din indtastning er et tal n, er tallet n ganget med 2.

Ved hjælp af størrelsen af indgangen er det fornuftigt, da dette er en tidskritisk alder, og folks liv er proppet med en voksende mængde data. At gøre alt til en matematisk funktion er lidt mindre intuitiv, men en funktion, der beskriver, hvordan en algoritme relaterer sin løsning til mængden af data, den modtager, er noget, du kan analysere uden specifik hardware- eller software support. Det er også nemt at sammenligne med andre løsninger, i betragtning af størrelsen af dit problem. Analyse af algoritmer er virkelig et tankegangskoncept, fordi det reducerer en kompleks række trin i en matematisk formel.

Desuden er en analyse af algoritmerne ikke engang interesseret i at definere funktionen nøjagtigt. Hvad du virkelig vil gøre, er at sammenligne en målfunktion med en anden funktion. Disse sammenligningsfunktioner vises inden for et sæt foreslåede funktioner, der udfører dårligt, når de står i modsætning til målalgoritmen. På denne måde behøver du ikke at tilslutte tal til funktioner med større eller mindre kompleksitet; I stedet beskæftiger du dig med enkle, præmade og velkendte funktioner. Det kan lyde groft, men det er mere effektivt og svarer til at klassificere algoritmernes præstation i kategorier, i stedet for at opnå en præcis præstationsmåling.

Sættet med generelle funktioner kaldes Big O notation, og du støder ofte på dette lille sæt funktioner (i parentes og forud for en kapital O >) bruges til at repræsentere algoritmernes ydeevne. Figuren viser analysen af en algoritme. Et kartesisk koordinatsystem kan repræsentere sin funktion som målt ved RAM-simulering, hvor abscissa (x-koordinaten) er størrelsen af indgangen og ordinaten (y-koordinaten) er dens resulterende antal operationer. Du kan se tre kurver repræsenteret. Indgangsstørrelse betyder noget. Men kvaliteten er også vigtig (for eksempel når man bestiller problemer, er det hurtigere at bestille et input, der allerede er næsten bestilt).Følgelig viser analysen det værste tilfælde, f 1 (n), et gennemsnitligt tilfælde, f 2 (n) og et bedste tilfælde, f 3 (n). Selvom det gennemsnitlige tilfælde kan give dig en generel ide, er det værste, at du virkelig bekymrer dig om, fordi problemer kan opstå, når din algoritme kæmper for at nå frem til en løsning. Big O-funktionen er den, der efter en bestemt værdi

n0 (tærsklen for at betragte en stor indgang) altid resulterer i et større antal operationer, der får samme indgang end den værste tilfælde > f1 . Således er Big O-funktionen endnu mere pessimistisk end den der repræsenterer din algoritme, så uanset kvaliteten af input kan du være sikker på, at tingene ikke kan blive værre end det. Kompleksiteten af en algoritme i tilfælde af bedste, gennemsnitlige og værste input-tilfælde. Mange mulige funktioner kan resultere i dårligere resultater, men valget af funktioner, der tilbydes af Big O notationen, som du kan bruge, er begrænset, fordi formålet er at forenkle kompleksitetsmåling ved at foreslå en standard. Derfor indeholder dette afsnit kun de få funktioner, der er en del af Big O notationen. Følgende liste beskriver dem i stigende rækkefølge af kompleksitet:

Konstant kompleksitet O (1):

Samme tid, uanset hvor meget input du giver. I sidste ende er det et konstant antal operationer, uanset hvor lang tid inputdataene er. Dette niveau af kompleksitet er ret sjældent i praksis.

Logaritmisk kompleksitet O (log n): Antallet af operationer vokser ved en langsommere hastighed end indgangen, hvilket gør algoritmen mindre effektiv med små indgange og mere effektiv med større. En typisk algoritme for denne klasse er binær søgning.
Lineær kompleksitet O (n): Operationer vokser med input i et 1: 1 forhold. En typisk algoritme er iteration, som er, når du scanner input en gang og anvender en operation til hvert element af det.
Linearitmisk kompleksitet O (n log n): Kompleksitet er en blanding mellem logaritmisk og lineær kompleksitet. Det er typisk for nogle smarte algoritmer, der bruges til at bestille data, såsom Mergesort, Heapsort og Quicksort.
Kvadratisk kompleksitet O (n 2
): ^{Operationer vokser som et firkant af antallet af indgange. Når du har en iteration inde i en anden iteration (indlejrede iterationer, i datalogi), har du kvadratisk kompleksitet. For eksempel har du en liste over navne, og for at finde de mest lignende, sammenligner du hvert navn med alle de andre navne. Nogle mindre effektive ordningsalgoritmer præsenterer sådan kompleksitet: boble sortering, valg sortering og insertion sortering. Dette niveau af kompleksitet betyder, at dine algoritmer kan løbe i timer eller endda dage, før de når en løsning.} Kubisk kompleksitet O (n 3
): ^{Operationer vokser endnu hurtigere end kvadratisk kompleksitet, fordi nu har du flere indlejrede iterationer. Når en algoritme har denne rækkefølge af kompleksitet, og du skal behandle en beskeden mængde data (100.000 elementer), kan din algoritme løbe i årevis.Når du har en række operationer, der er en effekt af input, er det almindeligt at henvise til algoritmen som} kører i polynomisk tid. Eksponentiel kompleksitet O (2 n
): ^{Algoritmen tager to gange antallet af tidligere operationer for hvert nyt element tilføjet. Når en algoritme har denne kompleksitet, kan selv små problemer tage for evigt. Mange algoritmer gør udtømmende søgninger har eksponentiel kompleksitet. Det klassiske eksempel på dette niveau af kompleksitet er imidlertid beregningen af Fibonacci-tal.} Faktisk kompleksitet O (n!): Et ægte mareridt af kompleksitet på grund af det store antal mulige kombinationer mellem elementerne. Bare forestil dig: Hvis din indtastning er 100 objekter, og en operation på din computer tager 10
-6 sekunder (en rimelig hastighed for hver computer, i dag), skal du bruge omkring 10 ¹⁴⁰ år at fuldføre opgaven med succes (en umulig tid siden universets alder skønnes at være 10 ¹⁴ år). Et kendte factorial kompleksitetsproblem er det rejseforhandlerproblem, hvor en sælger skal finde den korteste rute for at besøge mange byer og komme tilbage til startbyen.