TURNURILE DIN HANOI

Implementarea recursiva:(DIVIDE ET IMPERA)

Problema elementara: daca avem un singur disc pe tija a, acesta se muta pe tija c.

pentru n discuri procedam astfel:

-mutam n-1 discuri de pe tija a pe tija b folosind tija intermediara c
-mutam 1 disc de pe a pe c
-mutam n-1 discuri de pe tija b pe tija c folosind tija intermediara a

Numarul de discuri Numarul de mutari

1 1

2 3

3 7

4 15

5 31

n
2 -1
n

64
18 446 744 073 709 551 615
ULLONG_MAX

18 446 744 073 709 551 615

Optsprezece trilioane patru sute patruzeci și șase de biliarde șapte
sute patruzeci și patru de bilioane șaptezeci și trei de miliarde șapte
sute nouă milioane cinci sute cincizeci și una de mii șase sute
cincisprezece

Tower of Hanoi | Math Playground

QUICKSORT

#include<iostream>

#define Max 100001

using namespace std;

void citire(int v[], int &n)

int i;

cin>>n;

for(i=1;i<=n;i++)

cin>>v[i];

void afis(int v[], int n)

int i;

for(i=1;i<=n;i++)

cout<<v[i]<<" ";
}

int pozitie(int v[], int p, int q)

int aux, i, j;

aux=v[q];

i=p-1;

for(j=p;j<=q-1;j++)

if(v[j]<=aux)

i=i+1;

swap(v[i],v[j]);

swap(v[i+1],v[q]);

return i+1;

void Qsort(int v[], int p, int q)

if(p<q)

int m=pozitie(v, p,q);

Qsort(v, p,m-1);

Qsort(v, m+1,q);

int main()

int v[100001],n;
 citire(v,n);

Qsort(v, 1,n);

afis(v,n);

return 0;

MERGESORT

#include<iostream>
#define Max 100001
using namespace std;

int v[Max],n;
void citire()
{
int i;
cin>>n;
for(i=1;i<=n;i++)
cin>>v[i];
}
void interclasare(int p, int m, int u)
{
int c[Max],i,j,k;
i=p;
j=m+1;
k=0;
while(i<=m && j<=u)
{
if(v[i]<v[j])
c[++k]=v[i++];
else
c[++k]=v[j++];
}
while(i<=m)
 c[++k]=v[i++];
while(j<=u)
c[++k]=v[j++];
for(i=1;i<=k;i++)
v[p+i-1]=c[i];
}
void merge_s(int p,int u)
{
int m;
if(u>p)
{
m=(p+u)/2;
merge_s(p,m);
merge_s(m+1,u);
interclasare(p,m,u);
}
}
void afis()
{
int i;
for(i=1;i<=n;i++)
cout<<v[i]<<" ";
}
int main()
{
citire();
merge_s(1,n);
afis();
return 0;
}