Che materia stai cercando?

Informatica - Polimi - Prof. Campi Appunti scolastici Premium

Lista dei comandi e definizioni dei concetti incontrati nel corso di Informatica riguardanti il linguaggio C ed SQL e in particolare i comandi base, array, stringhe, matrici, struct, puntatori, funzioni, ricorsione, file, memoria dinamica, liste ed alberi. Riassunto basato su appunti personali presi alle lezioni del professore Campi dell'università degli Studi del Politecnico di Milano - Polimi. Vedi di più

Esame di Informatica docente Prof. A. Campi

Anteprima

ESTRATTO DOCUMENTO

typedef struct Nd {

int dato;

struct Nd * next;

} Nodo;

typedef Nodo * ptrNodo;

Creazione di un nodo ptrNodo ptr;

ptr = malloc(sizeof(Nodo));

ptr->dato = 10;

ptr->next = NULL;

ptrNodo Lista;

ptrNodo ptr;

Lista = malloc(sizeof(Nodo));

Lista->dato = 10;

ptr = malloc(sizeof(Nodo));

ptr->dato = 20;

Lista->next = ptr

Creazione lista di due nodi ptr->next = NULL;

ptrNodo Lista;

Lista = malloc(sizeof(Nodo));

Lista->dato = 10;

Lista->next = malloc(sizeof(Nodo);

Lista->next->dato = 20;

Lista->next->next = NULL;

ptrNodo ptr;

ptrNodo prec_ptr;

Cancellare un nodo ... /* qui si inizializzano ptr e prec_ptr … */

prec_ptr->next = ptr->next;

free (ptr);

int d;

ptrNodo Lista;

ptrNodo ptr;

ptr = Lista;

while( ptr != NULL && ptr->dato != d )

Cercare un nodo nella lista. ptr = ptr->next;

All’uscita ptr vale NULL o punta al dato cercato int d;

ptrNodo Lista, ptr;

for( ptr=Lista; ptr!=NULL && ptr->dato!=d;

ptr=ptr->next )

int numeronodi = 0;

ptrNodo Lista, ptr;

Lista = ... /* costruzione della lista */

for( ptr=Lista; ptr!=NULL; ptr=ptr->next )

numeronodi++;

Lunghezza lista int Dimensione(ListaDiElem lista) {

int count = 0;

while( lista!=NULL) {

lista = lista–>prox;

count++; }

return count; }

int DimensioneRic(ListaDiElem lista) {

if ( ListaVuota(lista) ) return 0;

return 1 + DimensioneRic( lista–>prox );}

ptrNodp prec_ptr;

ptrNodo ptr;

... /* qui prec_ptr è inizializzato (trovare il

Inserire un nodo all’interno della lista nodo) */

ptr = malloc (sizeof (Nodo));

ptr->next = prec_ptr->next;

prec_ptr->next = ptr;

Controllo lista vuota if (lista==NULL)

int VerificaPresenza (ListaDiElem lista,

TipoElemento elem) {

ListaDiElem cursore;

if ( ! ListaVuota(lista) ) {

cursore = lista

while( ! ListaVuota(cursore) ) {

if ( cursore–>info == elem )

return 1;

cursore = cursore–>prox;}}

Controllo presenza di un elemento return 0; }

int VerificaPresenza(ListaDiElem lista,

TipoElemento elem) {

if( ListaVuota( lista ) )

return 0;

if( lista–>info == elem )

return 1;

return VerificaPresenza( lista–>prox,

elem ); }

ListaDiElem InsInTesta

(ListaDiElem lista, TipoElemento elem) {

ListaDiElem punt;

punt = (ListaDiElem)

malloc(sizeof(ElemLista));

Inserimento nodo in prima posizione punt–>info = elem;

punt–>prox = lista;

return punt;}

Chiamata: lista1 = InsInTesta( lista1,

elemento );

ListaDiElem InsInFondo( ListaDiElem lista,

TipoElemento elem ) {

ListaDiElem punt, cur = lista;

punt = (ListaDiElem) malloc(

sizeof(ElemLista) );

punt–>prox = NULL;

punt–>info = elem

Inserimento nodo in ultima posizione if ( lista==NULL )

return punt

else {

while(cur–>prox!=NULL) cur=cur–>prox;

cur –>prox = punt; }

return lista;}

Chiamata : lista1 = InsInCoda( lista1,

elemento );

ListaDiElem InsInFondo(ListaDiElem

lista, TipoElemento elem )

{ ListaDiElem punt;

if( lista==NULL ) {

punt = malloc( sizeof(ElemLista) );

punt–>prox = NULL;

punt–>info = elem;

return punt; }

else { lista–>prox = InsInFondo( lista–

>prox, elem );

return lista; }}

Chiamata : lista1 = InsInFondo( lista1,

Elemento );

ListaDiElem InsInOrd( ListaDiElem lista,

TipoElemento elem ) {

ListaDiElem punt, puntCor = lista,

puntPrec = NULL;

while ( puntCor != NULL && elem >

puntCor–>info ) {

puntPrec = puntCor;

puntCor = puntCor->prox;}

punt = (ListaDiElem)

malloc(sizeof(ElemLista));

Inserimento in lista ordinata punt–>info = elem;

punt–>prox = puntCor;

if ( puntPrec != NULL )

puntPrec–>prox = punt;

return lista;

} else

return punt;}

Chiamata : lista1 = InsInOrd( lista1,

elemento );

ListaDiElem Cancella( ListaDiElem lista,

TipoElemento elem ) {

ListaDiElem puntTemp;

if( lista!=NULL)

if( lista–>info == elem ) {

puntTemp = lista–>prox;

free( lista );

Cancellazione di un elemento return puntTemp; }

else

lista–>prox=Cancella(lista–>prox, elem);

return lista; }

Chiamata : lista1 = Cancella( lista1,

elemento );

ListaDiElem Cancella( ListaDiElem lista,

TipoElemento elem ) {

ListaDiElem puntTemp;

if( lista!=NULL)

if( lista–>info == elem ) {

puntTemp = lista–>prox;

free( lista );

Elimina tutte le occorrenze di un elemento return Cancella(PuntTemp, Elem); }

else

lista–>prox=Cancella(lista–>prox, elem);

return lista; }

Chiamata : lista1 = Cancella( lista1,

elemento );

void DistruggiLista( ListaDiElem lista ) {

ListaDiElem temp;

while( lista != NULL ) {

temp = lista–>prox;

free( lista );

Deallocare completamente la lista lista = temp; } }

void DistruggiListaRic( ListaDiElem lista ) {

if ( lista!=NULL ) {

DistruggiListaRic( lista–>prox );

free( lista );} }

void VisualizzaLista( ListaDiElem lista ) {

if ( lista==NULL )

printf(" ---| \n");

Visualizzare la lista else {

printf(" %d\n ---> ", lista–>info);

VisualizzaLista( lista–>prox ); }}

void VisualizzaListaRovesciata

( ListaDiElem lista ) {

if ( lista==NULL )

Visualizzare lista al contrario printf(" |--- \n");

else {

VisualizzaListaRovesciata( lista–>prox );

printf(" %d\n <-- ", lista–>info); }}

ListaDiElem Reverse1( ListaDiElem lista, int

keepSource ) {

ListaDiElem temp = Inizializza(),

curr = lista;

while( curr!=NULL )

temp = InsInTesta( temp, curr–>info );

curr = curr–>prox;}

Rovesciare una lista if( ! keepSource )

DistruggiLista( lista );

return temp;}

Chiamate: ListaDiElem s1, s2, s3;

s1 = Reverse1( s1, 0 );

s2 = Reverse1( s3, 1 );

ListaDiElem Reverse2( ListaDiElem lista ) {

ListaDiElem temp, prec = NULL;

if( lista!=NULL ) {

while( lista–>prox != NULL ) {

temp = prec;

prec = lista;

lista = lista–>prox;

prec–>prox = temp;}

lista–>prox = prec;}

return lista;}

ListaDiElem ReverseRic( ListaDiElem lista ) {

ListaDiElem p, ris;

if ( lista==NULL || lista–>prox==NULL )

return lista;

else {

p = lista–>prox;

ris = ReverseRic( p );

p–>prox = lista;

lista–>prox = NULL;

return ris; }}0

int Ricorrenze(ListadiElem lista,

tipo elem) {

ListadiElem punt;

int cont=0;

Contare ricorrenze punt=lista;

while (punt!=NULL) {

if (punt->dato==elem) cont++;

punt=punt->next; }

return cont;}

typedef struct Nodo {

Tipo dato;

Lista concatenata struct Nodo *next;

} nodo;

typedef nodo * lista;

È una struttura dati dinamica in cui i nodi sono connessi tramite rami ad altri nodi in modo

che c’è un nodo di partenza (la radice); ogni nodo (tranne la radice) è collegato ad uno e

un solo nodo padre; ogni nodo è collegato al massimo a due altri nodi, detti figli; i nodi

che non hanno figli sono foglie.

Un albero è un nodo da cui spuntano due alberi.

typedef struct Nodo {

Tipo dato;

struct Nodo *left;

Struttura ricorsiva struct Nodo *right;

Alberi } nodo;

typedef nodo * tree;

int contaNodi ( tree t ) {

if ( t == NULL )

return 0;

Conteggio nodi else

return (contaNodi(t->left) +

contaNodi(t->right) + 1); }

int depth ( tree t ) {

int D, S;

if (t == NULL)

return 0;

S = depth( t->left );

D = depth( t->right );

if ( S > D )

return S + 1;

else

return D + 1;}

int max(int a,int b) {

if(a>b)

return a;

else

return b;}

Calcolo profondità int depth ( tree t ) {

if (t == NULL)

return 0;

return max (depth( t->left ),

depth( t->right ))+1;}

int depth ( tree t, int currentDepth) {

int D, S;

if ( t == NULL )

return currentDepth;

else {

S = depth( t->left, currentDepth+1 );

D = depth( t->right, currentDepth+1 );

if ( S > D )

return S;

else

return D;}

tree trova ( tree t, Tipo d) {

tree temp;

if ( t == NULL)

return NULL

if ( t->dato == d )

return t;

temp = trova( t->left, d );

if ( temp == NULL )

return trova( t->right, d );

else

Ricerca di un elemento. return temp; }

Restituisce NULL se non trova nell’albero t il

dato d, altrimenti restituisce il puntatore tree trova ( tree t, Tipo d) {

al primo nodo che lo contiene tree temp,temp2;

if ( t == NULL) return NULL

if ( t->dato == d ) return t;

temp = trova( t->left, d );

temp2 = trova( t->right, d );

if(temp2!=NULL)

retutn temp2;

else

return temp; }

tree trova ( tree t, Tipo d) {

tree temp;

if ( t == NULL)

return NULL

if ( t->dato == d )

Ricerca di un elemento in un albero ordinato return t;

if(t->dato > d)

return trova( t->left, d );

else

return trova( t->right, d ); }

int leaves ( tree t ) {

if ( t == NULL )

return 0;

Numero nodi foglia if ( t->left == NULL && t->right == NULL);

return 1;

return leaves( t->right )

+ leaves(t->left); }

int branches ( tree t ) {

if ( t == NULL ||

( t->left == NULL && t->right == NULL) )

return 0;

return 1 + branches( t->right ) +

Numero di nodi non foglia branches(t->left);}

int branches2 ( tree t ) {

return contaNodi( t ) – leaves( t );

}

int oddCount ( tree t, int level ) {

int n;

if ( t == NULL )

return 0;

n = oddCount( t->left, level+1 ) +

oddCount( t->right, level+1 );

Numero di nodi su livelli dispari if ( level%2 == 1 )

n++;

return n;}

chiamata: tree t = costruisciAlbero( … );

int x = oddCount( t, 0 );

Nodi= contaNodi – oddCount;

int evenCount ( tree t, int level ) {

int n;

if ( t == NULL )

return 0;

n = evenCount( t->left, level+1 ) +

Numero di nodi su livelli pari evenCount( t->right, level+1 );

if ( level%2 == 0 )

n++;

return n;}

chiamata: tree t = costruisciAlbero( … );

int x = evenCount( t, 0 );


PAGINE

16

PESO

704.63 KB

AUTORE

saratita

PUBBLICATO

4 mesi fa


DESCRIZIONE APPUNTO

Lista dei comandi e definizioni dei concetti incontrati nel corso di Informatica riguardanti il linguaggio C ed SQL e in particolare i comandi base, array, stringhe, matrici, struct, puntatori, funzioni, ricorsione, file, memoria dinamica, liste ed alberi. Riassunto basato su appunti personali presi alle lezioni del professore Campi dell'università degli Studi del Politecnico di Milano - Polimi.


DETTAGLI
Esame: Informatica
Corso di laurea: Corso di laurea in ingegneria matematica
SSD:
A.A.: 2018-2019

I contenuti di questa pagina costituiscono rielaborazioni personali del Publisher saratita di informazioni apprese con la frequenza delle lezioni di Informatica e studio autonomo di eventuali libri di riferimento in preparazione dell'esame finale o della tesi. Non devono intendersi come materiale ufficiale dell'università Politecnico di Milano - Polimi o del prof Campi Alessandro.

Acquista con carta o conto PayPal

Scarica il file tutte le volte che vuoi

Paga con un conto PayPal per usufruire della garanzia Soddisfatto o rimborsato

Recensioni
Ti è piaciuto questo appunto? Valutalo!

Altri appunti di Informatica

Appunti di "Informatica A"
Appunto
Raccolta Dimostrazioni di algebra Lineare e geometria analitica
Appunto
Elementi di Analisi Complessa
Appunto
Analisi matematica 1 - Appunti
Appunto