Analiza algoritmilor Tema 2

Problema 1: Consideram algoritmii InsertionSort, BubbleSort si MergeSort din Tema 1. Cerinte: alegeti unul dintre algoritmii InsertionSort si BubbleSort si aratati ca este partial corect. Aratati ca algoritmul MergeSort este partial corect. Pentru functia 'Merge' considerati varianta dezvoltata de voi in Tema 1 .
void BubbleSort(int *A,int n){ int aux; for (int i=0;i<n;i++){ for (int j=n-1;j>i;j--){ if (A[j] < A[j-1]){ aux = A[j]; A[j] = A[j-1]; A[j-1]= aux; } } } }

Demonstratie prin deductie directa I=Zn O=Zn Pi(A,n)= A vector cu n elemente Po(A,n)= A - vector sortat cu n elemente

Op 1. La fiecare ciclu din primul for (pentru i=k) se aduce pe pozitia A[k] cel mai mic element din subvectorul A[k:n-1] Dem: for (int j=n-1;j>k;j--){ Fie i=k.
if (A[j] < A[j-1]){ aux = A[j]; A[j] = A[j-1]; A[j-1]= aux; }

Pornind de la pozitia n-1, va compara fiecare element cu cel dinaintea lui si le va interschimba, daca acesta este mai mic. Asfel se va aduce in pozitia k elementul cel mai mic din subvectorul A[k :n-1] Op 2. Efectuand Op 1 pentru i=0 : n-1 va rezulta un vector ce are pe pozitia i cel mai mic din subvectorul A[i,n-1] A=[p0,p1,p2,p3,p4,p5.pn-1] cu proprietatea ca: pi=min(pi:n-1) pi pj , i<j p0 p1 pi pn-1 vectorul este sortat

BubbleSort este partial corect

void Merge(int *A,int p,int q,int r){ int *Aux,i=p,j=q+1,k=0; Aux=(int *) malloc((r-p+1)*sizeof(int)); while ((i<=q) && (j<=r)) { if (A[i]<A[j]) { Aux[k]=A[i]; k++;i++; } else { Aux[k]=A[j]; k++;j++; } } for (;i<=q;i++){ Aux[k]=A[i]; k++; } for (;j<=r;j++){ Aux[k]=A[j]; k++; } for (i=0;i<k;i++) { A[p+i]=Aux[i]; } }

void MergeSort(int *A,int p,int r){ int q; if (p < r) { q = (p + r) / 2; MergeSort(A,p,q); MergeSort(A,q+1,r); Merge(A,p,q,r); } }

Pas 1. Demonstram prin deductie directa ca algoritmul Merge este partial corect I=Zr-p+1 O=Zr-p+1 Pi(A,p,q,r)= A[p:q]=v1 subvector sortat crescator A[q+1:r]=v2 - subvector sortat crescator Po(A,p,q,r)= A[p,r] = Av- subvectorul sortat crescator

Algortimul foloseste un vector auxiliar Aux cu r-p+1 elemente. Se folosesc niste indici (i,j) care initial arata inceputul vectorilor v1,v2. Deoarece vectorii v1, v2 sunt sortati crescator, cele mai mici elemente din fiecare vector se afla pe primele pozitii. Intructiunea de ciclare while va introduce in vectorul Aux cel mai mic element, comparand pozitiile indicilor din cei doi vectori. Dupa fiecare intoducere se incrementeaza indicele vectorului din care s-a introdus. Operatia se repeata pana cand se termina unul din cei doi vectori. Urmatoarele operatii copiaza elementele care au ramas in vectorul Aux. Deoarece in vectorul Aux s-au introdus succesiv cele mai mici elemente vectorul Aux este sortat Ultima operatie copiaza vectorul Aux in vectorul A. A[p:r]=Aux de unde : A[p,r] subvector sortat crescator Pas 2. Demonstram prin inductie ca algoritmul MergeSort este partial corect I=Zr-p+1 O=Zr-p+1 Pi(A,p,r)= A[p:q] subvector nesortat Po(A,p,r)= A[p,r] - subvectorul sortat crescator

Caz de baza vector de 2 elemente: p+1=r q=(p+r)/2=p se apeleaz MergeSort(A,p,p) i MergeSort(q,q). ntruct primul indice nu este mai mic dect al doilea, cele 2 secvene rmn neschimbate n urma apelului funciei MergeSort. Se realizeaz apoi interclasarea celor 2 secvene Merge(A,p,p,q). Doarece am demonstrat ca Merge este partial corect vectorul rezultat este sortat crescator Pasul de inducie Fie un vector cu n elemente, A[p,p+n-1] Presupunem adevarat ca P1 : MergeSort(A,p,p+q) sorteaza subvectorul A[p,p+q] P2 : MergeSort(A,p+q+1,p+n-1) - sorteaza subvectorul A[p+q+1,p+n-1], Unde q = n / 2 Arat ca MergeSort(A, p,p+n-1) sorteaza vectorul A[p,p+n] MergeSort(p,p+n-1)=
MergeSort(A,p,p+q); - sorteaza subvectorul A[p,p+q] (ip ind) MergeSort(A,p+q+1,p+n-1); - sorteaza subvectorul A[p+q+1,p+n-1] (ip ind) Merge(A,p,p+q,p+n-1);

Merge va face interclasarea a celor doi subvectori sortati intr-un singur vector sortat A[p,p+n-1] sortat cresctor

MergeSort este partial corect

Problema 2 : "Fie S o secventa de numere intregi. Sa se determine suma maxima a subsecventelor de intregi continute in S (o subsecventa contine numere situate pe pozitii consecutive in S). Alegeti doi dintre cei trei algoritmi dezvoltati la Tema 1 pentru rezolvarea acestei probleme si aratati ca cei doi algoritmi sunt partial corecti.

Algorimul 1
int secvMax_1(int *v,int n){ /* lp - lowest point /* hr - highest rise /* sum - total sum */ int lp=0,hr=0,sum=0; for (int i=0;i<n;i++){ sum=sum+v[i]; if (sum<lp) lp=sum; else if ((sum-lp)>hr) hr=sum-lp; } return hr; }

Demonstram prin deductie directa ca algoritmul secvMax_1 este partial corect : I=Zn O=Z Pi(v,n)= A vector cu n elemente Po(v,n)= hr - suma maxima a subsecventelor

Algoritmul cauta cea mai mare suma a subsecvetelor lui S insumand elementele din S. Se retine in lp cel mai jos punct pe care l-a atins suma pana intr-un anumit moment. Astfel cresterea relativa a sumei totale a elementelor pana la un anumit punct este chiar diferenta dintre suma si lp. Cresterea relativa are semnificatia sumei subsecventei elementelor de unde s-a inregistrat cea mai mica suma, pana la elementul curent. Vom retine la fiecare pas cea mai mare crestere. In final hr va indica cresterea cea mai mare, si anume suma maxima a subsecventelor vectorului. Cum hr reprezinta suma maxima a subsecventelor secvMax_1 este partial corect

Algorimul 2
int secvMax_3(int *v,int n){ /* hr - highest rise /* s - variabila auxiliara pt sume */ int hr=0,s; for (int i=0;i<n;i++){ s=0; for(int j=i;j<n;j++) { s=s+v[j]; if (s>hr) hr=s; } } return hr; }

Demonstram prin deductie directa ca algoritmul secvMax_3 este partial corect : Algortimul pleca de la ideea ca subsecventa maxima poate incepe de la oricare element din S. Astfel se porneste pe rand de la fiecare element si se calculeaza suma maxima care se poate obtine insumand elementele pana la sfarsitul secventei S. Fie Op 1:
for(int j=i;j<n;j++) { s=s+v[j]; if (s>hr) hr=s; }

Pornind de la j=i, Op 1 face suma elementelor v[i:n] si retine in hr=suma maxima atinsa in aceasta subsecventa Prima bucla for executa Op 1 pentru i=0:n-1 se acopera astfel toate posibilitatile de localizare a subsecventei maxime. Astfel hr, va inregistra suma maxima a subsecventelor din v secvMax_3 este partial corect

Problema 3: Folosind tipul TList si algoritmii 'concat' si 'rev' prezentati la laborator, demonstrati prin inductie structurala ca: l1 TList, rev(rev(l1)) l1
concat(l1,l2) if (l1=nil) return l2 elseif l1=cons(x,l) return cons(x,concat(l,l2)) rev(l1) if l1=nil return nil elseif l1=cons(x,l) return concat(rev(l),cons(x,nil))

Demonstratie prin inductie structurala dupa l1 Caz de baza : l1=nil rev(rev(l1)) rev(rev(nil)) rev(nil) nil l1 Pas de inductie : Presupun ca P: rev(rev(l1)) l1 adevarat Arat ca rev(rev(cons( x, l1))) cons( x, l1)
(din algoritm ulrev)

rev(rev(co ns(x,l1 )))

rev(concat(rev(l1 ),cons(x,nil))) (rev(concat(l1,l 2 )) concat(rev(l 2 ),rev(l ))) 1 concat(rev(cons(x,nil)),rev(re 1 ))) v(l

(din ipoteza de inductie)

concat(concat(rev(nil),cons(x,nil)),l1 )
(din algoritm ulconcat)

concat(concat(nil,cons(x,nil)),l1 )
(din algoritm ulconcat)

concat(cons(x,nil),l ) 1 cons(x,concat(nil,l1 )) cons(x,l1 )

(din algoritm ulconcat)