Appunti completi Algoritmi e Strutture dati

Algoritmi e Strutture dati : complessità computazionale

Ricerca Lineare:

T_b(n) = Θ(1)

T_w(n) = Θ(n)

T_o(n) = Θ(n)

Ricerca dicotomica:

T_b(n) = Θ(1)

T_w(n) = Θ(log n)

T_o(n) = Θ(log n)

Ricerca Min/Max:

T_n(n) = Θ(n)

Selection sort:

T_b(n) = Θ(n²)

T_w(n) = Θ(n²)

T_o(n) = Θ(n²)

Insertion sort:

T_b(n) = Θ(n)

T_w(n) = Θ(n²)

T_o(n) = Θ(n²)

Bubble sort:

T_b(n) = Θ(n)

T_w(n) = Θ(n²)

T_o(n) = Θ(n²)

Merge:

T_m(n) = Θ(m + n)

T_w(n) = Θ(n)

T_o(n) = Θ(n)

Merge sort:

T_m(n) = Θ(n log n)

T_w(n) = Θ(n log n)

T_o(n) = Θ(n log n)

Parthion:

T_m(n) = Θ(n)

Ampuli sort:

T_b(n) = Θ(n log n)

T_w(n) = Θ(n²)

T_o(n) = Θ(n log n)

Ridimensionamento con espansione lineare:

T_m(n) = Θ(n)

Ridimensionamento con espansione geometrica:

T_am(n) = Θ(n)

Visita di una lista:

T_b(n) = Θ(n)

T_w(n) = Θ(n)

T_o(n) = Θ(n)

Inserimento in coda:

T_b(n) = Θ(1)

T_w(n) = Θ(n)

T_o(n) = Θ(n)

Ricerca di un elemento in una lista:

T_b(n) = Θ(1)

T_w(n) = Θ(n)

T_o(n) = Θ(n)

Cancellazione di un elemento:

T_b(n) = Θ(1)

T_w(n) = Θ(n)

T_o(n) = Θ(n)

Visita di un BST:

T_b(n) = Θ(n)

T_w(n) = Θ(n)

T_o(n) = Θ(n)

Cancellazione di un elemento in BST:

?

?

?

Ricerca di un elemento in BST:

T_b(n) = Θ(1)

T_w(n) = Θ(log n)

T_o(n) = Θ(log n)

Visita di una HT:

T_b(n) = Θ(n)

T_w(n) = Θ(n)

T_o(n) = Θ(n)

Inserimento di un elemento:

T_b(n) = Θ(log n)

T_w(n) = Θ(log n)

T_o(n) = Θ(log n)

Ricerca di un elemento in una HT:

T_b(n) = Θ(1)

T_w(n) = Θ(n)

T_o(n) = Θ(1)

Cancellazione di un elemento in HT:

T_b(n) = Θ(1)

T_w(n) = Θ(n)

T_o(n) = Θ(1)

Algoritmi e strutture dati: riassunto generale

Ricorsione:

Diretta, la procedura richiama se stessa

Indiretta, la procedura viene richiamata attraverso la chiamata di un'altra procedura

Dimostrazione matematica:

Se P è una proposizione, s'applicano due:

• 1. P(k) è vera per k = 1. (base)
• 2. È vera per un generico valore n. (ipotesi)
• Se a partire da P(n) riusciamo a dimostrare che anche P(n+1) è vera allora P(k) è vera per ogni k.

Divide et Impera:

Affidata a una radice nel principio di induzione matematica.

Metodo:

1. Divide, suddividere un problema P su sottoproblemi fino a quando il sottoproblema è risolvibile facilmente;
2. Impera, si risolve per ipotesi di aver risolto alcuni sottoproblemi;
3. Combina, si combinano i risultati delle sottosoluzioni per ottenere la soluzione complessiva.

Classificazione degli algoritmi ricorsivi:

Lineare, una sola chiamata a se stesso.

Binaria, la documenta ricorsione si cita più della funzione (esegue esse ultima istruzione).

Multipla, piú chiamate a se stesso.

Mutua, una prima funzione richiama una seconda che a sua volta richiama la prima.

Innestate, l'uso come argomento una chiamata a se stesso.

Svantaggi:

• I cicli certi la ricorsione infiniti errano sempre.
• Efficienza di una procedura iterativa.
• Le chiamate ricorsive possono raggiungere lo stack frame.
• Lo spazio di stack frame è numero di quoto da heap.
• Spreco di memoria per la memorizzazione di tutte le variabili locali.

Complessa complicatezza:

Notazione asintotica:

Limite auditorio superiore...

Limite auditorio inferiore...

• O(g(n)).
• O(g(n)).
• f(n) { ∃ o, c1 m}. c2. 0 n0.
• 0(m ⊆ g(n). n1 ⊆ gn.
• Limite auditorio ratio Θ(g(n)). Θ(g(n)). f(n) ff (c). m). n1. c2. g gn(n) c. gg r g-m. gn(n) cc m gg l m.
• ∀n>n0.

in n+c di ridurre una capacita n Δmax.

in n+c Δmax di ridurre una nuova capacita n Δnuovo.

altrimenti l'array non viene ribaltato.

NOTA: Δnuovo > Δmax

2. L'esecuzione garantita: perdita della capacita supplementare ma preparazioni della lunghezza richiesta:

in n+c di ridurre una capacita n Pmax.

in n+c di ridurre una nuova capacita n Pnuovo.

altrimenti l'array non viene ribaltato.

NOTA: Pnuovo > Pmax

Sia l'operazione limitata da quella guarentita durante cambio capacita spanazione O(n). In questo modo l'operazione non

frequenti di operazione limitata per n ribaltamenti capacita completa O(n²), somma quella operativa O(n).

3. Pila: una collezione di elementi che retrigua e memoriza di nuovo ad una logica LIFO, "last in, first out".

Vantaggi: non è necessario ridurare l'elemento di quale si vuole accedere. Se un utente inserita un intera lista

per errore si programma accede ai dati in ordine inverso.

Operazioni principali:

• inserisci, eliminazione, push e subsinazione, pop e accumulazione, top e sostituzione cima, controllo pila vuota, caricato
• lista pieno.

3. Coda: una collezione di elementi che retrigue le memoriza di nuovo ad ordine FIFO, "first in, first out".

Vantaggi: non è necessario eliminare l'elemento di nuovo acceduto per il predilaguazione dei dati.

sviluppa un operas elementi dopo il sulto fruppie la una, per nuovo azzabatura in elementi succedenti.

Operazioni principali:

• inserisci, eliminazione, add o accumulazione, remove o primesi, front e accumulazione del primo elemento, controllo coda
• vuota, sostitua coda piena.

4. Lista: è una struttura dati per rappresentare successioni di dati, adotta una schemma di rappresentazione ai cui sono

elementi costituzionatamente l’informazione utile (il nodo), l’elementazione strutturale che serve a

collegamento l'intera collezione.

1. Catenattro: soluzione instarata nei strutture della nodi, ogni nodo continui l'info e il link al nodo

succwente, per primo nodo e della lista e nell'offizio della nodo al ultimo nodo e link successivo all'info alla nodo

2. Circolare: ogni nodo ha a collegamento col nodo successe e ultimo nodo ha a collegamento alla fra della

lista.

3. Doppia: ogni nodo contenere a collegamento al nodo successe e a quello precedente.

4. Circolare doppia: ogni nodo ha a collegamento al nodo successivo e al nodo precedente. L'ultimo nodo ha

il collegamento alla testa della lista e il primo nodo ha il collegamento alla coda.

5. Ordinamento di una lista:

1. Lista: relazione esistante fra la posizione dei nodi nella lista.
2. Logia: relazione instratita fra il stilo dei nodi.