Sei sulla pagina 1di 7

#include <iostream>

#include <algorithm>
#include <vector>
#include <cstdlib>
#include <string.h>

using namespace std;

struct Node {
int intero;
string stringa;
int distanza;
int figli;
Node *left, *right;
Node(int i, string n) : intero(i), stringa(n), distanza(0), figli(0), left(NULL),
right(NULL) { };
};

class BinTree {
Node *root;
void delTree(Node* &tree)
{
if(tree)
{
delTree(tree->left);
delTree(tree->right);
delete tree;
tree = NULL;
}
}

public:
BinTree() { root = NULL; }
~BinTree() { delTree(root); }
Node* getRoot() { return root; }
void insert(int i, string c)
{
Node *node = new Node(i, c);
Node *pre = NULL;
Node *post = root;
while(post != NULL)
{
pre = post;
if(i < post->intero)
post = post->left;
else
post = post->right;
}

if(pre == NULL)
root = node;
else if (i < pre->intero)
pre->left = node;
else
pre->right = node;
}
};

// Distanza dal nodo radice


void setDistanza(Node *t, int dist)
{
if(!t) return;

t->distanza = dist;

setDistanza(t->left, dist+1);
setDistanza(t->right, dist+1);
}

// numero di nodi discendenti (figli)


int setFigli(Node *t)
{
if(!t) return 0;

if(!t->left && !t->right)


{
t->figli = 0;
return 1;
}

int figli = setFigli(t->left) + setFigli(t->right);


t->figli = figli;
return figli+1;
}

// Altezza di un nodo
int altezza(Node *t)
{
if(!t) return 0;

int sx = altezza(t->left);
int dx = altezza(t->right);

return (sx > dx) sx+1 : dx+1;


}

// somma delle chiavi delle foglie


int foglie(Node *t)
{
if(!t) return 0;
if(!t->left && !t->right)
{
t->foglie = t->key;
return t->key;
}

int f = foglie(t->left) + foglie(t->right);


t->foglie = f;
return f;
}

// somma chiavi nodi interni (interni: tutti tranne le foglie, nodo t incluso)
int interni(Node *t)
{
if(!t) return 0;
if(!t->left && !t->right)
{
t->interni = 0;
return 0;
}
int i = interni(t->left) + interni(t->right) + t->key;
t->interni = i;
return i;
}

// max distanza tra nodo e foglie nel sottoalbero radicato nel nodo
int setLx(Node* t)
{
if(!t) return 0;
if(!t->left && !t->right)
{
t->lx = 0;
return 1;
}

int sx = setLx(t->left);
int dx = setLx(t->right);

int max;
if(sx > dx)
max = sx;
else
max = dx;

t->lx = max;
return max+1;
}

// visite dei nodi facendo un percorso verso la destinazione


// Incrementa di 1 il num di visite dei nodi di passaggio
int percorso(Node* t, int dest)
{
if(!t) return 0;
if(t->id == dest)
{
++t->visite;
return 1;
}

int r = percorso(t->left, dest) + percorso(t->right, dest);


if(r>0)
t->visite++;
}

Node * min()
{
Node * temp = root_;
while( temp->left != NULL )
temp = temp->left;
return temp;
}

Node * max()
{
Node * temp = root_;
while( temp->right != NULL )
temp = temp->right;
return temp;
}

//Ricerca dell'altezza del nodo di valore val


int search( Node * tree , int val )
{
if( tree == NULL )
return 0;

int cont = 0;
if( tree->value == val )
return 1;
else if( val <= tree->value )
cont = search( tree->left , val );
else
cont = search( tree->right , val );

if( cont != 0 )
return cont+1;
else
return 0;
}

//Contare i nodi di un albero


int nodes (Node* tree)
{
if(!tree) return 0;
return 1 + nodes(tree->left) + nodes(tree->right);
}

//Contare le foglie di un albero


int leaves (Node* tree)
{
if(!tree) return 0;
if( !tree->left && !tree->right) return 1;
return leaves(tree->left) + leaves(tree->right);
}

// vettore stringhe
vector<string> vec;

sort(vec.begin(), vec.end(), ordina);

bool ordina(string a, string b)


{
if(a.compare(b) < 0)
return true;
else
return false;
}

---------------------------------------------------------------------------------

// HASH
struct Node {
int info;
int indirizzo;
int altezza;
Node *left, *right;
Node(int i, int ind) : info(i), indirizzo(ind), altezza(0), left(NULL),
right(NULL) { }
};

void insert(Node *&root, int i, int s)


{
Node *node = new Node(i, s);
Node *pre = NULL;
Node *post = root;
while(post != NULL)
{
pre = post;
if(i <= post->info)
post = post->left;
else
post = post->right;
}

if(pre == NULL)
root = node;
else if (i <= pre->info)
pre->left = node;
else
pre->right = node;
}

int hashfun(int id, int s)


{
return ((((1000*id)+2000) % 999149) % s);
}

bool ordina(Node* a,Node *b); // Return true se a precede b

vector<Node*> hash;

for(int i=0; i<S; i++)


hash.push_back(NULL);

cout << hash[i]->indirizzo << endl;

for(int i=0; i<N; i++)


{
int id, h;
cin >> id;
h = hashfun(id, S);
insert(hash[h], id, h);
}

-------------------------------------------------------------------------

// HASH CON LISTE DI TRABOCCO


struct Node {
int id;
string cognome;
Node *next;
Node(int i, string s) : id(i), cognome(s), next(NULL) { }
};

void insert(vector<Node*> &root,int i, string s, int n)


{
int h = hashfun(i,n);
Node *node = new Node(i, s);
cout << h << endl;

if(root[h] == NULL)
{
root[h] = node;
}
else
{
Node* t = root[h];
while(t->next != NULL)
t = t->next;
t->next = node;
//cout << " <" << t->next->cognome << "> " << endl;
}
}

void stampa(vector<Node*> &root, int n)


{
for(int i=0; i<n; i++)
{
if(root[i] != 0)
{
Node *t = root[i];
cout << t->id << " " << t->cognome << " | " ;
while(t->next != 0)
{
cout << t->next->id << " " << t->next->cognome << " | " ;
t = t->next;
}
}
cout << endl;
}
}

// main
vector<Node*> hash;
for(int i=0; i<2*N; i++)
{
hash.push_back(NULL);
}

for(int i=0; i<N; i++)


{
int n;
string s;
cin >> n >> s;
insert(hash, n, s, N);
}

------------------------------------------------------------------
Visite:

In-Order:
visita(nodo)
{
visita(nodo->sinistra);
elaborazioni su nodo
visita(nodo->destra);
}
std::map < key_T , obj_t > table;
Tipo chiave Tipo dati
table['uno']="valore uno";
table.find('uno');