03 10 . .

22

& Programma
Programma
-

-
>
Pseudo
> >
binario
/eseguibile)
1
Codice sorgente in
linguaggio
in C macchina

FUNZIONI
nome
codominio
- LIBRERIE T ↑
X

8 :R
SCRIVERE IN C f(x)
=
Ext

Introduce
Le Librerie
- deve essere
-standard library sempre presente
T
DIRETTIVE
DEL MEMORIA MACCHINA
PRECOMPILATORE sbit
standard input/output
> MAINI 123...

Stiamodefinendo,a me
-

# ·

- ... 590591

> dichiaro le variabili

> ARGOMENTO
SCRIVI
>
e
Istolo
-

DIRIZZO DI -

-
ALGORITMO PER SVOLGERE Istolio h)
MEMORIA IN CUl
.

E ALLOCATA LA
LA FUNZIONE MAIN & formato decimale VARIABILE
>
SEGNAPOSTO
OPPURE - printf (%D+%D=%D -
n”,A,B,C);
Esvalore variabile A CAPO
>Ok
· => O -
> ERRORE

Bisogna dichiarare il tipo e

il nome delle variabili
INT = /N -
> val a capo
FLOATE Q /B -

LONG =
I (INT) /R -T

DOUBLE =Q (FLOAT) 11 -
/
UNSIGNED =
N 1% >
-
%

Char =
Ya,
b ....,
2] caratteri
alfanumerici
(D

X
DATI DUE INTERI E
Y SCRIVI IL MAX

#include <stdlib.h> CONDIZIONE

>

#include <stdio.h> 1F( . . . . )

-

(A)
int main (void) & =

ESEL
int X, Y;
printf(“inserisci due interi:”);
scanf(“%d %d, &X, &Y); -
B si
?
no

if (X>Y) S
printf(“il massimo è %d, X”)
3 -
-

= (A)
(B)
3 else E
-

printf(“il massimo è %d, X”)

3 V

return(0)
'I
DATI TRE NUMERI INTERI X,
YEZ SCRIVI IL MAX

#include <stdlib.h>
#include <stdio.h>

int main (void) E

int X, Y, Z;
printf(“inserisci tre interi:”);
Si
T
no
IF ( . . . .

)[
scanf(“%d %d%d, &X, &Y, &Z);
if (X>Y) = (A)
Es = (A)
If (X>Z)
printf(“il massimo è %d, X”); !
else
35 V

printf(“il massimo è %d, Z”);

Y
3else E NON Posso
if (Y>Z) E Si
T
no =

printf(“il massimo è %d, Y”) SCRIVERE

3 else [
printf(“il massimo è %d, X”) = (A) (F( . . .

)[
3 V SELSES
return(0) -

S
-

-PERATORI
TERRORE

I
DI CONFRONTO NUMERI CI
IF
(A(B(39 & B! =
0)
-
! 3)
IF(B =
0 && A/B >

di
negazione
I

& &
> MODULO
and è il resto
della divisione
Resto
or V
STRUTTURA ITERATIVA

P
.
v

While ( )[
i
...

=
-

3 While ( ..
):

1. I=0
2. Se I<N allora prosegui altrimenti vai a 8
3. ….
4. ….
5. ….
For (assegnazione : condizione
, incremento) ?
6. I==+1
7. Vai al passo 2 V

8. ….
P

>? >

= RADICE QUADRATA

I I 1
(float)
= +
Sart

devo <math ha
includere .

#include <stdlib.h>
#include <stdio.h> e mettere come ultima opzione di compilazione -
em

int main (void) E

int A, K, I, M;
scanf(“%d %d”, &A, &K);
for (I=1; I<=K;i=i+1) S
M=A*I
printf(“%d n”,M);
I
oppure
I=1
while(I<=K) S
M=A*I;
print (“%d t”,M);
I=I+1;
I
return (0)
3
 ARRAY -
neupla di valori tutti dello stesso tipo
se il vettore ha dimensione n indici sono da 0 a N-1
gli
per definirlo :

- dimensione
int A100 ·
le variabili sono allocate tutte di
seguito
↓
AFOT ....
Alat

definirlo così
meglio :

#define MAX 100

int main void{

int [MAX]
…..
STDLIB H .
>

size off
printf("char :
din" ,
Sizeoff (char):
printf/ int Toin" Sizeoff (int):
:

printf("double :
din" ,
Sizeoff (double)):
restituisce l'indirizzo
del byte
↑
di memoria
o
1

malloc
memory allocation
(n
:
di byte) AGAFOT

scanf("% d" ,
& n) ; => INT Al100]

mesize = char

se
:.
una STRUTTURA è un nuovo tipo di dato composto da tante variabili scalari ,
o da strutture

=> STRUCT studente :

?
Char NOME 100] ; Es :
int man (rad) ?
int ESAMI ,
CREDITI ; struct
tipo
studenteSi t
di dato
posso fare un vettore
a

Float

3>
MEDIA

· int main (rads ?

importante senno
non funziona Structstudente * S;

int * X
,

X = malloc (100 + Size of (int) ;

S=
malloc /100 + Sizeof (Struct studente));
struct studente A,

A esami =
5 ;

A media 25 7 :
.
=

,
 23 na

STRUCT MATRICE
Sizeof (tipo) - > no byte 5678 3533

3533-17
(no byte)
-
malloc -1 ind . memoria
12 locaz
>
-

6 >
free (indice mem
-

o ,
-riga

A[5][4]
>
int
-

colonna
>
int alloca
-

n * 2 i come si
, , ;
y
Scant ("Yod" & n) ,
int * * A

2 =
malloc (N * Sizeof (int)) ; A =
malloc (5 Sizeof(in+* ))
*

for (i = 0
;
i< n
;
i ++ 1 for (i =
0; <5
,
i ++ /

A[i] RAND)( =
* [i] =
malloc (sizeof (int) 4) ; *

strutture dati
3 far
voglio
definire senza ricorso
agli array
LISTE
S NODO
S >
-

17 24 NULL 15
A
INFO NEXT M

nodo
L, puntatore
struct elemento
Successivo

int info ;

struct nodo * next ; LEGGI LISTA

Ii struct nodo
leggilista (vad)[
- stolio ht
# include .
intre i , ,

# include < stollib ha .

struct nodo *
p ,
*
Primo =
NULL ;

struct nodo printf ("quanti elementi ? ") :

int info ; Scanf("Yd", & n);

struct nodo * next ; for (i =
0; i < n
; i + +
14
3 i p
=
malloc(sizeof (struct nodo) ;
int main (vad) ? scanf ("Yod" apt in fo ,
.

) ,

l
struct nodo * A; penext
=
primo per separare
puntatore a l'indirizzo di memoria

leghista)
re
dal
primo p; campi
=

nodo
Stampalista (A) ; turn (prima);
return (0) ; 3
I
 STAMPA LISTA GENERA

vad stampadista /struct nodo * p)[ struct nodo

leggilista (vad)[
while (p : =
NULL) [ intre i ,
,

printf("dod" peinfol ,
struct nodo *
p primo =NULL ;
,

printf ("quanti elementi ? ")

3 p p next;
= >
-

Scanf("Yd", & n);

return
for (i 14
I
=
0; i < n
; i + +

p
=
malloc(sizeof (struct nodo) ;
p-> info =
rand)( % 100 ;

penext= primo

re primo p;
=

STAMPA LISTA in modo ricorsivo

turn (prima);
void stampadista (struct nodo *
pl[ 3
If (pi Nul 2
=

Stampadista /penext) : printf /"dod " peinfo) ;

se
>
-
=> si vertete
printf /"dod " peinfo) ; Stampadista (penext) ;
3
return ;

I
Lista di TIPO CODA
structiontu ma structuado int

ultimo
vod accoda

struct nodo *
pi

p mallo
=
(sizeof (struct nodo) :
P >
-
info =
X;
int main (void ,
P-> next = NULL;
struct nodo primo ultimo;
Nuci2
* ,
if ( * Ultimo ! =

Primo =
NULL
,
* ultimo next =p;
ultimo Null ;
jelse(
=

accoda/a primo
, ultimo
, 10) :
* primo p ; =

3 accoda/a primo
, ultimo
, 20) :

Ultimo
* =

p ,

return

3
28 nov

I GRAFI

insieme dei vertic

- V =

[0o ,
-
,
En 1
un GRAFO G =
(V E) ,
è una coppia di insiemi discreti e finiti
&
. insieme
degli spigoli
ECVXV

& [i 55) , ,
4 j
,
=
g ,
t
,
n -

1}
Wo
·

We
V
[Vo Va wil
S
vi =
Va Us
, , , ,

)
,

22 Va
G =

(100 22)(00 23) . . (e 50)(2 2) (20

, , .
2: 1

il è ORIENTATO
grafo (directed) (vi Uj) (25 wi)
Se =
, ,

sennò si dice NON ORIENTATO =

(2 Uj) =

(55 , wi)
,

↓ isomorfo a :

orientato
DAG
grafo
- =

acidico
Se (vi , j) E(G) =
Uj è ADIACENTE

IV (G)) =
n ->
numero vertici

IE(G)) =
m -
> numero
spigoli

spigde
in un
grefo orientato
-
J Vj è ADIACENTE a wi

↓
Vi
j
entrante
uscente

orientato
in un
grafo non

Ik In
è INCIDENTE so Un e Uk

GRADO DI V :

N(r) =

[w V(G) :
(u w) ,
(
E(G)) Il numero di
spigoli che sono incidenti a V

il è orientato
se
grafo non :

Nic] = N (r) 0
Quin 7
grado ENTRANTE E USCENTE

un CAMMINO è una successione di vertici a due a due ADIACENTI

p
=

Su,z wa} .....

(2) CE(G) > se
-
un cammino passa una o più
p (0 1
=

, ,
5 . 4) volte per un vertice ,
si dice che non

è SEMPLICE
lunghezza = n
spigoli
 un cammino che inizia e termina nello stesso vertice si dice CICLO
ACICLICO è un
un
grafo grafo che non contiene adi
>
un
na
cido che
uno
spigolo
allora il cammino è SEMPLICE che va da Wal
è detto CAPPIO

Se 7 p :
w -u Vu,weV(6) =
G Si dice CONNESSO
che
un cammino
2 due a
p
due ,
collega
vertici

Se G non è ORIENTATO

tea
S > ·
7 .

FORTEMENTE
CONNESSO i
i
T
=

completo che ha
un
grafo
e un
grafo due
collegat
J (v , v) e E(G) Fu ver, i ~

= V
-
-

- -

NON ORIENTATO L PRIMO GRAFO

·imm
ACICLICO
. >
-

ALBERO
hanno il minimo numero di
spigoli
>
-

CONNESSO
affinché sia connesso

hanno il massimo numero di

spigoli
>
-

affinché sia acidico

n'vertici-1
ni
spigoli
>
-
=

-
-

to >
-

il cammino che uniscedue vertici esiste

sempre ed è unico
T

·
La
le

=> costituiscono una PARTIZIONE dell'insieme dei vertici

Va

Va UV V =
1
.
Vz
2

V= rVe 0
.

=
.
3

↑ (v v) EE(G) weV1 VEVa Li

, .
5
,

7
un
grafo MULTIPARTITO è un
grafo la cui partizione dell'insieme
dei vertici è divisa in n sottoinsiemi
Es : G =
(V E), >
-

se tutti i
possibili spigoli sono connessi allora

. 2
Il
grafo è detto
VI
1
COMPLETO

i
Vz

K3
"

.
3
>
-
e indicato con
,
2
V3 4

.
5

K3 3 è
,
uno del più piccoli non PLANARE

G' è detto Sottografo di G se :

G =
(V., E)
>
·

V'EV è detto INDotto da V'EV Se .

·
ECE G =
G[v]
ha i vertici di G' ma ha tutti i possibili spigoli di G
INDotto
-
> albero ricoprente
T è SPANNING TREE di
-

G Se :

T è di G ;
sottogruppo
·

e albero
-

·
T :
-

·
v (T) =
V (G) : m

spinning
indica vertice
a un cammino per raggiungere ogni
PROBLEMI DI OTTIMIZZAZIONEL
↓ minimizza il costo

applicata diventa massimizza

al
grafi il ricavo

OTTIMIZZAZIONE COMBINATORIA
 rappresentare ?
come posso un
grafo
·
con una MATRICE DIADIACENZA :

particolarmente inefficiente
dato G =

(V E)
,

(vi)E
(0
se
M quadrata di ordine n =
VIG) to .

Maj =

1 2 .
01234
1 se (Vi Vj)
,
e E
·
0100 1

1 10101
O
M =
201011
~>
vertici adiacenti a 3 =
(2 4)
,

300101

4 11110
43

il è orientato la matrice è
grafo SIMMETRICA
>
se non
-

il
grado entrante è la somma della colonna
>
-

il
grado uscente è la somma della riga
>
-

con una LISTA DI ADIACENZA :

lista dei vertici adiacenti al vertice

Va

8
-1 - 4

1 >
2 > 4 >
O

2 >
4 > 1 >
3

3
>
2 > 4

4
3
O <
2 >
1 -3

>
operazioni elementari :
-

#include stollib ha .

# include -staio ha .

-
= ** V

struct nodo ? int

leggiGrafo (struct nodo * VII) ?
int info ; intr i,
,

struct nodo next; vertici ? ") ;

printf ("quanti
*

3 j

Scanf ("%d" & n) ;

int main
(void) [
int n ;- numero vertice vettore puntatori a
for (i =
o
;
i < n
; i + +
12
ili
strutture nodo
>
-

printf("inserisci vertici i adiacenti a % d",

struct nodo * VELOO]
V[i]
leggiGrafo (V) leggi Lista) ) :
=

Seturn (n)
n =
:
vedi 23 nov

stampeGrafo (V K) ; ,

return (0) ; I
3
void stampaGrafo (struct nodo * VIit ,
in + n) ;

int i
j

for (i =
0; i < m
; i + + )[
printf/"vertici adiacenti a % d :
"

,
il i
Stampa Lista (VEi]) ;
3 vedi 23 nov

return ;

I
lette le liste di adiacenza di orientato G stampare le liste di G
Es in input un
grafo
:
,

input due vertic veV(6) selu v) V(G) G Stampa G

letti in U
, , ,
aggiungilo a .

# include stollib ha .

# include stolio h > .

struct nodo ?
int info ;
int adiacente /struct nodo VI] intA int B)
struct nodo next;
, ,
*

3 j
struct nodo *
p ; intri
- primo elemento
>

(void) [
l'ORDINE delle condizioni
int main p V[A]
lista di adiacenza
è importante
-
=
A

int n ,
A B; ,
While (P != NULL &9 p
-
> infol =
B)
struct nodo * VELOO] P-p-onext ;
n =

leggiGrafo (V) : if (p = =
NUL)
stampeGrafo (V K) ; ,
V 0 =
;

scanf(" % d % d" & A& B) ; ,

else
if (adiacente (V A B) , ,
= =
0) r = 1;

B); return (r) ;

aggiung (V
A

Y
, ,

StempaGrafo(V n); ,

return (0) ;

I
B)
aggiung (struct
void nodo +
VI] intA in +
, ,

struct nodo *
p:

p malloc
=
(size of (structnodo) ;
p-> info =
Bi

p >
-
next =
VIA] ;
VIA] =
P;

return ;

3
5

GRAFO
matrice di adiacenza
liste di adiacenza
~
>
- >
-

- -

~
N(i) vitV(G)
vertich
puntatori

la prima operazione L :

VISITA DI UN GRAFO
a fa
↓
esplorare il
grafo in maniera efficiente

per non "perderci" segneremo i vertici visitate

ci sono due
strategie :

in AMPIEZZA :
visita il
grafo allontanandosi il meno
possibile dalla

Sorgente della visita

>
-

a permette di trovare il cammino più breve per arrivare ad un vertice

di BSF breadth fast search

=

algoritmo 5 6

devo tenere conto di :

C =
COLORE

= 4 1

i padre
loscelgo
- =

2 d distanza
(rospigdiv S) >
-
=
3
-

deve orientato accodare vertici del

essere connesso e -Qu =
coda in cui i
grafo
BFS(G ,
S)

!
1 per ogni weV(G) ripeti nella coda
li
ci
coloro
vanno
di
solo
nero
i vertici
grigi
ma poi
2 .
c(v) = bianco ,
i
(w) =
Nu ,
d = 0
:

fine-ciclo
&(n)
.
3

d(s) 2(s) accoda ( 5)

grigio
4. =
0 ,
=
, ,

.
5 fintanto che + ripeti

j
>
- primo elemento della coda a

.
6 Sian =

estral(a)
7
.
per s adiacente a ripeti mere
ogni
u
13
. fine-ciclo
.
8 Se c(u) =
bianco allora :

14 .
c(u) = nero ;

9
. c(u) =

grigio ,
accoda (Q 2) ,
15
. Fine-ciclo

E
π(w) 4
rivertici
10 .
=

11 . d() =
d(u) 1) + =G(n) +

12
. Fine-condizione
# include stollib ha .

# include stolio ha .

struct nodd
int info :

struct nodo * next ;

3 j

int man (vod)(

struct nodo *
V100] ,
* primo - Null ,
* Ultimo =
Null ;

int c [100] .
Pit100] DE100] , ,
u
,
v
,
n
,
i
,

Grafo (VI :
n
leggi
=

for (i = 0 ; i < n
;
i + +
14
c[i] =
0 : pi[i] =
-1 : D[i] = -

1:

I
Scanf (" % d" & S) ;

D(s] =
0 ; c[5] = 1 ; accoda /a primo
, aultimo ,
s) ;
while /primo != NU) ?
4 = estrai (a primo
, &ultimo) ,

p
=
V[r] ;
while (p ! Null) [ =

If (c[p
info) 0? -
> ==

d[p-infoj 1 =

accoda /a primo, d ultimo

, pinfo) ;

Pi[peinfoj =
U ; D[peinfo] D[u] =
+ 1;

3
P p = -
> next ;

3
c[u] =
2 :

3
Stampa Vettore/Pi n) ; ,
 7 dic

PROFONDITà più possibile della

In Si allontana il
sorgente
· :

di
algoritmo DFS depth first search
=

DFS(G)
per
ogni wev(G) ripeti
.
1
:

2 C(u) = bianco ,
in (v) =
NULL

.
3 fine-ciclo ;

ogni veV(G) ripeti

4.
per :

5 .
se ((2) =
bianco
, allora visita (G ,
2) ;
6
. fine-ciclo
7
. fine

visita (G v) ,

.
1 C(u) =

grigio ,
i = i + 1

sorgentez perché ha
2 per ogni UEN(2) ripeti
:
entrante O
grado
.

↓
.
3 se C(u) =
bianco allora :
pozzo + perché ha
- uscente O
1 grado
4 .
(4) =
0 %
3

.
5 visita (G ,
U
,
i
, p) ;
6 .
fine-condizione ; 0 . 2 4

7 .
fine-ciclo ;
8 C(u) =
nero ; f = F+ 1 ;
.

6 5
.
9 fine .

I 01152 P
& 12345 6

COMPLESSITÀ COMPUTAZIONALE :

10 13)

G(n m)
.

⑧
+
(1 10)
·

~ "If
↓
,

W
1
spigoli vertici SPANNING (11 12) ,

% TREE
se sono

tant (4 , 9) (2 3) ,

2 .
↓
1 2
SPANNING
i FOREST (5 8)
·
7
,
.
5

C
↑

es

L
0
.
5)
%3

16
7
,
72
E
2
↑
-

·
O -
3
O
21
4
.
1 .
6 ! 13 sa noi is
5
-
 12 olic

algoritmo in
grado di calcolare il cammino di costo
non il
minimo

più breve
da
sorgente singola
1
3

DIJKSTRA
-
I

5
15 5 10

.......
0 30 10
. 4

5
-
2 w(v , v) 20
15

principio del rilassamento prendere la strada più

10
:

65
costosa
lunga ma meno

(0 v) ,
- E(G)
w(p) + w(2 u) ,
<
W(r v) ,

DIJKSTRA (G ,
W , S) D(w) =
[W(vi Uj),

per
ogni wev(G) ripeti
1 :

.
2 on) D() in () NULL ;
=
20
,
=

.
3
Fine Cicada in cul metto tutti verta del
graf
4. Q V(G)=

/FwEV(f) :
accoda in Q) ;
.

5 8HD(S) =
0 ;
inizio ve ro

6
. fintanto che Q O ripeti
an
7
. U =
estrai da Q il vertice con D minima ;

.
8 per vertice u adiacente a u ripeti
Im ogni
0
9
. se D(w) >
D(u) + w(x + 2) :

10 .
T allora D(t) D(u) =
+ w(n + v) ;

11 .
# (2) 2 =
,

12 .
fine-condizione :
13 .
fine-ciclo ; >
-

G(n + n + 1 + n + m)
= d(nz +m)
14. fine-ciclo ;

15 Stop

per abbassare la comp .

comp .
scambio 4. e .
5

uso una coda di priorità

inserisco nell'heap vertice del
grafo
ogni
a seconda della D ,
di cui conosciamo solo la
sorgente
=>
quindi sarà la ama dell'albero .

a) 7 O(n) >
Ollogan )
-

al 10 . 0(1) -
>
allog n) ,

=> se usiamo la coda heap la comp .

dell'algoritmo sono /(n+ n) logen)

 π51 % 3151313191 ...

Cammino (i u) ,

fintanto che in (4) * NULL ripeti : Cammino

(it,
4)

Scrivi 4 : Se Uf Null allora :

u M(u)
- Cammino (it (4)) :
=

ricorsivo
; ,

fine-ciclo ; in mode Scrivi (4) :

SCRIVI U; fine-condizione :

fine fine ;

Dato
grafo G
un

calcolare il
grado entrante di veV(G)
trovare vertici pozzo e
sorgente
·

1 > 2 V
>
1 M O >
-
1

O
v 1 >
-
2
3
M 1

3
>
-
5 - 3
~
S
5 > 4
4 >
-
3

5 >
-
4 - 0 - 1- 2

int GradoEntrante (struct nodo * VI] intn , ,

intul[ X esonero

intG =
0, i;

struct nodo +pi

for (i = 0; i <n
; i ++ )4
P V[i] ;
=

while /P != Null
2
If (p-s info ==
0){
G = G+ 1;

P =
NULL ;

jelse(
P P = -
> next ;

3
3
I
return(G) :
 14 dic

BASI DI DATI
↓
(database) INDICE del dat
-
ordinati per ...

eseguo frequentemente
-
alcune operazioni
codice fiscale matricola
nome
cognome ecc
...

RICERCA -
>
O(m)
·

ORDINARE--O(nlogen)
.....
-
·

MASSIMO E MIN -O(n)

:
·

PREDECESSORE SUCCESSIVO -- O(n)

:
INDICE ANALITICO
creare un
degli
>
-

come si crea un indice analitico elementi della tabella

↓
ALBERI BINARI DI RICERCA
mai usata in questa
forma perché e
ELEMENTARE perché utilizza una

Strategia DICOTOMICA
↓

suddividere l'insieme
necessariamente in cul cerco il dato
non
completo

>
-

UNICA REGOLA

S(v) = w =
D()

es : 50 20, 40 60 90
, , , ,

10 48 45 85 , 70, 65
, , , .
50

80 30 , ,
12 5 35 , ,

20 60

10 40 go

51230 85
48
operazioni
70
3545
inserimento
O()
·

65 80

loghan
·
ordinamento (utilizzando DFS) 0(n m)
↓
+

è un albero quindi i
=> ((n + n -

1) =
0(n)
numero di
spigoli è n-1

dobbiamo utilizzare una struttura

>
-

NO HEAP perché l'albero non è completo

Nuova Struttura
PADRE
struct nodobin
?
INFO
structnodobin
SXDX
*
padre ,
* SX ,
& dX ;

int info ;

Y i
·
INSERIMENTO

imsert(T V) ,

padre
X =
root (T) , Y NULL
=

radice

fintanto che X NULL ripeti

X ;
Y =

Se info(x) v allora :

(h
X= Sx(x) :
·

altrimenti
logenzhen
:

X =
dx(x) ;
fine-condizione ;

fine-ciclo

P(v) =

Y
se Y =
NULL allora :

root(T) =
V,

altrimenti :

Se info(y) >V allora :

Sx(y) =
vi
S(1)

altrimenti :

dx(y) =
Vi

fine-condizione
fine-condizione

fine

·
RICERCA
~ rediceol
Search (X , v)
L,vertice che
cerco

fintanto che X * NULL e info(x) # V;

Se info(x) v allora :

x =
Sx(x) ;
altrimenti
(n)
:

&
X =
d(x) ;
fine-condizione

fine-ciclo

restituisci X,

fine
.
MINIMO ·

MASSIMO
radice
min(x) max(x)
fintanto che SX(x) NULL :
fintanto che dx(x) NULL :

X =
SX(x) ; X =
dx(x) ;
fine-ciclo
; & (n) fine-ciclo
;

restituisciX ; restituisciX ;

fine fine

SUCCESSORE
·

PREDECESSORE

successore(x) predecessore (X)

se dx(x) * NULL :

y mim (0x(X)) ;
= -
>
figlio de più piccolo

altrimenti :

& (n)
y
=
p(x) ;

fintanto che YeNULLEX dx(y) = :

X=
Y;

y =
p(x) ;
fine-ciclo ;

fine-condizione ;

restituisci y :
fine

ORDINAMENTO (n forma ricorsiva

radice
sort(x)
Se X * NULL allora :

SORT (sX(x)) :

SCrIVI X ,

SORT(0x(x) ;
fine-condizione ;
fine
 19 dic

COMPLESSITA COMPLESSITA
DI > DI
ALGORITMI PROBLEMI
ci sono problemi più difficili ?
>
-

scartiamo i problemi NON CALCOLABILI

ci occupiamo del problemi" CALCOLABILI" -

COMPL COMPUT
.

devo dim che non e · esistenza decisione

possibile overe una V

> la
e
compcompe cui
risposta è si/ no
.

5(f(n)) =

(g(n) :
7 noso , o >
-

ricerca

t . c .

<(f(n) =

g(n)fn
> no
3 una soluzione

>
-
enumerazione

f(n) le soluzioni possibili

=
n
+
v & tutte
funzione
Obiettivor

problemeil >
- ottimizzazione
criterio
f(n) = k
X
· subset
sum
· sort
soluzione
migliore secondo un

&
!
non

f(n)
sappiamo I
= m se esiste
. conn
.

->
2 S
algoritmo
problemi risolvibili
un

polinomiale
=
·
NP
in
tempo polinomiale
problemi l hanno card
questi insiemi o

CLIQUE SO
i3 MASSIMALE
>
-

di
su G

dimensione K ?
una clique
CLIQUE

· didim4
NON ESISTE
- - UN ALGORITMO
Subsetsum- sottansiemi >
POLINOMIALE
DER RISOLVERLO
-
> CLIQUE

· -
di dim 3
·
ALGORITMO RISOLUTORE
POLIN

> ALGORITMO DI VERIFICA

NON POLIN

PROBLEMI PER I QUALI ESISTE ALGORITMO DI VERIFICA POLINOMIALE =

NIP
problemi verificabili
in tempo polinomiale
es Sort
problema
=

grande
.

=>
siamo sicuri che P =
NP ? >
-
più
dell'informatica teorica
↓

libro con tutti i problemi

computers and
intrattability
RIDUCIBILITÀ TRA PROBLEMI
* B vedi def 11 20
:
fino 11 30:

Ps se B è in tempo polinomiale
>
-
NON È Detto Che E
PIU SEMPLICE

NP-COMPLET (NP-C)
# E NP-C SE

1 .
A ENP

.
2 V BENP BEpA

or -
P

ma siamo sicuri che sia concreto ?

perché NP è infinito

>
-

fine '70 è stato dim che la classe NPC non è vrota

TEOREMA DI COOK

SAT ENP-C
satisfability

(IAEB)GAECCENOND) . . . . . . . . .

)
COPIA 11 38
:
 COPIA -
> 10 : 21

int man (void) ?

struct nodo * VE00] ;
intn i

n =
random Graph (V) ;
Stampa Grafo (V n) ; ,

return (0) ;

3
non orientato
int random Graph /struct nodo
VIS/2 ↑
Float X
:

int n; for (i =
0 ; in -
1: i + +
)
intn i , for(j =
i 1 ; j( j + +)
j ;
+

, ,

Srand (NULL))
(lunsigned timeprobabilità ; rand() % 100 =100 +
X)
>

Scanf ("Yf" & X) ; element

addedge(V ,
i ,
j) ;
~ numero

Scanf(" %od" ,
& n) ; addedge (V J i) ; , ,

for (i =
0 ; icn : i + +
V[i] =
NULL ;

for (i = 0 ; i < n ; i + + )
for(j =
0 ; j( ; j + +)
>
-

è ORIENTATO
aggiunge un If (i ! j =
&d rand (1 % 100 7100 +
X)
vertice alla lista
di adiacenza

E uno -addEdge (V
spigolo tradue)
vertici del grafo
,
i
j)
,
;

return (n)
I 10 36 :

Vod
addedge /struct nodo VI] ,
inti ,
intjl[
struct nodo p;

p
=
malloc (sizeof (structnodd) ;
Pt Info J ; è prientato
=

>
-

p
- > mext =
V[i]
vedi 10 45 !!
:

V[i] p ; =

return ;
3
 lista di vertic stampare Gel verificare e
Datoungrafo e
una se
,

e
·

#
#include time h >

.
.
·

-
4

&
struct
nodd
intinfo ;
&

-
-
· -
-

struct nodo anext ;

I i

int main (void) 2

struct nodo *
V100] ,
L;

intn ; ~ oppure-n =

leggiGrafo)
n =
randomGraph (V) ;
=
while (c
leggilista))
!
Nulla&
=
;

-> next !- Nul &d

adiacente (V ,
Le info
,
Le next-> info)
L Lt next ;
=

If /-> next ==
NULL)
printf ("Si"),
else

Printf ("no") ;
return (0)
3
:

int adiacente) struct nodo eVI] inti , , intj) <

struct nodo *
D;
intr =
0;

P =
V[i] ;
While (p ! =
NULL da p - info =
j)
P p
= - next ;

#f
(p !=
Nux)
r = 1
;

return (r) :
 SorT
·

Selection sort (A , n) ·
insertion sort (A n) ,

per i = o -an-1 ripeti per i =

1 -
> n-1 ripeti
per i 1 1 ripeti k i 1;
j n
=
+ + - = -

se Ai > Au allora :
fintanto che K=0 e AkAnt1 ripeti :

scambia Ai e Ak Scambia Ak e Ak + 1 ;

fine-cond k =
k -
1;

fine-ciclo fine-ciclo
fine-ciclo fine-ciclo

fine fine

·
bubble sort (A n) ,
·

quick sort (A ,
pre fine

flag
=
0; pivot= fina Pivot(A p r) ; , ,

k =
n -

1; se pivot Null e pLV = allora :

ripeti 9 partiziona (A p r);

=

, ,

per 1 =
o -
> K ripeti :

quicksort (A p q-1); , .

Se Ai > Ai + 1 allora :
quicksort (A , p , g) ;

scambia A , eAi + 1; fine-cond

fleg =
1, fine

fine-cond
fine-ciclo
k =
k -
1; partiziona
I
(A pr , , pivot)
finanto che 1 fintanto che per ripeti
flag
=

fine fintanto che Arz pivot :

r =
r -
1 ;

find pivot (A , p , r fine-ciclo

per i =
p+ 1 - r fintanto che Ap-pivot :

se Ai-Ap allora :
P p+1
=

restituisci Ai , fine-ciclo

altrimenti : fine-ciclo
restituisci Ap; se par allora :

fine cond scambio per

fine ciclo fine-condizione
restituisci NULL ; restituiscie
fine fin
·

merge
sort (A, p , r) .

neap sort (A , n)
se pir allora :
Ho =
P

q =

Pr per i =
0 -
> n-1 ripeti :

mergesort (A p 9) , , ,
inserisci (H Ai) ; ,

sort (A r
q + 1); fine-ciclo
merge , ,

merge (A p p r) : , , ,
per 1 =
1-1-30 ripeti
fine-cono A .
=
estral (H)
fine fine-cido
fine
merge (A p a)
r
, , ,

k 0 i p 1
j q
= = =
+
, ,

fintanto che izq e

jer ripeti :
estrei(H)
se Ai Aj allora : MAX = H1 ;

Bk =
Ai ,
i = i + 1
,
k =
k + 1; L Ho =
;

altrimenti :
Ho =
Ho-1;

Bx =

Aj ,
j j+
= 1 ,
k =
k + 1; H1 =
H2 ;
fine-cond i =
1;

fine-ciclo fintanto che 2ice

(HiHeio HicHzita) ripeti
fintanto che ip ripeti
BK = Ai ,
i = i + 1 ,
k = k + 1; Se Hai >
Hai + 1 allora :

fine-ciclo scambie Hi ettzi ;

fintanto che
jer ripeti i 2i ,
=

Bk =
Aj j j ,
= + 1 ,
k = k + 1; altrimenti :

fine-ciclo Scambie Hi etzi +1

fine i =
2i + 1;

inserisci (H x) ,
fine-condizione
L Ho 1
=
+
,
Ho 2 =

,
Ha =
X; fine-ciclo
fintanto che -1 e Ha Hua ripeti :
se i =
22 e Hi Hei allora :

scambia Ha e Hae ; scambia Hi e Hei ,

2 =
4/2 w =
2/2
fine-cido fine-condizione
fine restituisci MAX

fine
 VISITA DI UN GRAFO
in amplezza
·

>
-

si allontana il meno possibile dalla sorgente

permette di trovare il più breve per raggiungere
>
-

ci cammino v

BFS(G S) -
>
breath fast search

Y
,

per seVIG) ripati

ogni
:

c) =
bianco ;

↑ (2) =
NULL ; On numerose
(v) d) = 0
;

fine-ciclo
d (s) 0 c(s) grigio, accoda (a 5)
= =
, ,

fintento che Q &

ripeti +

I
U =
estralla)
per ogni
s adiacente a u ripeti :

se c(e)-bianco allora :

N(w)
C(u) =

=
grigio
4
, accoda (a w)
,
5(m numero

a (w) =
p()+ 1 spiga ,

fine-condizione
fine-ciclo
c(u) =
nero;

fine-ciclo
=>
ha compl comp .
8 =
n +m

in profondità
allontana il più possibile dalla
sorgente
>
si
-

>
-

c permette di costruire uno

spanning
tree

DFS(G) -
>
depth first search
se v(G) ripeti

I
per ogni
c (v) bianco
=
,
in (w) =
NULL ,
(n)
fine-ciclo
per we V (G) ripeti
ogni
:

se

fine-ciclo
e(a) =
bianco ,
allora visita (G ,

2) ) 0(n)
fine
visite (G ,
v)

3
C(r) grigio=

ve N(2) ripeti
per ogni
:

se clu) =
bianco allora :

# (4) = 2; G (m)
visite (G u) ;
,

fine-condizione

fine-ciclo

c(u) =
nero ;

fine
=>
ha compl comp .
8 =
n +m

DIJKSTRA
>
-

calcola il cammino con costo minimo da

sorgente singola
- Si basa sul principio del Rilassamento

> (u v)cE(G)
,

DIJKSTRA(G W , ,
S] w(p) w(2 v) W(0 v)
+
, ,

ogni we V(G) ripeti

.
per :

w(2 v)
D(0) in (w) NULL;
=
00
,
=
,

fine-ciclo y
y w(0 V),
V

& =
V(G) - EFeeV(6) accoda sina);
D(S) =
0
;

fintanto che + 0
ripeti :

= estrai(Q a) ,
con el minima

s adiacente
vertice ripeti
per ogni a u

se D(w) > D (u) + Wir w) allora

+ :

() (0) =
D (0) +
w(u 2) +
;

(2) = U

fine-condizione
fine-cido
fine-ciclo

fine