RicBin: log2n Sel.Sort: T=(n2) S=(1) s.p.

(n2+n)/2 1_1/2 Ins.Sort: TM/W=(n2) TB=(1)

S=(1) s.p. st. M.Sort: T=(nlogn) S= (n) st.
Q.Sort: TM/B=(nlogn) TW=(n2)[s.sort]
S=(logn) SW=(n) s.p. Q.S.triP: TB=(n)
SB=(1) H.Sort: T=(nlogn) S=(1) s.p.
Introspect.sort: quickS.+heapS. Counting S.:
T=(n+k) S=(n+k) st. BucketS.: con code
RadixS.: T=((b/r)(n+2r)) b=bits tot. r=b.x seq.
Liste di trabocco: O(n) fatt. di carico:
=n(key)/m(liste) se <1 T=O(1) Indirizz.
Aperto: =O(1). scans.lineare cluster prim.,
quadratica clust.sec. scan(i,k)=(hash(k)+ai2+bi)
% m, hashing doppio. T(n,m)1/(1- )
Quickfind: Union=(n)=2Find=(n) U.bySize/
Rank:F=(logn)+path compres. Tam(m,n)=O(1)
|16
Grafo semplice: m=n(n-1) [/2 n.orient.]
G.denso: m=(n2) G.sparso: m=(n)
Camm.Semplice: nodi Camm.Euleriano:
percorre 1xarchi Hamilton: 1xnodi Compon.
connessa: sottograph G conness. Massimale
Connesso: m>n-1
Albero libero: graph non or. conness. aciclico
Alb.Copertura: G , nG. Matrice (n2),
Lista adiacenza (m+n)/incidenza(m uscenti)
Camm.minimo: SSE no cicli costo negativo
Min.Alb.Ricopr.: alb.ricop. con pesi min.
A.Dijkstra: list.o. O(n+n+m*n) list.no.
O(n+n2+m) Johnson O(n+nlogn+mlogn)
A.Bellman-Ford: T(n,m)= O(nm)
Visite: (n+m) A.Prim: T(m,n)=O(mlogn)
A.Kruskal: T=O(mlogn) A.Topo: T=O(n+m)
private void moveUp(int i){
if(i > lastIndex || i < 1) throw new
IllegalArgumentException();
ElemWithPrior elem = heap[i];
while(i > 1 && elem.prior < heap[i/2].prior){
heap[i] = heap[i/2];
i = i/2;
} heap[i] = elem; }
private void moveDown(int i){
if(i > lastIndex || i < 1) throw new
IllegalArgumentException();
ElemWithPrior elem = heap[i]; int j;
while( (j=2*i) <= lastIndex){
if(j+1 <= lastIndex && heap[j].prior >
heap[j+1].prior) j++;
if(elem.prior <= heap[j].prior) break;
heap[i] = heap[j]; i = j;
} heap[i] = elem; }
|
static void countingSort(Item[] a, int k){
Item[]c=new Item[k], b=new Item[a.length];
for(Item it: a) c[it.key()]++;
for(int tot=0, j=0; j<k; j++{
int temp = c[j];
c[j] = tot; tot += temp;}
for(Item it: a) b[c[it.key()]++] = it;
for(int i=0; i<b.length; i++) a[i] = b[i]; }
static Node remove(int key, Node n){ BST
if(n == null) return null;
int nodeKey = n.element.key();
if(key<nodeKey) n.left = remove(key, n.left);
else if(key>nodeKey) n.right = n.right);
else{ if(n.left == null) n=n.right;
else if(n.right == null) n=n.left;
else{ n.elem=min(n.right);
n.right=deleteMin(n.right); } } return n; }

void heapify(){
for(int j=lastIndex/2; j>0; j--) moveDown(j);
T(n)= 2T(n/2)+logn = (n)
static void heapsort(int[] a){
int n = a.length;
for(int j=(n-2)/2; j0; j--)
moveDown(a, j, n); /a max/
for(int i=n-1; i>0; i--){
swap(a, 0, i); moveDown(a, 0, i); } }
private HashMap<Object, Integer> position;
position = new HashMap<Object, Integer>;
position.get(Object o);
position.put(Object o, Integer key);
.
Double.POSITIVE_INFINITY;
.
.
|
void breadthF(Graph G){
for each(Nodo u: G){ padre[u]= -1;
visitato[u]=false; /dist[u]= ;
/ padre[u]=u; dist[s]=0;
x} Q = codaVuota(); /priority
for each(Nodo u: G) /q.add(u, dist[u])
x if(not visitato[u]) breadthF(G, u);}
x void breadthF(Graph G, Nodo s){ /
x visitato[s]=true; accoda s in Q; /
x while(Q non vuota){
x Nodo u= Q.getFirst();
for each(Nodo v adj a u)
if(not visitato[v]){ /dist[u]+cuv<dist[v]){
padre[v] = u;
visitato[v]=true; /dist[v]=dist[u]+c uv;
x
Q.add(v); /decreasePriority(v, dist[v],Q);
}}}}
Prob. Comput.trattabile: se E un algo. efficie.
che lo risolve
Efficiente: se il suo T desecuzione limitato
superiormente da una funzione polinomiale
Algo Ottimo: se la sua compless. coincide con il
limite inferiore della compl. del problema. Se
lim. sup. e inf. coincidono: Alg.mic. chiuso
.
.
.
.
.
|
Code prior.: [Ins Estr 1] lis o/no, arr o/no, heap
Albero d-ario: foglie=dh nodi=(dh+1-1)/(d-1)
Dizionario: liste o/no, array o/no, albero avl
(bst 1-bil.) [Ricer Insert Cancel]
(SSa(T1cT2))bD DD>((_SSaT1_)cT2)bD
-SS>(SSaT1)c(T2bD) rotaz. SD
Master: T(1)=1 T(n)= aT(n/b) + c*n^s
a<b^s=>T=(n^s) a>b^s=>T=(n^logb_a)
a=b^s=> T(n) = (n^s logb_n)
.

void Kruskal(Graph G){

ordina gli archi in una seq. S a pesi cresc.;
A = insieme (vuoto) di archi;
crea UnionFind con nodi G come singoletti
int i=0, counter=0;
while(counter < n-1){
arco(u,v)=i-esimo arco di S;
if(union(u,v)){ [union speciale]
aggiungi(u,v) ad A; counter++; } i++; } }
|
void depthF(Graph G){
for each(Nodo v di G){ padre[v]=-1; x
visitato[v]=false;}x S=seq di Nodi vuota x
for each(Nodo v di G)
If(not visitato[v]) depthF(G, v);}
void depthF(Graph G, Nodo u){
visitato[u]=true; for each(Nodo v adj u)
if(not visitato[v]){ padre[v]=u; x
depthF(G,v); }
x aggiungi u in cima a S x}
.