CREACOPPIE(ADJ)
	GL <- NIL
	FOR I = 1 TO N
	    X <- ADJ[I]
	    WHILE X <> NIL
		  INLISTA(I,KEY[X],GL)
		  X <- NEXT[X]
	RETURN GL

INLISTA(A,B,L)
	X <- L
	TROVATO <- FALSE

	WHILE (X <> NIL) AND (NOT TROVATO)
	      IF SORGENTE[X] = B AND DESTINAZIONE[X] = A
	      THEN
		TROVATO = TRUE
	      X <- NEXT[X]

	IF (NOT TROVATO)
	THEN
		;;ALLOCO MEMORIA PER Y
		SORGENTE[Y] <- A
		DESTINAZIONE[Y] <- B
		NEXT[Y] <- L
		L <- Y

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

VERIFICA(ADJ,T)
	IF T=NIL 
	THEN 
	     RETURN TRUE
	ELSE
	     RETURN (CONTROLLA-NODO(T,ADJ) AND
		     VERIFICA(ADJ,SX[T]) AND
		     VERIFICA(ADJ,DX[T]))

		
CONTROLLO-NODO(T,ADJ)
	BOOLSX <- TRUE
	BOOLDX <- TRUE
	
	K <- KEY[T]

	IF (K < 1) OR (K > N) THEN
		RETURN FALSE

	IF ESISTE-SX(T) THEN
	   KSX <- KEY[SX[T]]
	   BOOLSX <- ESISTE-ARCO(K,KSX,ADJ)

	IF ESISTE-DX(T) THEN
	   KDX <- KEY[DX[T]]
	   BOOLDX <- ESISTE-ARCO(K,KDX,ADJ)

	RETURN BOOLSX AND BOOLDX


ESISTE-SX(T)
	RETURN (SX[T] <> NIL)

ESISTE-DX(T)
	RETURN (DX[T] <> NIL)

ESISTE-ARCO(X,Y,ADJ)
	CERCA(ADJ[X],Y)