Große O-Notationen

Es ist eine Notation, die bestimmt, wie schnell oder langsam ein Algorithmus läuft. Diese Geschwindigkeit wird nicht durch Sekunden bestimmt, sondern dadurch, wie stark die Laufzeit eines Algorithmus mit zunehmender Anzahl an Elementen zunimmt.

Big O ist die Beziehung zwischen Zeit und Größe. Im gesamten Artikel sehen Sie Diagramme mit diesen Maßnahmen und können sie in der Praxis besser verstehen. Wir haben zwei Arten von Komplexität (räumlich und zeitlich).

Zeitliche Komplexität: Bestimmt, wie lange es dauert, den Algorithmus proportional zur Größe der Eingabe auszuführen.

Räumliche Komplexität: Bestimmt, wie viel Speicher zugewiesen wird, um das benötigte Element zu finden.

Warum das studieren?

• Damit können Sie feststellen, wie skalierbar ein Algorithmus ist
• Big O befasst sich immer mit dem schlimmsten Fall, Beispiel unten:

Beispiel:

• Sie haben eine Liste und möchten nach einem Artikel suchen, aber der Artikel befindet sich am Ende der Liste. Im schlimmsten Fall müssen Sie so viele Vorgänge wie möglich ausführen, bis Sie die gewünschten Daten gefunden haben.

Ausführungszeiten

Tempo Constante O(1):

• Unabhängig von der Größe des Arrays dauert es immer gleich lange

Beispiel:

• Inkrementieren oder Dekrementieren

function increment(value: number){
  return ++value
}

function decrement(value: number){
  return --value
}

• Nehmen Sie einen bestimmten Gegenstand

const fruits = ["apple", "orange", "grape", "banana"]

function getItem(items: string[], index: number) {
  return items[index]
}

const item = getItem(fruits, 2)
console.log(`fruit: ${item}`) // "grape"

• Erstens Element eines Arrays abrufen

const animes = ["one piece", "dragon ball", "naruto", "demon slayer"]

function getFirstElement(items: string[]){
 return items[0]
}

• Das letzte Element in einem Array abrufen

const animes = ["one piece", "dragon ball", "naruto", "demon slayer"]

function getLastElement(items: string[]){
 return items[item.length - 1]
}

let lastElement = getLastElement(animes)
console.log(`Last Element: ${lastElement}`)

Lineare Zeit O(n):

• Die Ausführungszeit wächst proportional zur Größe des Arrays
• Sortier- und binärer Suchalgorithmus
• Iteration mit nur einer Schleife

Beispiele:

• Um die größte Zahl in einer Reihe von 10 Elementen zu finden, scrolle ich durch alle Elemente, bis ich sie finde.
• Im schlimmsten Fall wird die größte Zahl die letzte sein.

const numbers = [0, 4, 8, 2, 37, 11, 7, 48]

function getMaxValue(items: number[]) {
    let max = numbers[0];
    for (let i=0; i <= items.length; i++){
      if(items[i] > max) {
        max = items[i]
      }
    }

    return max;
}

let maxValue = getMaxValue(numbers)

console.log(`Max Value: ${maxValue}`)

Logarithmische Zeit O(log n)

• Die Eingabegröße erhöht sich um n und die Ausführungszeit erhöht sich um log n, die Zeit wächst im logarithmischen Verhältnis.
• Denken Sie daran, dass n die Anzahl der Elemente im Array ist.
• Die Eingabe wächst schneller als die Ausführungszeit.

Beispiel:

• Wir führen eine binäre Suche in einem Array durch, um ein bestimmtes Element zu finden.

const numbers = [0, 9, 24, 78, 54, 88, 92, 100, 21, 90]

function binarySearch(nums: number[], target: number) {
    let left = 0;
    let right = nums.length - 1;

    while (left <= right) {
        let middle = Math.floor((right + left) / 2);

        if (nums[middle] === target) {
            return middle;
        } else if (nums[middle] < target) {
            left = middle + 1;
        } else {
            right = middle - 1;
        }
    }

    return -1;
}

let getTarget = binarySearch(numbers, 92)
console.log(`Target: ${getTarget}`)

• Um das logarithmische Wachstum besser zu verstehen, betrachten wir es wie folgt: Das Array, das wir im Beispiel verwenden, hat 10 Eingänge, also:

log2(10) = 3,4
log2(20) = 4,3
log2(40) = 5,3

• Die folgende Grafik erleichtert das Verständnis:

Linearithmische/quasilineare Zeit O(n log n)

• Zeitkomplexität eines Algorithmus, der sich auf die n-fache Ausführung logarithmischer Operationen bezieht.
• Eine Mischung aus O(log(n)) und O(n).
• Ein Beispiel für eine Struktur ist die Zusammenführungssortierung.
• wächst mäßig.

• Ein Teil skaliert in n und der andere Teil skaliert in log(n). Das folgende Beispiel ist eine glückliche Zusammenführung:

function increment(value: number){
  return ++value
}

function decrement(value: number){
  return --value
}

Quadratische Zeit O(n²)

• Die Ausführungszeit erhöht sich quadratisch mit der Anzahl der Eingaben.
• Lesematrix.
• Grundsätzlich, wenn 2 verschachtelte Schleifen erforderlich sind
• Blasensortierung

Beispiel:

const fruits = ["apple", "orange", "grape", "banana"]

function getItem(items: string[], index: number) {
  return items[index]
}

const item = getItem(fruits, 2)
console.log(`fruit: ${item}`) // "grape"

Zeitexponential O(2ˆn)

• Mit jedem in die Eingabe eingefügten Element verdoppelt sich die Ausführungszeit.

• Ein Beispiel für diesen Code ist Fibonacci

const animes = ["one piece", "dragon ball", "naruto", "demon slayer"]

function getFirstElement(items: string[]){
 return items[0]
}

Fakultätszeit O(n!)

• Die Ausführungszeit erhöht sich faktoriell entsprechend der Größe der Eingabe.

Beispiel:

• Generieren Sie alle Permutationen innerhalb eines Arrays

const animes = ["one piece", "dragon ball", "naruto", "demon slayer"]

function getLastElement(items: string[]){
 return items[item.length - 1]
}

let lastElement = getLastElement(animes)
console.log(`Last Element: ${lastElement}`)

Das obige ist der detaillierte Inhalt vonGroße O-Notationen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!