Backtracking - descompunere suma - toate combinatiile

//Descompunere suma - toate combinatiile

# include <iostream.h>;
# include <conio.h>;

# define MAX 10

int sum,cont;
int sol[MAX];

void final(int n)
{
int i;
for(i=0;i<n;i++)
 cout<<sol[i]<<" ";
cout<<"\n";
cont++;
}

int verif(int j, int s)
{
if(j+s<=sum) return 1;
else return 0;
}

void back(int k, int s)
{
int j;

if(s==sum) final(k);
else
 for(j=1;j<sum;j++)
  if(verif(j,k))
   {
    sol[k]=j;
    back(k+1,s+j);
   }
}

void main(void)
{
clrscr();
cout<<"Intr suma: ";
 cin>>sum;

back(0,0);
cout<<"Nr. sol= "<<cont;
getche();
}
// Descompunere suma - combinatii distincte
// Descompunere suma - combinatii distincte si numere distincte
// Descompunere suma - combinatii cu nr prime (test)
// Descompunere suma - combinatii cu nr prime (test)

// Descompunerea unei table de sah in dreptunghiuri disjuncte diferite
//2 cate 2, care au un nr. de patrate albe = nr de patrate negre
//(N^2 in suma de numere pare)

// Plata unei sume in monezi

Alocare dinamica - inversare lista construita prin insertie

//Inversare lista construita prin insertie
//
//V. Rosca - Culegere de probleme de programare, prb. 7.1 == [2], pag. 127
//+ [2], pag. 126, prb. 1
//
# include <stdio.h>;
# include <alloc.h>;
# include <conio.h>;

struct nod{int util; struct nod * next;};
typedef struct nod NOD;
typedef NOD * NOD_PTR;

int n,i,val;
NOD_PTR first,p,q,r;

void main(void)
{
clrscr();

printf("Intr nr de elemente: ");
 scanf("%d",&n);
//Creare primul nod
i=1;
printf("a[%d]=",i);
 scanf("%d",&val);

first=NULL;
first=(NOD_PTR)malloc(sizeof(NOD));
first->util=val;
first->next=NULL;

//Inserarea celorlalte numere

for(i=2;i<=n;i++)
{
 //Citire valoare
 printf("a[%d]=",i);
  scanf("%d",&val);

 //Determinare pozitie si legarea in lista
 p=first;
 while((p->next!=NULL)&&(p->next->util<val))
  {
   p=p->next;
  }
 //Cream un nou nod(var dinamica), dupa ce i-am determinat pozitia (p->next)
 q=(NOD_PTR) malloc(sizeof(NOD));
  q->util=val;
  q->next=NULL;
  if(val<p->util)
   {
    q->next=p;
    first=q;
   }
  else
   {
    q->next=p->next;
    p->next=q;
   }
}
//Afisam lista sortata prin inserare
printf("\nAfisam lista sortata:\n");
p=first;
while(p!=NULL)
{
 printf("%d ",p->util);
 p=p->next;
}

//Inversam lista
p=first;
//Lucrez cu perechi de pointeri si le interschimb legaturile
q=p->next;
p->next=NULL;

while(q)
{
 r=q->next;
 q->next=p;
 p=q;
 q=r; //q==NULL la ultima bucla
}
first=p;

//Afisam lista inversata
printf("\nAfisam lista inversata:\n");
p=first;
while(p!=NULL)
{
 printf("%d ",p->util);
 p=p->next;
}


getche();
}

Alocare dinamica - sortare liste

# include <stdio.h>;
# include <alloc.h>;
# include <conio.h>;

struct nod{int util; struct nod * next;};
typedef struct nod NOD;
typedef NOD * NOD_PTR;

int n,m,i,val;
NOD_PTR first1,first2,p,q;

NOD * sl_ins(int n)
{
NOD * first;
//Creare primul nod
i=1;
printf("a[%d]=",i);
 scanf("%d",&val);

first=NULL;
first=(NOD_PTR)malloc(sizeof(NOD));
first->util=val;
first->next=NULL;

//Inserarea celorlalte numere

for(i=2;i<=n;i++)
{
 //Citire valoare
 printf("a[%d]=",i);
  scanf("%d",&val);

 //Determinare pozitie si legarea in lista
 p=first;
 while((p->next!=NULL)&&(p->next->util<val))
  {
   p=p->next;
  }
 //Cream un nou nod(var dinamica), dupa ce i-am determinat pozitia (p->next)
 q=(NOD_PTR) malloc(sizeof(NOD));
  q->util=val;
  q->next=NULL;
  if(val<p->util)
   {
    q->next=p;
    first=q;
   }
  else
   {
    q->next=p->next;
    p->next=q;
   }
}
return first;
}

void afis(NOD * first)
{
//Afisam lista sortata prin inserare
printf("\nAfisam lista:\n");
p=first;
while(p!=NULL)
{
 printf("%d ",p->util);
 p=p->next;
}

}

void main(void)
{
clrscr();

printf("Intr nr de elemente din prima lista: ");
 scanf("%d",&n);
printf("Intr nr de elemente din a doua lista: ");
 scanf("%d",&m);


first1=sl_ins(n);
first2=sl_ins(m);

afis(first1);
 printf("\n");
afis(first2);

getche();
}

Backtracking - permutari - alocare dinamica

//Permutari prin alocare dinamica
# include <stdio.h>;
# include <conio.h>;
# include <alloc.h>;

# define MAX 100

struct nod{int util; struct nod * next;};
typedef struct nod NOD;
typedef NOD * NOD_PTR;

NOD_PTR vf;
int n,sol[MAX];

void final()
{
int i;
 for(i=0;i<n;i++)
  printf("%d ",sol[i]);
printf("\n");
}
int verif(int j, int k)
{
int i;
for(i=0;i<k;i++)
 if(sol[i]==j) return 0;
return 1;
}

void back(int k)
{
int j;
if(k==n) final();
else
 for(j=1;j<=n;j++)
  if(verif(j,k))
   {
    sol[k]=j;
    vf=s_push(vf,j)
   }
vf=s_pop(vf,val);
}

void main(void)
{
clrscr();

printf("Intr n= ");
 scanf("%d",&n);

back(0);

getche();
}

Maxim - Divide et Impera

# include <stdio.h>;
# include <conio.h>;
# include <values.h>;

# define MAX 100 //maxim 100 de elemente in sir

int i,n,val,a[MAX];

void main(void)
{
clrscr();

printf("Intr nr de elemente din sir: ");
 scanf("%d",&n);
printf("\nIntr elementele sirului:\n");
 for(i=0;i<n;i++)
  scanf("%d",&a[i]);

int s,d,mij;
int max,max1,max2;

s=0;
d=n;
mij=(s+d)/2;

max=max1=max2=-MAXINT;

int gasit=1;
while((s<=d)&&(gasit==1))
 {
  gasit=0;
  s=0;
  d=n;
  mij=(s+d)/2;


  while(a[mij+1]>max) {max1=a[mij+1]; s=mij+1;gasit=1;}
  while(a[mij-1]>max) {max2=a[mij-1]; d=mij-1;gasit=1;}
  if(max1>max2) max=max1;
  else max=max2;
 }

printf("\nMAX din sir este: %d",max);

getche();
}

Subsir de suma maxima

//
//Det secventa de m numere distincte dintr-un sir de n nr, cu suma maxima
//
# include <stdio.h>;
# include <conio.h>;
# include <values.h>;

# define MAX 100

int i,n,m,s,max=-MAXINT,a[MAX],sol[MAX];//,solmax[MAX];
int * solmax;
void afis()
{
int i;
s=0;
for(i=0;i<m;i++)
 {
  //printf("%d ",a[sol[i]]);
  s=s+a[sol[i]];
 }
 if(s>max)
   {
    max=s;
    //for(i=0;i<m;i++)
     //solmax[i]=sol[i];
     solmax=sol;  // !!! NU
   }
//printf("\n");
}
int verif(int j,int k)
{
int i;
for(i=0;i<k;i++)
 if(a[sol[i]]==a[j]) return 0;
return 1;
}
void back(int k)
{
int j;
if(k==m) afis();
else
 for(j=0;j<n;j++)
  if(verif(j,k))
   {
    sol[k]=j;
    back(k+1);
   }
}
void main(void)
{
clrscr();
printf("Intr n,m:\n");
 scanf("%d%d",&n,&m);
printf("Intr elemtele sirului:\n");
for(i=0;i<n;i++)
 scanf("%d",&a[i]);
back(0);
printf("\nSolutia optima este:\n");
for(i=0;i<m;i++)
 printf("%d ",a[solmax[i]]);
printf("\nSuma maxima este: %d\n",max);
getche();
}

Alocare dinamica - interclasare liste

# include <stdio.h>;
# include <alloc.h>;
# include <conio.h>;
# include <values.h>;
# include <math.h>;

struct nod{int util; struct nod * next;};
typedef struct nod NOD;
typedef NOD * NOD_PTR;

int n,m,i,val;
NOD_PTR first1,first2,first3,p,q,r,s,aux;

NOD * sl_ins(int n)
{
NOD * first;
//Creare primul nod
i=1;
printf("a[%d]=",i);
 scanf("%d",&val);

first=NULL;
first=(NOD_PTR)malloc(sizeof(NOD));
first->util=val;
first->next=NULL;

//Inserarea celorlalte numere

for(i=2;i<=n;i++)
{
 //Citire valoare
 printf("a[%d]=",i);
  scanf("%d",&val);

 //Determinare pozitie si legarea in lista
 p=first;
 while((p->next!=NULL)&&(p->next->util<val))
  {
   p=p->next;
  }
 //Cream un nou nod(var dinamica), dupa ce i-am determinat pozitia (p->next)
 q=(NOD_PTR) malloc(sizeof(NOD));
  q->util=val;
  q->next=NULL;
  if(val<p->util)
   {
    q->next=p;
    first=q;
   }
  else
   {
    q->next=p->next;
    p->next=q;
   }
}

//Creare santinele

r=NULL;
r=(NOD *)malloc(sizeof(NOD));
r->next=NULL;
r->util= - MAXINT;

//Legare la primul nod
r->next=first;
first=r;

r=NULL;
r=(NOD *)malloc(sizeof(NOD));
r->next=NULL;
r->util= + MAXINT;

//Legare dupa ultimul nod
// (**)

// !!! Parcurg lista (q nu e ultimul daca s-a inserat primul si p=?)
p=first;
while(p->next!=NULL)
{
p=p->next;
}
//Acum p==ultimul nod

// (**)
p->next=r;

return first;
}

void afis(NOD * first)
{
//Afisam lista sortata prin inserare
printf("\nAfisam lista:\n");
p=first;
while(p!=NULL)
{
 if(abs(p->util)!=MAXINT)
   printf("%d ",p->util);
 p=p->next;
}

}

void main(void)
{
clrscr();

printf("Intr nr de elemente din prima lista: ");
 scanf("%d",&n);
printf("Intr nr de elemente din a doua lista: ");
 scanf("%d",&m);


first1=sl_ins(n);
first2=sl_ins(m);

afis(first1);
 printf("\n");
afis(first2);

//Interclasare
p=first1;
q=first2;

first3=NULL;
first3=(NOD *)malloc(sizeof(NOD));
first3->next=NULL;


if(p->util<q->util)
 {
  first3->util=p->util;
  p=p->next;
 }
else
{
 first3->util=q->util;
  q=q->next;
}
aux=first3;

while((p!=NULL)&&(q!=NULL))
{

r=NULL;
r=(NOD *)malloc(sizeof(NOD));
r->next=NULL;

if(p->util<q->util)
 {
  r->util=p->util;
  p=p->next;
 }
else
{
 r->util=q->util;
  q=q->next;
}
aux->next=r;
aux=r;
}

//Copiere
if(p==NULL)
 aux=q;
else aux=p;

s=r;

r=NULL;
r=(NOD *)malloc(sizeof(NOD));
r->next=NULL;
r->util=aux->util;

aux=aux->next;
s->next=r;
s=r;

while(aux!=NULL)
{
r=NULL;
r=(NOD *)malloc(sizeof(NOD));
r->next=NULL;

r->util=aux->util;
aux=aux->next;

s->next=r;
s=r;

}

//Afisare sir interclasat
printf("\nAfisez sirl interclasat:\n");
afis(first3);

getche();
}

# include <stdio.h>;
# include <alloc.h>;
# include <conio.h>;

struct nod{int util; struct nod * next;};
typedef struct nod NOD;
typedef NOD * NOD_PTR;

int n,m,i,val;
NOD_PTR first1,first2,first3,p,q,r,s,aux;

NOD * sl_ins(int n)
{
NOD * first;
//Creare primul nod
i=1;
printf("a[%d]=",i);
 scanf("%d",&val);

first=NULL;
first=(NOD_PTR)malloc(sizeof(NOD));
first->util=val;
first->next=NULL;

//Inserarea celorlalte numere

for(i=2;i<=n;i++)
{
 //Citire valoare
 printf("a[%d]=",i);
  scanf("%d",&val);

 //Determinare pozitie si legarea in lista
 p=first;
 while((p->next!=NULL)&&(p->next->util<val))
  {
   p=p->next;
  }
 //Cream un nou nod(var dinamica), dupa ce i-am determinat pozitia (p->next)
 q=(NOD_PTR) malloc(sizeof(NOD));
  q->util=val;
  q->next=NULL;
  if(val<p->util)
   {
    q->next=p;
    first=q;
   }
  else
   {
    q->next=p->next;
    p->next=q;
   }
}
return first;
}

void afis(NOD * first)
{
//Afisam lista sortata prin inserare
printf("\nAfisam lista:\n");
p=first;
while(p!=NULL)
{
 printf("%d ",p->util);
 p=p->next;
}

}

void main(void)
{
clrscr();

printf("Intr nr de elemente din prima lista: ");
 scanf("%d",&n);
printf("Intr nr de elemente din a doua lista: ");
 scanf("%d",&m);


first1=sl_ins(n);
first2=sl_ins(m);

afis(first1);
 printf("\n");
afis(first2);

//Interclasare
p=first1;
q=first2;

first3=NULL;
first3=(NOD *)malloc(sizeof(NOD));
first3->next=NULL;


if(p->util<q->util)
 {
  first3->util=p->util;
  p=p->next;
 }
else
{
 first3->util=q->util;
  q=q->next;
}
aux=first3;

while((p!=NULL)&&(q!=NULL))
{

r=NULL;
r=(NOD *)malloc(sizeof(NOD));
r->next=NULL;

if(p->util<q->util)
 {
  r->util=p->util;
  p=p->next;
 }
else
{
 r->util=q->util;
  q=q->next;
}
aux->next=r;
aux=r;
}

//Copiere
if(p==NULL)
 aux=q;
else aux=p;

s=r;

r=NULL;
r=(NOD *)malloc(sizeof(NOD));
r->next=NULL;
r->util=aux->util;

aux=aux->next;
s->next=r;
s=r;

while(aux!=NULL)
{
r=NULL;
r=(NOD *)malloc(sizeof(NOD));
r->next=NULL;

r->util=aux->util;
aux=aux->next;

s->next=r;
s=r;

}

//Afisare sir interclasat
printf("\nAfisez sirl interclasat:\n");
afis(first3);

getche();
}

Heapsort - vector

# include <stdio.h>;
# include <conio.h>;

# define MAX 100

typedef int tip[MAX];

int i,n,val;
tip h;

void Insert(tip &h,int x)
{
int i;

i=n+1;
while((i>1)&&(h[int(i/2.0)]>x)&&(h[int(i/2.0)]==0))
{
h[i]=h[int(i/2.0)];
i=(int)(i/2.0);
}
h[i]=x;
}

void HeapSort(int n)
{
int i,aux;

for(i=n;i>=2;i--)
 {
 aux=h[1];
 h[1]=h[i];
 h[i]=aux;
 }

}

void main(void)
{
clrscr();

printf("Intr nr de elemente din sir: ");
 scanf("%d",&n);
printf("Intr elementele sirului:\n");
for(i=1;i<=n;i++)
 {
 scanf("%d",&val);
 Insert(h,val);
 }

//
 //HeapSort(n);
//

printf("\nAfisez sirul sortat:\n");
for(i=1;i<=n;i++)
 printf("%d ",h[i]);

getche();
}

Heapsort - operatii binare vector

# include <stdio.h>;
# include <conio.h>;

# define MAX 100

int i,n,h[MAX];

void Scufunda(int n,int k)
{

int fiu=0;

//Se alege fiul cu valoarea mai mare
if((k<<1) < n)
 {
  fiu=k<<1;
  if(( ((k<<1)|1) < n) && (h[(k<<1)|1] > h[k<<1]))
   fiu=fiu|1;
  //Interschimbare numai daca este nevoie
  if(h[fiu] <= h[k]) fiu=0;
 }
else fiu=0;

while(fiu)
 {
  //Interschimbare
  int aux;
  aux=h[k];
  h[k]=h[fiu];
  h[fiu]=aux;
  k=fiu;
  //Se alege urmatorul fiu
  if((k<<1) < n)
  {
   fiu=k<<1;
   if(( ((k<<1)|1) < n) && (h[(k<<1)|1] > h[k<<1]))
    fiu=fiu|1;
  //Interschimbare numai daca este nevoie
  if(h[fiu] <= h[k]) fiu=0;
 }
 else fiu=0;
 }
}

void ConstruiesteHeap(int n)
{
int i;
for(i=(n>>1);i>0;i--)
 Scufunda(n,i);
}

void HeapSort(int n)
{
int i,aux;

ConstruiesteHeap(n);

for(i=n;i>=2;i--)
 {
 aux=h[1];
 h[1]=h[i];
 h[i]=aux;
 Scufunda(i,1);
 }

}

void main(void)
{
clrscr();

printf("Intr nr de elemente din sir: ");
 scanf("%d",&n);
printf("Intr elementele sirului:\n");
for(i=1;i<=n;i++)
 scanf("%d",&h[i]);

//
 HeapSort(n);
//

printf("\nAfisez sirul sortat:\n");
for(i=1;i<=n;i++)
 printf("%d ",h[i]);

getche();
}

Metoda Greedy - solutia optima (nr min de monezi)

//Metoda Greedy - solutia optima (nr min de monezi)

# include <stdio.h>;
# include <conio.h>;
# include <math.h>;

# define MAX 20

int n=9;
long int const m[MAX]={1,2,5,10,20,50,100,500,1000};
long int sum,i,x;

void main(void)
{
clrscr();

 printf("Intr suma: ");
  scanf("%ld",&sum);

//cat timp s!=0 daca m[0]!=1
for(i=n-1;i>=0;i--) //sortare
 {
  //aleg optimul
  x=floor(sum/m[i]);
  if(x)
   printf("%ld monezi de %ld\n",x,m[i]);
  sum=sum-x*m[i];
 }

getche();
}
//Ex de nr care foloseste toate tipurile de monezi?

Generare lista adiacenta

# include <stdio.h>;
# include <conio.h>;
# include <alloc.h>;
# include <stdlib.h>;

typedef struct nodd{int util;struct nodd * next;} NOD;
typedef NOD * NOD_PTR;

unsigned long int n;

NOD_PTR gen(unsigned long int n)
{
NOD_PTR p,q,first;
unsigned long int i;

first=(NOD_PTR)malloc(sizeof(NOD));
first->util=random(100);
first->next=NULL;
p=first;
for(i=0;i<n-1;i++)
 {
  q=(NOD_PTR)malloc(sizeof(NOD));
  q->util=random(100);
  q->next=NULL;
  p->next=q;
  p=q;
 }
return first;
}

void afis(NOD_PTR f)
{
NOD_PTR p;

printf("\nAfisez lista:\n");
p=f;
while(p!=NULL)
{
 printf("%d ",p->util);
 p=p->next;
}
}

void main(void)
{
clrscr();
 printf("Intr nr de elem din lista: ");
  scanf("%uld",&n);
 afis(gen(n));
getche();
}

Afisare continut memorie RAM

#include<stdio.h>
#include<conio.h>
float *p;
int i;
float b;
long n=0l;
void main(void){
clrscr();
p=NULL;
p++;
while(p!=NULL){
 // for(i=0;i<sizeof(int);i++)
    {
    b=*p;
    /*if(b&1==1)
       printf("1");
    else
       printf("0");
       b>>1;
       }
       n++;
       p++;
       } */
       printf("%f",b);}   }
       printf("\n%ld",n);
       getch();
  }

Test Clasa Complex

# include <iostream.h>;
# include <conio.h>;

class COMPLEX
     {
      public:
       int re,im;


      public:
       int get_re()
{return re;}
       int get_im()
{return im;}



       COMPLEX()
       {re=im=-1;}
       COMPLEX(int n)
       {re=im=n;}
       COMPLEX(int n,int m)
       {re=n;im=m;}

       ~COMPLEX() //Vezi Alt+F5
       {
cout<<"\nSalut!";
       }







       void afis()
       {
cout<<"\nNr complex este: "<<this->re<<"+i*"<<this->im<<"\n";
       }
       void suma(COMPLEX c1)
       {
re=re+c1.re;  //this->re=this->re+c1.re;
im=im+c1.im;
       }
     };







void aduna(COMPLEX c1,COMPLEX c2)
{
 cout<<"Suma este: "<<c1.get_re()+c2.get_re()<<"+i*"<<c1.get_im()+c2.get_im();
}
//void aduna(COMPLEX &c1,COMPLEX &c2) nu mai sunt create obiecte temporare
//este apelat un contructor implicit de copiere, nu sunt apelati destructori
//Vezi Alt+F5









COMPLEX c1(10),c2(12,34),c3;//,v[10];

void main(void)
{
clrscr();

c1.afis();
c2.afis();
c3.afis();

aduna(c1,c2);
c1.suma(c3);
c1.afis();

getche();
}

Parcurgere Arbori binari

# include <stdio.h>;
# include <conio.h>;
# include <alloc.h>;
# include <string.h>;

struct nod {char rom[100], eng[100]; struct nod *s, *d;};
typedef struct nod NODarb;

NODarb * r;

int n,x;
int i;

FILE * pf;
char cuv[100];

NODarb* creare(NODarb * r)
{ NODarb * q, * p;

pf=fopen("dict.txt","r");

  while(!feof(pf))
   {

  if(r==NULL)
  {
   q=(NODarb*)malloc(sizeof(NODarb));
   fgets(cuv,100,pf);
    strcpy(q->rom,cuv);
   fgets(cuv,100,pf);
    strcpy(q->eng,cuv);
   q->s=q->d=NULL;
   r=q;//q devine radacina pentru noul arbore
  }

  else
  {
   q=(NODarb*)malloc(sizeof(NODarb));
   fgets(cuv,100,pf);
    strcpy(q->rom,cuv);
   fgets(cuv,100,pf);
    strcpy(q->eng,cuv);
   q->s=q->d=NULL;

   p=r;

   while((p->s!=NULL)&&(p->d!=NULL))
    if(strcmp(p->rom,q->rom)<0) p=p->d;
    else p=p->s;

  if(strcmp(p->rom,q->rom)<0) p->d=q;
  else p->s=q;
  }
 }
fclose(pf);

return r;
}

//******************************* PARCURGERI ********************************

void RSD(NODarb * r)
{
 if(r!=NULL)
  {
    printf("%s ",r->rom);
    printf("%s\n",r->eng);
   RSD(r->s);
   RSD(r->d);
  }
}

void SRD(NODarb * r)
{
 if(r!=NULL)
  {
   SRD(r->s);
    printf("%s ",r->rom);
    printf("%s\n",r->eng);
   SRD(r->d);
  }
}

void SDR(NODarb * r)
{
 if(r!=NULL)
  {
   SDR(r->s);
   SDR(r->d);
    printf("%s ",r->rom);
    printf("%s\n",r->eng);
  }
}

void main(void)
{
clrscr();
  r=creare(r);
printf("\nParcurgere in preordine:\n");
 RSD(r);
printf("\nParcurgere in inordine:\n");
 SRD(r);
printf("\nParcurgere in postordine:\n");
 SDR(r);

getche();
}



# include <stdio.h>;
# include <conio.h>;
# include <alloc.h>;

struct nod {int info; struct nod *s, *d;};
typedef struct nod NODarb;

NODarb * r;

int n,x;
int i;

NODarb* insert(NODarb * r,int x)
{ NODarb * q;
  if(r==NULL)
  {
   q=(NODarb*)malloc(sizeof(NODarb));
   q->info=x;
   q->s=q->d=NULL;
   r=q;//q devine radacina pentru noul arbore
  }
  else
  {
   if (r->info>x) r->s=insert(r->s,x);
   else r->d=insert(r->d,x);
  }
return r;
}
void RSD(NODarb * r)
{
 if(r!=NULL)
  {
    printf("%d ",r->info);
   RSD(r->s);
   RSD(r->d);
  }
}

void SRD(NODarb * r)
{
 if(r!=NULL)
  {
   SRD(r->s);
    printf("%d ",r->info);
   SRD(r->d);
  }
}

void SDR(NODarb * r)
{
 if(r!=NULL)
  {
   SDR(r->s);
   SDR(r->d);
    printf("%d ",r->info);
  }
}

void main(void)
{
clrscr();

printf("Intr nr de noduri: ");
 scanf("%d",&n);

for(i=0;i<n;i++)
 {
  scanf("%d",&x);
  r=insert(r,x);
 }
printf("\nParcurgere in preordine:\n");
 RSD(r);
printf("\nParcurgere in inordine:\n");
 SRD(r);
printf("\nParcurgere in postordine:\n");
 SDR(r);

getche();
}

/*
1 2 0 0 3 4 5 0 0 6 0 0 7 0 0

RSD: 1 2 3 4 5 6 7

SRD: 2 1 5 4 6 3 7

SDR: 2 5 6 4 7 3 1

*/

# include <stdio.h>;
# include <conio.h>;
# include <alloc.h>;

struct nod {int info; struct nod *s, *d;};
typedef struct nod NODarb;

NODarb * r;
int i,n;
NODarb* creare(NODarb * r)
{
 int x;
 NODarb * q;
 scanf("%d",&x);
 if(x==0) r=NULL;
 else
  {
   q=(NODarb*)malloc(sizeof(NODarb));
   q->info=x;
   q->s=q->d=NULL;
   r=q;//q devine radacina pentru noul arbore

   q->s=creare(q->s);
   q->d=creare(q->d);
  }
return r;
}
void RSD(NODarb * r)
{
 if(r!=NULL)
  {
    printf("%d ",r->info);
   RSD(r->s);
   RSD(r->d);
  }
}

void SRD(NODarb * r)
{
 if(r!=NULL)
  {
   SRD(r->s);
    printf("%d ",r->info);
   SRD(r->d);
  }
}

void SDR(NODarb * r)
{
 if(r!=NULL)
  {
   SDR(r->s);
   SDR(r->d);
    printf("%d ",r->info);
  }
}

void main(void)
{
clrscr();

r=creare(r);

printf("\nParcurgere in preordine:\n");
 RSD(r);
printf("\nParcurgere in inordine:\n");
 SRD(r);
printf("\nParcurgere in postordine:\n");
 SDR(r);

getche();
}

/*
1 2 0 0 3 4 5 0 0 6 0 0 7 0 0

RSD: 1 2 3 4 5 6 7

SRD: 2 1 5 4 6 3 7

SDR: 2 5 6 4 7 3 1

*/

# include <stdio.h>;
# include <conio.h>;
# include <alloc.h>;

struct nod {int info; struct nod *s, *d;};
typedef struct nod NODarb;

NODarb * r;
int i,n;
void creare(NODarb * &r)
{
 int x;
 NODarb * q;
 scanf("%d",&x);
 if(x==0) q=NULL;
 else
  {
   q=(NODarb*)malloc(sizeof(NODarb));
   q->info=x;
   q->s=q->d=NULL;

   creare(q->s);
   creare(q->d);
  }
//trimitem ca referinta adresa lui r pt ca in subprogram aceasta se modifica
r=q;
}

void RSD(NODarb * r)
{
 if(r!=NULL)
  {
    printf("%d ",r->info);
   RSD(r->s);
   RSD(r->d);
  }
}

void SRD(NODarb * r)
{
 if(r!=NULL)
  {
   SRD(r->s);
    printf("%d ",r->info);
   SRD(r->d);
  }
}

void SDR(NODarb * r)
{
 if(r!=NULL)
  {
   SDR(r->s);
   SDR(r->d);
    printf("%d ",r->info);
  }
}

void main(void)
{
clrscr();

creare(r);

printf("\nParcurgere in preordine:\n");
 RSD(r);
printf("\nParcurgere in inordine:\n");
 SRD(r);
printf("\nParcurgere in postordine:\n");
 SDR(r);

getche();
}

/*
1 2 0 0 3 4 5 0 0 6 0 0 7 0 0

RSD: 1 2 3 4 5 6 7

SRD: 2 1 5 4 6 3 7

SDR: 2 5 6 4 7 3 1

*/

# include <stdio.h>;
# include <conio.h>;
# include <alloc.h>;

struct nod {int info; struct nod *s, *d;};
typedef struct nod NODarb;

NODarb * r;
int i,n;
FILE * pf;

NODarb* creare(NODarb * r)
{
 int x;
 fscanf(pf,"%d",&x);
 if(x==0) r=NULL;
 else
  {
   r=(NODarb*)malloc(sizeof(NODarb));
   r->info=x;
   r->s=r->d=NULL;

   r->s=creare(r->s);
   r->d=creare(r->d);
  }
return r;
}
void RSD(NODarb * r)
{
 if(r!=NULL)
  {
    printf("%d ",r->info);
   RSD(r->s);
   RSD(r->d);
  }
}

void SRD(NODarb * r)
{
 if(r!=NULL)
  {
   SRD(r->s);
    printf("%d ",r->info);
   SRD(r->d);
  }
}

void SDR(NODarb * r)
{
 if(r!=NULL)
  {
   SDR(r->s);
   SDR(r->d);
    printf("%d ",r->info);
  }
}

void main(void)
{
clrscr();
pf=fopen("c:\\arbore.txt","r");
r=creare(r);

printf("\nParcurgere in preordine:\n");
 RSD(r);
printf("\nParcurgere in inordine:\n");
 SRD(r);
printf("\nParcurgere in postordine:\n");
 SDR(r);

fclose(pf);
getche();
}

/*
1 2 0 0 3 4 5 0 0 6 0 0 7 0 0

RSD: 1 2 3 4 5 6 7

SRD: 2 1 5 4 6 3 7

SDR: 2 5 6 4 7 3 1

*/

Clasa complex-rational

# include "comprat1.cpp";//clasa RATIONAL

class COMPLEX:public RATIONAL
     {
      private:
       float re,im;
      public:
       int get_re()
       {return re;}
       int get_im()
       {return im;}
       COMPLEX()
       {
RATIONAL r1,r2;
cout<<"\Intr un nr RATIONAL sub forma a/b: ";
cin>>r1;
cout<<"\Intr un nr RATIONAL sub forma a/b: ";
cin>>r2;
re=((float)r1.x)/r1.y;
im=((float)r2.x)/r2.y;
       }
       COMPLEX(int n)
       {re=im=n;}
       COMPLEX(int n,int m)
       {re=n;im=m;}
       ~COMPLEX() //Vezi Alt+F5
       {
cout<<"\nSalut!";
       }
       void afis()
       {
printf("\nNr complex este: %.2f+i*%.2f\n",this->re,this->im);
       }
       void suma(COMPLEX c1)
       {
re=re+c1.re;  //this->re=this->re+c1.re;
im=im+c1.im;
       }
       friend void sum(COMPLEX x, COMPLEX y);
       COMPLEX operator+(COMPLEX z)
       {
COMPLEX t(re+z.re,im+z.im);
return t;
       }
     };

void aduna(COMPLEX c1,COMPLEX c2)
{
 cout<<"Suma este: "<<c1.get_re()+c2.get_re()<<"+i*"<<c1.get_im()+c2.get_im();
}
//void aduna(COMPLEX &c1,COMPLEX &c2) nu mai sunt create obiecte temporare
//este apelat un contructor implicit de copiere, nu sunt apelati destructori
//Vezi Alt+F5

void sum(COMPLEX x, COMPLEX y)
//friend = fara COMPLEX :: = f. externa care are acces la atribute
{
 cout<<"Sum_friend este: "<<x.re+y.re<<"+i*"<<x.im+y.im;
}

Clasa numere rationale

# include <iostream.h>;
# include <stdio.h>;
# include <conio.h>;
# include <math.h>;

class RATIONAL
      {
       public:
      int x,y;
      RATIONAL()
      {x=0;y=1;}
      RATIONAL(int a,int b);//:x(a),y(b){};
      RATIONAL operator+(RATIONAL &);
      RATIONAL operator-(RATIONAL &);
      RATIONAL operator*(RATIONAL &);
      RATIONAL operator/(RATIONAL &);
      RATIONAL operator-();
      RATIONAL operator~();
      friend ostream & operator<<(ostream& out, RATIONAL &);
      friend istream & operator>>(istream& out, RATIONAL &);
       private:
       int cmmdc(int a,int b)
       {
if(a%b==0)
  return b;
else
    return abs(cmmdc(b,a%b));
       }
      };

RATIONAL :: RATIONAL(int a,int b)
{
if(b==0) b=1;
x=a;
y=b;
}
RATIONAL RATIONAL :: operator+(RATIONAL & b)
{
RATIONAL c;
c.x=x*b.y+b.x*y;
c.y=y*b.y;
int d=cmmdc(c.x,c.y);
return RATIONAL(c.x/d,c.y/d);
}
RATIONAL RATIONAL :: operator-()
{
return RATIONAL(-x,-y);
}
RATIONAL RATIONAL :: operator-(RATIONAL & b)
{
RATIONAL c;
c=-b;
return (c+ *this);
}
RATIONAL RATIONAL :: operator*(RATIONAL & b)
{
RATIONAL c;
c.x=x*b.x;
c.y=y*b.y;
int d=cmmdc(c.x,c.y);
return RATIONAL(c.x/d,c.y/d);
}
RATIONAL RATIONAL :: operator~()
{
return RATIONAL(this->y,this->x);
}
RATIONAL RATIONAL :: operator/(RATIONAL & d)
{
return (*this)*(~d);
}

ostream & operator<<(ostream & out, RATIONAL & obj)
{
out<<obj.x<<"/"<<obj.y;
return out;
}
istream & operator>>(istream & in, RATIONAL & obj)
{
scanf("%d/%d",&obj.x,&obj.y);
return in;
}

Varianta 2:

# include <iostream.h>;
# include <stdio.h>;
# include <conio.h>;
# include <math.h>;

class RATIONAL
      {
       public:
      int x,y;
      RATIONAL()
      {x=0;y=1;}
      RATIONAL(int a,int b);//:x(a),y(b){};
      RATIONAL operator+(RATIONAL &);
      RATIONAL operator-(RATIONAL &);
      RATIONAL operator*(RATIONAL &);
      RATIONAL operator/(RATIONAL &);
      RATIONAL operator-();
      RATIONAL operator~();
      friend ostream & operator<<(ostream& out, RATIONAL &);
      friend istream & operator>>(istream& out, RATIONAL &);
       private:
       int cmmdc(int a,int b)
       {
if(a%b==0)
  return b;
else
    return abs(cmmdc(b,a%b));
       }
      };

RATIONAL :: RATIONAL(int a,int b)
{
if(b==0) b=1;
x=a;
y=b;
}
RATIONAL RATIONAL :: operator+(RATIONAL & b)
{
RATIONAL c;
c.x=x*b.y+b.x*y;
c.y=y*b.y;
int d=cmmdc(c.x,c.y);
return RATIONAL(c.x/d,c.y/d);
}
RATIONAL RATIONAL :: operator-()
{
return RATIONAL(-x,-y);
}
RATIONAL RATIONAL :: operator-(RATIONAL & b)
{
RATIONAL c;
c=-b;
return (c+ *this);
}
RATIONAL RATIONAL :: operator*(RATIONAL & b)
{
RATIONAL c;
c.x=x*b.x;
c.y=y*b.y;
int d=cmmdc(c.x,c.y);
return RATIONAL(c.x/d,c.y/d);
}
RATIONAL RATIONAL :: operator~()
{
return RATIONAL(this->y,this->x);
}
RATIONAL RATIONAL :: operator/(RATIONAL & d)
{
return (*this)*(~d);
}

ostream & operator<<(ostream & out, RATIONAL & obj)
{
out<<obj.x<<"/"<<obj.y;
return out;
}
istream & operator>>(istream & in, RATIONAL & obj)
{
scanf("%d/%d",&obj.x,&obj.y);
return in;
}

void main(void)
{
RATIONAL r(3,7),z;

clrscr();

z=-r;
cout<<z<<endl;

z=~r;
cout<<z<<endl;

cout<<"\Intr un nr RATIONAL sub forma a/b: ";
cin>>z;
cout<<z<<endl;

//

RATIONAL a,b,c;
cout<<"\Intr un nr RATIONAL sub forma a/b: ";
 cin>>a;
cout<<"\Intr un nr RATIONAL sub forma a/b: ";
 cin>>b;

c=a+b;
cout<<c<<endl;

c=a-b;
cout<<c<<endl;

c=a*b;
cout<<c<<endl;

c=a/b;
cout<<c<<endl;

getche();
}

Clasa numere complexe

# include <iostream.h>;
# include <conio.h>;

class COMPLEX
     {
      private:
       int re,im;
      public:
       int get_re()
       {return re;}
       int get_im()
       {return im;}
       COMPLEX()
       {re=im=-1;}
       COMPLEX(int n)
       {re=im=n;}
       COMPLEX(int n,int m)
       {re=n;im=m;}
       ~COMPLEX() //Vezi Alt+F5
       {
cout<<"\nSalut!";
       }
       void afis()
       {
cout<<"\nNr complex este: "<<this->re<<"+i*"<<this->im<<"\n";
       }
       void suma(COMPLEX c1)
       {
re=re+c1.re;  //this->re=this->re+c1.re;
im=im+c1.im;
       }
     };

void aduna(COMPLEX c1,COMPLEX c2)
{
 cout<<"Suma este: "<<c1.get_re()+c2.get_re()<<"+i*"<<c1.get_im()+c2.get_im();
}
//void aduna(COMPLEX &c1,COMPLEX &c2) nu mai sunt create obiecte temporare
//este apelat un contructor implicit de copiere, nu sunt apelati destructori
//Vezi Alt+F5

COMPLEX c1(10),c2(12,34),c3;//,v[10];

void main(void)
{
clrscr();

c1.afis();
c2.afis();
c3.afis();

aduna(c1,c2);
c1.suma(c3);
c1.afis();

getche();
}