Esempi di algoritmi

Appunti

• Parametro valore: Per il tipo di base il modulo prende in valore senza modificarlo in seguito. Protezione: Immutabile, non può essere modificato all'interno del modulo.
• Parametro formale: Il valore del parametro dichiarato viene utilizzato all'interno del modulo. Protezione: Effimero, sono parametri di documentazione che prendono il posto di alcuni nomi del modulo dichiarato.
• Il record di attivazione di un modulo ha determinate caratteristiche:
  1. Variabili locali
  2. Formal vs. Parametri effettivi
  3. Ritorno al chiamante
  4. Appunto di R.A chiamante (registro variabili)
  5. Indirizzo di ritorno
  6. Note: posizionamento del codice
• La chiamata ricorsiva a una procedura consiste nel chiamare se stessa. La chiamata ricorsiva di una function si effettua assegnando il risultato ad una variabile/array.
• Le variabili statiche sono quelle dichiarate all'interno del key iniziale che non casual un indirizzo di memoria fisso e variano dinamicamente solo in caso puntatore, continuano in indirizzi di memoria, non hanno un indice e non sono ordini.
  • Statiche o Dinamiche
• Un tipo di dato è astratto se è descritto su carta, il concreto è definito sul computer.
• Il dato astratto è definito da semantica sintattica e motivazione o standard delle sue operazioni (produttiva e sintattica - significativa assoluta ad esaminare dalla sintattica, indipendentemente e come sono realizzati i dati e eseguente le operazioni).
• Sia il tipo astratto il tipo concreto. Un tipo ordine di interesse o separazione in T1 - T2 e o di D1, D2 fino a Dn. Una rappresentazione dell'astratto è composta da:
  • Vide) Dico) SU(d1)
  • Vide) Dico = Bl(d1), Bl(d1)^Bl(d1), Bl(d1)-Bl(d1, ...dm)
• La pila è una struttura ricca simile come una lista ma ha un solo punto di accesso, posso operare solo sul primo elemento:
  • First in - First out
• La coda è una struttura forte con due punti di accesso e inversione e svuoto intorno e la terminazione in coda.
  • First in - First out
• La lista ordinata è una lista i cui elementi sono in ordine da mantenere tutte le operazioni CS il secondo solo di esso.

-> Devo cercare una chiave K in una lista binaria al convento

(ignare le ridice) punini per il solo costo = O(logn)

-> La lista circolare è simile una lista semplice ma con elementi

ha un riferimento in più, quando è l'ultimo gli elemento

predecessore, quando è, ugualmente accadendo ogni giro una lista

Note

• Dato un numero m => numerologi con le cicche infinite

In modo iterativo: inizializzare ello una variabile m₀. While m>0 then

begin: m=653

m=0; lo+1+7=7; m=2+lo+5=25 (m=25>+l) m:=m; m₁₀ | m:=m div 10

m=0 m=lo end;

• Dato un array a (lunghezza m) => la chiave X è presente in A?

In modo iterativo: assigno A[m+1]:=x cosi che X è invlato agile.

E successivamente con m donvalo := m-1 posizione di epresso m+1

• Per calcolare lo scopo (elemento per esempio) accumule che gli

elementi sono tutti contenuti in una vendere, poiché ci accadendo pol punirre le media è a collo scarto non possono "passare"

• Il procedimento del tipo: polimento (ortici) lo spesso per trovare si variabile.

Valore che pol. escelo il punto distangla dello stesso

poi a sentire associare invla la struttura interna

variabile quando rosifico il punto di patenza della lista

• nella procedimento è possibile verete la ricorsione valutata (formen dare) nella function while no

• Data una lista L => la chiave x è presente in L?

In modo iterativo: Inancio la seminali S in modo ricossico:

con il valore di x collegato

elemento nella lista

FUNCTION cerca (il; S, lista; x, integer) boolean

begin

S_A lists l x

while fun keys crea una sintura con gli stessi po giorno in ordine invassa (stesso ordine)

In modo iterativo: mensuco tur il delegando con il in una pila b (good: C)

• Data una lista L => modisca il manetinggli di elenenti
• Per esporno 2 punline p:q per generare una usa si resoprenza gli element

PROCEDURE SIZE (VAR P: O, N; VAR INTBOLL: O, N; VAR EL: LISTA_ARRAY);

BEGIN

IF INTBOLL=0 THEN ERROR

ELSE

BEGIN

P:= INTBOLL

INTBOLL:= EL[INTBOLL].NEXT

END; END;

PROCEDURE RELEASE (P: O, N; VAR EL: LISTA_ARRAY; VAR INTBOLL: O, N);

BEGIN

EL[P].NEXT:= INTBOLL

INTBOLL:= P

END;

FUNCTION CONTA (L: LISTA_PUNTATORE): INTEGER;

BEGIN

IF L= NIL THEN CONTA:=0

ELSE

CONTA:= 1 + CONTA (L^.NEXT)

END;

FUNCTION CONTA (L: LISTA_ARRAY; INTBOL,INTBOLL: INTEGER): INTEGER;

BEGIN

IF INTBOL = 0 THEN CONTA:=0

ELSE

CONTA:= 1 + CONTA (L, L[INTBOL].NEXT, INTBOLL)

END;

PROCEDURE CONS (X: INTEGER; VAR L: LISTA_SEQUENZIALE);

BEGIN

IF L.LUNGHEZZA= N THEN

DIMENSIONE INSUFFICIENTE

ELSE

BEGIN

IF L.LUNGHEZZA=0 THEN L.PRIMO:=1

ELSE

IF L.PRIMO=1 THEN L.PRIMO:=N

ELSE

L.PRIMO:= L.PRIMO - 1

L.ELEMENTI[L.PRIMO]:= X

END; L.LUNGHEZZA:=L.LUNGHEZZA +1

END;

PROCEDURE CONS (X: INTEGER; VAR L: LISTA_PUNTATORE);

VAR P: LISTA_PUNTATOK;

BEGIN

NEW(P);

P^.KEY:= X

P^.NEXT:= L

L:= P

END;

PROCEDURE CONS (X: INTEGER; VAR L: LISTA_ARRAY; INTBOLL: VAR: O, N);

BEGIN

SIZE (P, INTBOLL);

L[P].KEY:= X;

L[P].NEXT:= INTBOL;

INTBOL:= P

END;

• PROCEDURE INS (VAR L: listaPuntatori; x: integer);VAR P: listaPuntatoribeginINSU(P);P^.key := xIF L = NIL THENbeginP^.next := NIL;L := PendelseIF x < L^.key THENbeginP^.next := L;L := PendelseINS(L^.next,x);

end;

• PROCEDURE CANC(VAR L: listaPuntatori; x: integer);VAR P: listaPuntatori;beginIF L = NIL THENbeginIF x = L^.key = x THENbeginL := L^.next;DISPOSE(P);endelseIF x < L^.key THENCANC(L^.next,x)

end;

• TYPE LISTABARRAY = ARRAY[1..N] of recordkey: integernext: 0..NPrec: 0..Nend;

VAR Inizio,Inizio_L: 0..N;

• TYPE LISTAPUNTATORI = ^.elementi;elementi = recordkey: integerPrec: listaBnext: listaBend;

• NULL e CARSONO LE STESSEDELLE LISTE SERIALI

• PROCEDURE VISITARE PROFONDITÀ (a: Albero), VAR P: Pila; begin INIZIALIZA(P); PUSH(P, a); While not Pilavuota(P) do begin a := POP(P); VISITA (a^.key); If (a^.R <> nil) then PUSH(P, a^.R); If (a^.L <> nil) then PUSH(P, a^.L); end; end;
• PROCEDURE VISITARE LIVELLI (a: Albero), VAR C: Coda; begin INIZIALIZA(C); WSCoda(C, a); While not CODAVUOTA(C) do begin a := OUTCODA(C); VISITA(a^.key); If (a^.L <> nil) then WSCoda(C, a^.L); If (a^.R <> nil) then WSCoda(C, a^.R); end; end;
• PROCEDURE VISISTORIA (var Q: Albero, a: Element, fatc: integer); begin If (a <> nil) then begin: fatc := fatc + a^.key; If not (cerca(a)) then begin wsFoglia(a^.L, a^.L, fatc); wsFoglia(a^.R, fatc); end; else begin ws(a); a^.L, key := fatc; a^.L^.A := nil; a^.L^.B := nil; end; end;
• FUNCTION CERCA (a: Albero, k: integer): boolean; begin If (a = nil) then cerca := False; else If a^.key = k then cerca := True else cerca := cerca(a^.L, k) or cerca(a^.R, k) end;