Liste Arbori Sortari

Liste si arbori
1
/* arbelnod.cpp - programul construieste recursiv si tipareste un arbore
de numere intregi, utilizand functiile recursive: 'inserare', 'listare'.
Arborele contine pe langa valorile intregi ordonate (SRD)
si numarul de aparitii pentru valorile ce se repeta.
Programul permite elimiarea unei anumite valori (chei), adica
un nod din arbore ce contine cheia, pastrand arborele de cautare (SRD).
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct tnod
int nr;
int ap;
struct tnod *pstg;
struct tnod *pdr;
} ARB;
int nel = 0;
ARB *e;
void inserare (ARB * &v, int val){
ARB *pc;
int gasit;
if (!v)
{v = new ARB; v->nr=val; v->ap=1;

v->pstg=NULL; v->pdr=NULL;}
else if (v->nr > val)
inserare(v->pstg, val);
else if (v->nr < val)
inserare(v->pdr, val);
else
v->ap++;
void inlocuire_nod(ARB * &n){ // n - nodul de eliminat
// se inlocuieste cu maximul de pe subarborele stang (acum maximul din n),
// care este pe ramura dreapta a lui 'n',
// sau cu minimul de pe subarborele drept (adica minimul din arborele n),
// rezultatul final fiind acelasi, adica un arbore de cautare
if (n->pdr)
inlocuire_nod(n->pdr);
else {e->nr=n->nr; // e - nodul care se elimina (continutul sau)
e->ap=n->ap; // se actualizeaza valorile lui 'e' cu maximul din
e=n; // arborele nodului 'n' , ramura dreapta
n=n->pstg; // pastrez legatura la ramura stanga a nodului
free(e); // pentru care elimin ramura dreapta, a carei
} // valori s-au mutat in nodul 'eliminat' (inlocuit)
void elimina_nod (ARB * &a, int x){// a-arbore, x-valoarea de eliminat
if (!a)
printf("\nCheia cautata %d nu este in arbore!\n", x);
else if (x < a->nr) // se cauta pozitia valorii 'x'
elimina_nod (a->pstg, x);

else if (x > a->nr)
elimina_nod (a->pdr, x);
else // s-a gasit pozitia lui 'x'
{e=a;
if (!a->pstg){ // are subarborele stang vid
a=a->pdr; // se conecteaza subarborele drept
free(e); // si eliberez spatiul alocat
} // nodului eliminat
else if (!a->pdr){// are subarborele drept vid
a=a->pstg; // se conecteaza subarborele stang
free(e); // si eliberez spatiul alocat
} // nodului eliminat
else
inlocuire_nod(a->pstg); // sau cu parametru 'a->pdr'
} // cu modificarile respective in functia de inlocuire
void listare_SRD (ARB *v){
if (v)
{if (v->pstg)
listare_SRD (v->pstg);
printf("%3d(%d) -> ", v->nr, v->ap);
nel++;
if (nel%7==0)
printf("\n");
if (v->pdr)
listare_SRD(v->pdr);
}
main()
ARB *pl;
int valoare;
pl = NULL;
clrscr();
printf("Se construieste un arbore de cautare si permite elimarea unui nod.\n");
printf ("\nIntroduceti un sir de valori, terminat cu EOF.\n");
printf ("Valoare:");
while ( scanf ("%d", &valoare) != EOF) {
inserare (pl,valoare);
/* afisare arbore */
printf("\nListare arbore SRD:\n");
listare_SRD (pl);
printf ("NULL\n");
printf("\nValoare de eliminat: ");
scanf("%d", &valoare);
elimina_nod(pl, valoare);
/* afisare arbore dupa eliminare */
printf("\nListare arbore SRD, dupa eliminarea valorii %d:\n", valoare);
nel=0; // initializare contor afisare pe ecran
listare_SRD (pl);
printf ("NULL\n");
printf("Terminare dupa apasarea unei taste!\n");
getch();
}
2
/*
arbinnum - programul construieste recursiv si tipareste un arbore de intregi,
utilizand functiile recursive: 'inserare' si 'listare'.
si numarul de aparitii pentru valorile ce se repeta
- afiseaza arborele si inaltimea lui
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct tnod
int nr;
int ap;
struct tnod *pstg;
struct tnod *pdr;
} ARB;
int nel = 0;
ARB *pc;
int gasit;
if (!v)

else
v->ap++;
if (v)
{if (v->pstg)
printf("%3d(%2d) -> ", v->nr, v->ap);
nel++;
if (nel%7==0)
printf("\n");
if (v->pdr)
int maxim (int a, int b){
if (a>b)
return a;
return b;
int inaltime (ARB *v){
if (!v)
return 0;
else
return 1+maxim(inaltime(v->pstg), inaltime(v->pdr));

}
main()
ARB *pl;
int valoare;
pl = NULL;
clrscr();
printf("Dimensiune structura: %d\n", sizeof (struct tnod));
printf ("\nIntroduceti un sir de valori, terminat cu 0.\n");
while ( scanf ("%d", &valoare) != EOF) {
/* afisare arbore */
printf("\nListare arbore SRD:\n");
listare_SRD (pl);
printf ("NULL\n");
printf("Inaltime arbore: %d\n", inaltime(pl));
}
3
/*
arbinrec - programul construieste recursiv si tipareste un arbore de intregi,
utilizand functiile recursive: 'inserare' si 'listare'.
si numarul de aparitii pentru valorile ce se repeta
- varianta 2 pentru functia 'inserare' (total recursiva)
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct tnod
int nr;
int ap;
struct tnod *pstg;
struct tnod *pdr;
} ARB;
int nel = 0;
ARB *pc;
int gasit;
if (!v)

else
v->ap++;
void listare_RSD (ARB *v){
if (v)
{printf("%3d(%2d) -> ", v->nr, v->ap);
nel++;
if (nel%7==0)
printf("\n");
if (v->pstg)
listare_RSD (v->pstg);
if (v->pdr)
listare_RSD(v->pdr);
if (v)
{if (v->pstg)
printf("%3d(%2d) -> ", v->nr, v->ap);
nel++;
if (nel%7==0)
printf("\n");
if (v->pdr)
}
main()
ARB *pl;
int valoare;
pl = NULL;
clrscr();
printf("Dimensiune structura: %d\n", sizeof (struct tnod));
printf ("\nIntroduceti un sir de valori, terminat cu 0.\n");
scanf ("%d", &valoare);
while ( valoare ) {
/* afisare lista */
listare_RSD (pl);
printf ("NULL\n");
nel=0;
printf("\nListare SRD:\n");
listare_SRD (pl);
printf ("NULL\n");
}
4
/* arbrecc.c - arbore, construit recursiv, ce contine cuvinte, si numarul
de aparitie a acestora, citite de la tastatura (cate un cuvant pe linie)
introducerea cuvintelor se termina cu un cuvant vid (Enter la inceputul
liniei), si apoi sunt afisate cuvintele in ordine alfabetica */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#define LUNGMAX 20
struct st_arbore
char *cuvant; /* pointer la cuvantul citit */
int nrap; /* numarul de aparitii */
struct st_arbore *st, *dr;
};
int nle=0;
void actualizare (struct st_arbore * arb , char *cuv){
/* Functia actualizeaza arborele binar.
Daca cuvantul nu a mai fost citit se creaza un nou nod,
altfel se incrementeaza contorul de aparitii al
nodului corespunzator cuvantului citit anterior.
Se determina pe care ramura a arborelui se va insera
cuvantul, sau daca exista deja
*/
if (strcmp(cuv, arb->cuvant) < 0)
if (arb->st)
actualizare (arb->st, cuv);

else {
arb->st=(struct st_arbore *) malloc (sizeof(struct st_arbore)) ;
arb=arb->st;
arb->cuvant=cuv;
arb->nrap=1;
arb->st=NULL;
arb->dr=NULL;
else if (strcmp(cuv, arb->cuvant) >0 )
if(arb->dr)
actualizare (arb->dr, cuv);
else {
arb->dr=(struct st_arbore *) malloc (sizeof(struct st_arbore)) ;
arb=arb->dr;
arb->cuvant=cuv;
arb->nrap=1;
arb->st=NULL;
arb->dr=NULL;
else
arb->nrap=arb->nrap + 1;
void tiparire_arbore (struct st_arbore *arbo)
/* functia afiseaza arborele de cautare ce contine cuvinte si
numarul lor de aparitii */
if (arbo!=NULL)
{
tiparire_arbore (arbo->st) ; /* tiparire arbore stanga */
printf ("%s (ap: %d)\n", arbo -> cuvant, arbo -> nrap ) ;
nle++;
if (nle%24==0){
printf("Apasati o tasta pentru a continua afisarea!\n");
getch();
tiparire_arbore (arbo->dr) ; /* tiparire arbore dreapta */
void main ()
{struct st_arbore *arb;
char cuvant[LUNGMAX] ;
clrscr();
prin1tf("Introduceti cuvinte, care vor fi apoi tiparite in ordine"
" alfabetica:\n");
gets(cuvant) ;
arb=(struct st_arbore *) malloc (sizeof(struct st_arbore)) ;
/* am presupus ca nu se returneaza de catre malloc
valoarea NULL */
arb->cuvant=strdup(cuvant);
arb->nrap=1;
arb->st=NULL;
arb->dr=NULL;
gets(cuvant) ;
while (strcmp(cuvant, ""))
{actualizare (arb, strdup(cuvant));
gets(cuvant);
}
printf("Lista ordonata a cuvintelor (numar aparitii):\n");
tiparire_arbore (arb);
5
/* arbrecc.cpp - arbore, construit recursiv, ce contine cuvinte, si numarul
de aparitie a acestora, citite de la tastatura (cate un cuvant pe linie)

introducerea cuvintelor se termina cu un cuvant vid (Enter la inceputul
liniei), si apoi sunt afisate cuvintele in ordine alfabetica */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#define LUNGMAX 20
struct st_arbore
char *cuvant; /* pointer la cuvantul citit */
int nrap; /* numarul de aparitii */
struct st_arbore *st, *dr;
};
int nle=0;
void actualizare (struct st_arbore * &arb , char *cuv)
/* functia actualizeaza arborele binar. Daca cuvantul nu a mai fost citit
se creaza un nou nod, altfel se incrementeaza contorul de aparitii al
nodului corespunzator cuvantului citit anterior
*/
if (arb==NULL)
{ /* arb este NULL fie s-a gasit pozitia unde trebuie adaugat
noul nod */
arb=(struct st_arbore *) malloc (sizeof(struct st_arbore)) ;
/* am presupus ca nu se returneaza de catre malloc
valoarea NULL */
arb->cuvant=cuv;
arb->nrap=1;
arb->st=NULL;
arb->dr=NULL;
else
/* se determina pe care ramura a arborelui se va insera
cuvantul, sau daca exista deja */
if (strcmp(cuv, arb->cuvant) < 0) /* daca este mai mic se cauta in
subarborele stang */
actualizare (arb->st, cuv);
else if (strcmp(cuv, arb->cuvant) >0 ) /* daca este mai mare se cauta in
subarborele dreapta */
actualizare (arb->dr, cuv);
else /* daca s-a determinat ca exista cuvantul in arbore, se
actualizeaza numarul de aparitii */
arb->nrap=arb->nrap + 1;
void tiparire_arbore (struct st_arbore *arbo)
/* functia afiseaza arborele de cautare ce contine cuvinte si
numarul lor de aparitii */
if (arbo!=NULL)
tiparire_arbore (arbo->st) ; /* tiparire arbore stanga */
printf ("%s (ap: %d)\n", arbo -> cuvant, arbo -> nrap ) ;
nle++;
if (nle%24==0){
printf("Apasati o tasta pentru a continua afisarea!\n");
getch();
}
tiparire_arbore (arbo->dr) ; /* tiparire arbore dreapta */
void main ()
{struct st_arbore *arb=NULL ;
char cuvant[LUNGMAX] ;
clrscr();
printf("Introduceti cuvinte, care vor fi apoi tiparite in ordine"
" alfabetica:\n");
gets(cuvant) ;
while (strcmp(cuvant, ""))
{actualizare (arb, strdup(cuvant));
gets(cuvant);
tiparire_arbore (arb);
6
/* coadacuv.c - programul construieste o coada de cuvinte,
pe care o afiseaza, la terminarea introducerii de cuvinte,
cu eliberarea spatiului alocat pentru aceasta structura */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMCV 25
struct st_cuvant
char *cuvant; /* pointer la sirul de caractere (cuvant) */
struct st_cuvant *urmator;
};
int ncl=0; /* numar de cuvinte afisate pe linie */
struct st_cuvant * atasare_coada (struct st_cuvant *ultim, char *sirc)
struct st_cuvant *vr;
vr=(struct st_cuvant *) malloc(sizeof(struct st_cuvant));
if (vr) /* daca s-a putut crea un pointer se continua atasarea */
vr->cuvant=strdup(sirc);
vr->urmator=NULL;
ultim->urmator=vr;
return (vr);
void extragere ( struct st_cuvant * primu)
struct st_cuvant *ptr;
while (primu)
{ptr=primu; /* memorat pentru a elibera spatiul referit de el */
printf (" %s -> ", primu->cuvant);
ncl++;
if (ncl%5==0)
printf("\n");
primu=primu->urmator;
free(ptr); /* eliberarea spatiului alocat pointerului */
printf ("NULL\n");/* sfarsit lista sau lista vida daca primu == NULL */
void main()
struct st_cuvant *primul, *ultimul;
char cuv[DIMCV];
clrscr();
printf("Programul construieste o lista de tip coada cu cuvinte de la"
" tastatura\n");
printf("Programul ia sfarsit cu un cuvant vid, adica RETURN,"
" la inceput de linie.\n");
printf("Cuvant de introdus in lista:");
gets(cuv);
primul=(struct st_cuvant *) malloc(sizeof(struct st_cuvant));
primul->cuvant=strdup(cuv);
primul->urmator=NULL;
ultimul=primul;
gets(cuv);
while (strcmp(cuv, SIR_VID))

{
if(!(ultimul=atasare_coada (ultimul, cuv)))
break;
gets(cuv);
extragere (primul);
7
/* coadatab.c - operatii cu o coada realizata static intr-un tablou;
operatii disponibile: inserare, extragere, afisare cap coada,
afisare coada, afisare pozitii referinte la primul si ultimul
element din coada */
#include <stdio.h>
#include <conio.h>
#define MaxC 10
typedef int ElTip; // ElTip - definire tip element din coada
typedef struct {
ElTip elem [MaxC];// spatiu pentru elem. cozii
int prim, ultim;
/* indecsi/ referinte la primul/ ultimul element din coada */
} TCoada, *ACoada;
void eroare (char *meserr){
printf("%s\n", meserr);
int IncIndexC (int i){ /* increment index element curent coada */
return ((i+1) % MaxC);
void InitCoada (ACoada pc){
/* initializare coada, referintele prim si ultim */
pc->prim=0;
pc->ultim=MaxC-1;
int CoadaGoala (ACoada pc){
/* coada este goala: index (ultim+1) == index (prim)
coada goala: x x x x u p x x x x ,
daca p si u ocupa aceeasi pozitie coada are un singur element:
x x x x x p(u) x x x x , p si u au aceeasi valoare */
return (IncIndexC (pc->ultim) == pc->prim);

}
int CoadaPlina (ACoada pc){
/* coada este plina: index (ultim+2) == index (prim)
coada goala: x x x u - p x x x x , pozitia - nu este element in coada*/
return (IncIndexC (IncIndexC(pc->ultim)) == pc->prim);
void AdaugElC (ACoada pc, ElTip el){
if (IncIndexC (IncIndexC(pc->ultim)) == pc->prim)
eroare ("Coada Plina !!!");
else {pc->ultim=IncIndexC(pc->ultim);
pc->elem[pc->ultim]=el;
ElTip ScotElC (ACoada pc){
ElTip e;
if (CoadaGoala (pc))
{eroare ("Coada Goala !!!");
return 0;
else
{e=pc->elem[pc->prim];
pc->prim=IncIndexC(pc->prim);
return e;
}
ElTip CapCoada (ACoada pc){
return 0;
else
return pc->elem[pc->prim];
void AfisareCoada (ACoada pc){
/* se creaza o copie a cozii curente, pentru a utiliza functiile
definite pentru operare coada (ScotElC, CapCoada, CoadaGoala) */
TCoada c=*pc;
ACoada pt=&c;
int nvl=0; /* Numar de valori afisate pe linie */
if (CoadaGoala(pt))
eroare("Coada Goala !!!\n");
else
while (!CoadaGoala (pt))
{printf ("%d -> ", CapCoada (pt));
ScotElC (pt);
if (++nvl % 10 == 0)
printf("\n");
printf("NULL\n");
void Afisare_Poz_Prim_Ultim (ACoada pc){
printf("Cei doi indecsi (referinte), prim si ultim: %d(p), %d(u)\n",

pc->prim, pc->ultim);
void main (void){
TCoada c, *pc;
char optiune[20];
ElTip n;
clrscr();
printf("Exemplu de coada realizata utilizand un tablou.\n");
printf("Coada este alcatuita din numere intregi.\n");
InitCoada (pc);
printf("\nOptiuni Int, Ext, Afis coada, Cap coada, Poz p/u, Stop: ");
gets(optiune);
while (optiune[0] != '\0' && optiune[0] != 's' && optiune[0] != 'S'){
switch(optiune[0]){
case 'i':
case 'I':if (CoadaPlina(pc)){
eroare("\n\tCOADA PLINA !!! ELIMINATI...\n");
break;}
printf("Introd. nr. (CTRL-Z, Enter-Stop Introd): ");
while (scanf("%d", &n) == 1){
AdaugElC (pc, n);
if (CoadaPlina (pc)){
eroare("Coada PLINA !!! ELIMINATI.....\n");
break;
fflush(stdin);
break;
case 'e':
case 'E': optiune[0]='D';
while ( !CoadaGoala (pc) &&
(optiune[0] == 'D' || optiune[0] == 'd') )
{printf ("Se extrage primul element din coada: %d\n",
CapCoada (pc));
ScotElC (pc);
if (!CoadaGoala (pc)){
printf("Continuati extragerea (Da/Nu): ");
gets(optiune);
fflush(stdin);
printf("Coada Goala !!! INTRODUCETI ELEMENTE \n");
break;
case 'c':
case 'C': if (!CoadaGoala (pc))
printf("Afisare element din capul cozii: %d\n",
CapCoada (pc));
else
break;
case 'a':
case 'A':AfisareCoada (pc);
break;
case 'p':
case 'P': Afisare_Poz_Prim_Ultim (pc);

break;
gets(optiune);
8
/* coadatbv.c - operatii cu o coada realizata static intr-un tablou;
operatii disponibile: inserare, extragere, afisare cap coada,
afisare coada, afisare pozitii referinte la primul si ultimul
element din coada
Varianta: pentru afisare nu se creaza o copie a cozii, ci se
utilizeaza doi indecsi locali in functia Afisare CoadaV (pc) */

#include <stdio.h>
#include <conio.h>
#define MaxC 10
typedef int ElTip; // ElTip - definire tip element din coada
typedef struct {
ElTip elem [MaxC];// spatiu pentru elem. cozii
int prim, ultim;
/* indecsi/ referinte la primul/ ultimul element din coada */
} TCoada, *ACoada;
int IncIndexC (int i){ /* increment index element curent coada */
return ((i+1) % MaxC);
void InitCoada (ACoada pc){
/* initializare coada, referintele prim si ultim */
pc->prim=0;
pc->ultim=MaxC-1;
int CoadaGoala (ACoada pc){
/* coada este goala: index (ultim+1) == index (prim)
coada goala: x x x x u p x x x x ,
daca p si u ocupa aceeasi pozitie coada are un singur element:

x x x x x p(u) x x x x , p si u au aceeasi valoare */
return (IncIndexC (pc->ultim) == pc->prim);
int CoadaPlina (ACoada pc){
/* coada este plina: index (ultim+2) == index (prim)
coada goala: x x x u - p x x x x , pozitia - nu este element in coada*/
return (IncIndexC (IncIndexC(pc->ultim)) == pc->prim);
void AdaugElC (ACoada pc, ElTip el){
if (IncIndexC (IncIndexC(pc->ultim)) == pc->prim)
eroare ("Coada Plina !!!");
else {pc->ultim=IncIndexC(pc->ultim);
pc->elem[pc->ultim]=el;
ElTip ScotElC (ACoada pc){
ElTip e;
return 0;
else
{e=pc->elem[pc->prim];
pc->prim=IncIndexC(pc->prim);
return e;
}
}
ElTip CapCoada (ACoada pc){
return 0;
else
return pc->elem[pc->prim];
void AfisareCoadaV (ACoada pc){
/* se parcurge coada cu doi indecsi locali, copii ai celor din coada */
int pp, pu; /* indecsi la primul si ultimul din coada */
pp=pc->prim;
pu=pc->ultim;
if (CoadaGoala(pc))
else
while ((pu+1) != pp) /* conditie de coada goala */
{printf ("%d -> ", pc->elem[pp]);
pp++;
if (++nvl % 10 == 0)
printf("\n");
printf("NULL\n");
}
void Afisare_Poz_Prim_Ultim (ACoada pc){
printf("Cei doi indecsi (referinte), prim si ultim: %d(p), %d(u)\n",
pc->prim, pc->ultim);
void main (void){
TCoada c, *pc;
char optiune[20];
ElTip n;
clrscr();
printf("Exemplu de coada realizata utilizand un tablou.\n");
printf("Coada este alcatuita din numere intregi.\n");
InitCoada (pc);
gets(optiune);
switch(optiune[0]){
case 'i':
case 'I':if (CoadaPlina(pc)){
eroare("\n\tCOADA PLINA !!! ELIMINATI...\n");
break;}
while (scanf("%d", &n) == 1){
AdaugElC (pc, n);
if (CoadaPlina (pc)){
eroare("Coada PLINA !!! ELIMINATI.....\n");
break;

}
fflush(stdin);
break;
case 'e':
while ( !CoadaGoala (pc) &&
{printf ("Se extrage primul element din coada: %d\n",
CapCoada (pc));
ScotElC (pc);
if (!CoadaGoala (pc)){
gets(optiune);
fflush(stdin);
printf("Coada Goala !!! INTRODUCETI ELEMENTE \n");
break;
case 'c':
case 'C': if (!CoadaGoala (pc))
printf("Afisare element din capul cozii: %d\n",
CapCoada (pc));
else
break;
case 'a':
case 'A':AfisareCoadaV (pc);
break;
case 'p':
case 'P': Afisare_Poz_Prim_Ultim (pc);
break;
gets(optiune);
9
/* coadvcuv.c - programul construieste o coada de cuvinte,
pe care o afiseaza, la terminarea introducerii de cuvinte,
cu eliberarea spatiului alocat pentru aceasta structura;
varianta citeste in ciclu si primul cuvant introdus */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""

#define DIMCV 25
struct st_cuvant
};
int ncl=0; /* numar de cuvinte afisate pe linie */
struct st_cuvant * atasare_coada (struct st_cuvant *ultim, char *sirc)
struct st_cuvant *vr;
vr=(struct st_cuvant *) malloc(sizeof(struct st_cuvant));
if (vr) /* daca s-a putut crea un pointer se continua atasarea */
vr->cuvant=strdup(sirc);
vr->urmator=NULL;
ultim->urmator=vr;
return (vr);
void extragere ( struct st_cuvant * primu)
struct st_cuvant *ptr;
while (primu)
{ptr=primu; /* memorat pentru a elibera spatiul referit de el */
printf (" %s -> ", primu->cuvant);
ncl++;
if (ncl%5==0)
printf("\n");
primu=primu->urmator;
free(ptr); /* eliberarea spatiului alocat pointerului */
printf ("NULL\n");/* sfarsit lista sau lista vida daca primu == NULL */
void main()
struct st_cuvant *primul, *ultimul;
char cuv[DIMCV];
clrscr();
" tastatura\n");
gets(cuv);
primul=ultimul=NULL;
while (strcmp(cuv, SIR_VID))
if(!(ultimul=atasare_coada (ultimul, cuv)))
break;
if (!primul)
primul=ultimul;
gets(cuv);
extragere (primul);
}
10
/* constiva.cpp - prog. construieste o stiva de numere intregi, distincte,
pe care o afiseaza, utilizand functiile: adauga_stiva si afisare_stiva */
/*
Alte probleme propuse:
- construirea unei liste ordonate de numere;
- organizarea unui dictionar de cuvinte, ca o lista inlantuita. */
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
struct s_stiva
int valoare;
int nr_aparitii; /* numarul de aparitii ale numarului in stiva */
struct s_stiva *urmator;
};
struct s_stiva *adauga_stiva (struct s_stiva *ultimul, int val)
/*Functia returneaza un pointer la ultimul element din stiva daca s-a putut
adauga un nou element, sau NULL daca nu s-a adaugat ("Memorie plina!") */
struct s_stiva *ptr_stiva;
if (ultimul==NULL)
ultimul=(struct s_stiva *) malloc(sizeof(struct s_stiva));
if (ultimul==NULL)
{printf("Memorie plina!\n");
return(NULL);
else
ultimul->valoare=val;
ultimul->nr_aparitii=1;
ultimul->urmator=NULL;
return(ultimul);
else
{
ptr_stiva=ultimul; /* se cauta daca exista valoarea */
while(ptr_stiva->valoare!=val && ptr_stiva->urmator!=NULL)
ptr_stiva=ptr_stiva->urmator;
if(ptr_stiva->valoare==val)
{ptr_stiva->nr_aparitii++;
return(ultimul);
else
{ptr_stiva=(struct s_stiva *)malloc(sizeof(struct s_stiva));
if (ptr_stiva==NULL)
{printf("Mmeorie plina!\n");
return(NULL);
else
{ptr_stiva->valoare=val;
ptr_stiva->nr_aparitii=1;
ptr_stiva->urmator=ultimul;
return(ptr_stiva);
void afisare_stiva(struct s_stiva *ultim)
int nr_val_linie = 0;
while (ultim!=NULL)
{
printf("%2d(%d)-> ", ultim->valoare, ultim->nr_aparitii);
ultim=ultim->urmator;
nr_val_linie++; /* contor pentru nr. de valori afisate pe linie */
if (nr_val_linie%8==0)
printf("\n");
printf ("\n");
void eliberare_spatiu (struct s_stiva *ptrs){
struct s_stiva *p=ptrs;
while(p){ptrs=p;
p=p->urmator;
free(ptrs);
void main()
struct s_stiva *ultim=NULL;
int numar;
clrscr();
printf("Prg. construieste si afiseaza o stiva de nr. intregi, distincte.\n");
printf("Introducerea se termina cu EOF(CTRL-Z, ENTER.\n");
printf("Introduceti numar: ");
while(scanf("%d", &numar)!=EOF)
{if((ultim=adauga_stiva(ultim, numar))==NULL)
break;

}
afisare_stiva(ultim);
eliberare_spatiu(ultim);
11
/* constivr.cpp - programul construieste o coada de numere intregi, pe care
o afiseaza, utilizand functii recursive: adaug_coada, afisez_coada */
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
struct s_coada
int valoare;
struct s_coada *urmator;
};
int nr_val_linie=0; /* contor pentru nr. de valori afisate pe linie */
void adaug_coada (struct s_coada *primul, int val)
/*Functia returneaza un pointer la primul element din coada daca s-a putut
adauga un nou element, sau NULL daca nu s-a adaugat ("Memorie plina!") */
if (primul->urmator==NULL){
primul->urmator=(struct s_coada *)malloc(sizeof(struct s_coada));
if(!primul->urmator)
{printf("Memorie plina!!!\n");
exit(1);
primul=primul->urmator;
primul->valoare=val;
else
adaug_coada(primul->urmator, val);
void afisez_coada(struct s_coada *primul)
if (primul)
printf("%2d-> ", primul->valoare);
nr_val_linie++;
if (nr_val_linie%8==0)
printf("\n");
afisez_coada(primul->urmator);
}
void eliberare_spatiu (struct s_coada *ptrs){
struct s_coada *p=ptrs;
if(p){ ptrs=p;
p=p->urmator;
free(ptrs);
eliberare_spatiu(p);
void main()
struct s_coada *prim=NULL;
int numar;
clrscr();
printf("Prg. construieste si afiseaza o coada de nr. intregi, distincte.\n");
printf("Introducerea se termina cu EOF(CTRL-Z, ENTER.\n");
scanf("%d", &numar);
prim=(struct s_coada *)malloc(sizeof(struct s_coada));
if(!prim)
{printf("Memorie plina!!!\n");
exit(1);
prim->valoare=numar;
prim->urmator=NULL;

while(scanf("%d", &numar)!=EOF)
{adaug_coada(prim, numar);
afisez_coada(prim);
printf("NULL\n");
eliberare_spatiu(prim);
12
/* echi_arb.cpp - programul construieste un arbore - utilizand o functie:
constr_arbore, si determina daca o anumita valoare exista in arbore,
folosind functia caut_val, care returneaza un pointer la elementul
respectiv
Programul determina si daca acest arbore este echilibrat sau nu: diferenta
de inaltimi intre ramura cea mai lunga si cea mai scurta este <=1.
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct s_arbore
{
int valoare;// valoarea asociata nodului
int nr_ap; // numarul de aparitii
struct s_arbore *stg;
struct s_arbore *dr;
};
int maxy = 1;
struct s_arbore *constr_arbore (void)
struct s_arbore *pelem, * parb;
int numar, gasit_poz_ins; // gasit pozitia de inserare
parb = NULL;
printf ("Valorile intregi de introdus in arbore:\n");
printf ("Valoare = ");
scanf ("%d", &numar);
while (numar)
if (parb == NULL)
parb = (struct s_arbore *) malloc(sizeof(struct s_arbore));
parb -> valoare = numar;
parb -> nr_ap = 1;
parb -> stg = NULL;
parb -> dr = NULL;
else
{gasit_poz_ins = 0;
pelem = parb;
while (pelem != NULL && !gasit_poz_ins)
if (numar == pelem->valoare)
{pelem->nr_ap++; break;}
else if(numar < pelem->valoare)
if (pelem->stg)
pelem = pelem->stg;
else
{gasit_poz_ins = 1;
pelem->stg=(struct s_arbore *)
malloc (sizeof(struct s_arbore));
pelem = pelem->stg;
else
if (pelem->dr)
pelem = pelem->dr;
else
{gasit_poz_ins = 1;
pelem->dr=(struct s_arbore *)
pelem = pelem->dr;
if (pelem == NULL)/* daca nu mai e spatiu -> exit */
exit(0);
if (gasit_poz_ins)
{pelem->valoare = numar;
pelem->nr_ap = 1;
pelem-> stg = NULL;
pelem-> dr = NULL;
}
}
printf ("Valoare = ");
return ( parb );
void display_arbore (struct s_arbore *start, int pas, int p_x, int p_y)
if ( start != NULL )
display_arbore (start->stg, pas/2, p_x-pas/2, p_y+2);
gotoxy (p_x, p_y);
printf ("(%d,%d)", start->valoare, start->nr_ap);
gotoxy (wherex()-7, p_y+1);
printf("/ \\");
if (wherey() > maxy)
maxy = wherey();
display_arbore (start->dr, pas/2, p_x+pas/2, p_y+2);
struct s_arbore *caut_val (struct s_arbore *p_arb, int numar_cautat,
int *p_nivel)
while (p_arb != NULL)
(*p_nivel)++;
if (p_arb ->valoare == numar_cautat)

return (p_arb);
else if (numar_cautat < p_arb->valoare)
p_arb = p_arb->stg;
else
p_arb = p_arb->dr;
return (0);
};
int maxim (int a, int b) {
if (a > b)
return (a);
return (b);
int inalt (s_arbore *parb){
int l;
if (parb == NULL)
l = 0;
else
l = maxim(inalt(parb->stg), inalt(parb->dr)) + 1;
return l;
int minim (int a, int b) {
if (a < b)
return (a);
return (b);
}
int inalt_min (s_arbore *parb){
int i;
if (parb == NULL)
i=0;
else
i= minim(inalt_min(parb->stg), inalt_min(parb->dr)) + 1;
return i;
void main (void)
struct s_arbore *constr_arbore();
void display_arbore (struct s_arbore *start, int p_niv, int p_x, int p_y);
struct s_arbore *caut_val (struct s_arbore *p_arb, int numar_cautat,
int *p_pozitie);
struct s_arbore *start_arb, * ptr_valoare;
int *nivel, val_cautata, niv, x, y;
char *pcuv;
clrscr();
start_arb = constr_arbore();
niv = 40; x = 37; y = 1;
printf("Pentru afisare arbore apasati o tasta.\n");
getch();
clrscr();
display_arbore (start_arb, niv, x, y);
if ( start_arb == NULL )
printf ("Arbore vid de valori.\n");
else
{
gotoxy(1,maxy+1);
pcuv = "";
printf("inalt = %d, inalt_min = %d\n", inalt(start_arb), inalt_min(start_arb));
if (inalt(start_arb)-inalt_min(start_arb) > 1)
pcuv = "nu";
printf("Arborele %s este echilibrat.\n", pcuv);
printf ("Valoarea de cautat in arbore :");
scanf ("%d", &val_cautata);
*nivel = 0;
ptr_valoare = caut_val(start_arb, val_cautata, nivel);
if (ptr_valoare != NULL)
printf ("Valoarea: %d, este in arbore pe nivelul: %d\n",
ptr_valoare -> valoare, *nivel);
else
printf ("Valoarea %d nu este in arbore.\n", val_cautata);
printf("Apasati o tasta pentru a termina programul.\n");
getch();
}
13
/* frunzarb.cpp - Programul construieste un arbore, apeland o functie
pentru construirea unui arbore, dupa care determina numarul de noduri si
numarul de frunze, adica nodurile care nu au nici un descendent.
Programul mai determina si 'latimea' maxima a arborelui, adica
nivelul pe care sunt cele mai multe noduri sau frunze
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define DIM_MAX 100
struct s_arbore
int valoare;// valoarea asociata nodului
int nr_ap; // numarul de aparitii

struct s_arbore *stg;
struct s_arbore *dr;
};
int maxy = 1;
int nr_nod[10], niv=0, max_niv=0;
int nr_frunze=0;
struct s_arbore *constr_arbore (void)
struct s_arbore *pelem, * parb;
int numar, gasit_poz_ins, ind=1; // gasit pozitia de inserare
parb = NULL;
printf ("Valorile intregi de introdus in arbore:\n");
printf ("Valoare(%d)= ", ind++);
while (numar)
if (parb == NULL)
parb = (struct s_arbore *) malloc(sizeof(struct s_arbore));
parb -> valoare = numar;
parb -> nr_ap = 1;
parb -> stg = NULL;
parb -> dr = NULL;
else
{gasit_poz_ins = 0;
pelem = parb;
while (pelem != NULL && !gasit_poz_ins)
if (numar == pelem->valoare)
{pelem->nr_ap++; break;}
else if(numar < pelem->valoare)
if (pelem->stg)
pelem = pelem->stg;
else
{gasit_poz_ins = 1;
pelem->stg=(struct s_arbore *)
pelem = pelem->stg;
else
if (pelem->dr)
pelem = pelem->dr;
else
{gasit_poz_ins = 1;
pelem->dr=(struct s_arbore *)
pelem = pelem->dr;
if (pelem == NULL)/* daca nu mai e spatiu -> exit */
exit(0);
if (gasit_poz_ins)
{pelem->valoare = numar;
pelem->nr_ap = 1;
pelem-> stg = NULL;
pelem-> dr = NULL;
}
}
printf ("Valoare(%d)= ", ind++);
return ( parb );
void display_arbore (struct s_arbore *start, int pas, int p_x, int p_y)
{int p;
if ( start != NULL )
{p=p_x-pas/2;
if (p<1)
p=1;
display_arbore (start->stg, pas/2, p, p_y+2);
gotoxy (p_x, p_y);
printf ("(%d,%d)", start->valoare, start->nr_ap);
p=wherex()-7;
if (p<1)
p=1;
gotoxy (p, p_y+1);
printf("/ \\");
if (wherey() > maxy)
maxy = wherey();
p=p_x+pas/2;
if (p>73)
p=73;
display_arbore (start->dr, pas/2, p, p_y+2);
}
int nr_nod_arb (struct s_arbore *a) {
// determina numarul de noduri din arbore
int nr_nod;
if (a==NULL)
nr_nod = 0;
else
nr_nod = nr_nod_arb(a->stg) + nr_nod_arb(a->dr) + 1;
return (nr_nod);
void nr_frunze_arb (struct s_arbore *a) {
// determina numarul de frunze (noduri fara nici un descendent)
if (a) {
if (!(a->stg) && !(a->dr))
{nr_frunze++;
printf(" %d ", a->valoare);}
nr_frunze_arb(a->stg);
nr_frunze_arb(a->dr);
void max_nod (struct s_arbore *a){ // nivelul ce contine maxim noduri
if (a)
{niv++;
max_niv=niv;
nr_nod[niv]++;
if (a->stg){
max_nod(a->stg);
niv--;}
if (a->dr){
max_nod(a->dr);
niv--;}
void main (void)
struct s_arbore *arb;
int dim, x, y, i, max_noduri=0, i_max=0;
for (i=0;i<10;i++)
nr_nod[i]=0;
clrscr();
arb = constr_arbore();
dim = 40; x = 37; y = 1;
printf("Pentru afisarea primului arbore apasati o tasta.\n");
getch();
clrscr();
display_arbore (arb, dim, x, y);
gotoxy(1, maxy+1);
printf("Numarare de noduri din arbore. Apasati o tasta!\n");
getch();
printf("\nNmuar de noduri: %d\n", nr_nod_arb(arb));
printf("Frunzele din arbore sunt :\n\t");
nr_frunze_arb(arb);
printf("\nNmuar de frunze: %d\n", nr_frunze);
max_nod(arb);
for (i=0; i<=max_niv; i++)

if (max_noduri<nr_nod[i])
{i_max = i;
max_noduri=nr_nod[i];
printf("Nivelul %d contine numarul maxim de noduri (frunze) %d\n",
i_max,nr_nod[i_max]);
printf("\nApasati o tasta pentru a termina programul!!!!\n");
getch();
14
/* listcirc.c - programul construieste o lista circulara de caractere,
pe care apoi o tipareste, si in care se cauta un anumit caracter */
#include <stdio.h>
struct st_litera
char car;
struct st_litera * pred, *urm;
};
int ncl=0; /* numar de caractere afisate pe linie */
void atasare(struct st_litera *pl){
char c;
struct st_litera *vr;
while ((c=getchar()) != EOF)
if (c!='\n')
{vr=(struct st_litera *) malloc(sizeof(struct st_litera));
if (vr == NULL)
{ /* daca pointerul returnat de functia malloc() este
NULL */
printf("Memorie plina !!!!!!\n"); /* se tipareste un
mesaj de eroare */
break; /* si se termina executia ciclului de citire

caractere */
vr->car=c;
if(pl->pred==pl) /* lista vida? */
{vr->pred=vr->urm=pl;
pl->urm=pl->pred=vr;
else {vr->urm=pl;
vr->pred=pl->pred;
pl->pred->urm=vr;
pl->pred=vr;
void afis_list_circ (struct st_litera *plc){
struct st_litera *p;
p=plc->urm;
while (p != plc)
{printf("%c -> ", p->car);
p=p->urm;
ncl++;
if (ncl%10==0) /* s-au afisat 10 caractere pe linie ? */
printf("\n");
if (plc->urm!=plc)
printf("%c (primul).\n", plc->urm->car);/* tiparire primul caracter sau
NULL daca lista este vida */
else
printf("NULL");
int numar_aparitii_car (struct st_litera *start, char *pcar)
int numar = 0;
struct st_litera *curent; /* pointerul cu care se parcurge lista */
*pcar=start->car; /* se transmite prin adresa primita, caracterul cautat */
curent=start->urm;
while (curent != start) /* cat timp referinta la urmatorul din lista */
{ /* nu a ajuns la santinela/ start */
if (start->car == curent->car) /* se numara daca este caracterul */
numar++;
curent=curent->urm;
return (numar);
void main()
struct st_litera *primul;
char ch;
primul->urm=primul->pred=primul; /* lista vida */
printf("\nProgramul construieste si afiseaza o lista circulara de char.\n");
printf("Introduceti caractere (CTRL-Z, Enter-pentru sfarsit):\n");

atasare(primul);
printf("\nLista circulara construita este:\n");
afis_list_circ(primul);
printf("Caracterul de cautat in lista: ");
ch=getch();
primul->car=ch; /* se pune caracterul de cautat in santinela/ start */
printf("\nCaracterul \'%c\' este in lista de %d ori\n",
ch, numar_aparitii_car(primul, &ch));
15
/*
listfrec.cpp - programul construieste, apoi tipareste, o lista de intregi,
de tip coada, utilizand functiile recursive: 'adaugare' si 'listare'
*/
#include <stdio.h>
#include <stdlib.h>
struct tnod
int valoare;
struct tnod *urmator;
};
void adaugare (tnod * &v, int val){
tnod *sf;
if (!v)
{v = new tnod; v->valoare=val; v->urmator=NULL;}
else
adaugare (v->urmator, val);
}
void listare (tnod *v){
if (v)
{printf("%d->", v->valoare);
listare (v->urmator);
main()
struct tnod *pl;
int valoare;
pl = NULL;
printf ("Introduceti un sir de valori, terminat cu 0.\n");
while ( valoare ) {
adaugare (pl,valoare);
/* afisare lista */
listare (pl);
printf ("NULL\n");
}
16
/* listord.c - construiete o lista ordonata de numere intregi, distincte */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct st_numar {
int numar;
struct st_numar *next;
};
int nvl=0; /* numarul de valori afisate pe linie */
void main()
struct st_numar *inserare (struct st_numar *, int );
struct st_numar *prim, *vr;
int nr;
clrscr();
printf("Programul construieste o lista ordonata, de numere distincte.\n");
printf("Introducerea numerelor se termina cu o valoare nenumerica.\n");
printf("Numar de inserat in lista: ");
prim=(struct st_numar *) malloc(sizeof (struct st_numar));
scanf("%d", &prim->numar); /* citire numar de introdus in lista */

prim->next=NULL;
while (scanf("%d", &nr)==1){
prim=inserare (prim, nr);
/* tiparirea listei introduse cu eliberarea memoriei alocate */
printf("\nLista de numere ordonata este:\n");
while (prim)
{vr=prim; /* variabila auxiliara pentru a apela functia free() */
printf("%d -> ", vr->numar);
nvl++;
if (nvl%8==0) /* daca s-au tiparit 8 valori pe linie */
printf("\n"); /* se trece pe o linie noua */
prim=prim->next;
free(vr); /* eliberare memorie alocata pentru vr */
printf("NULL\n"); /* tiparire sfarsit de lista */
struct st_numar *inserare (struct st_numar *primul, int n){
/* daca nu se mai poate aloca memorie se rutrneaza poiterul NULL,
altfel se returneaza pointerul la primul numar din lista,
care se poate modifica daca se insereaza un numar mai mic
decat primul din lista */
struct st_numar *anterior, *curent, *vr;
vr=(struct st_numar *) malloc(sizeof(struct st_numar));
if (vr == NULL){
printf("\nNu mai introduceti numere!!!\nMEMORIE PLINA!!!\n");

return (primul);
else
vr->numar=n;
anterior=NULL; /* initializare pointeri 'anterior' si 'curent' */
curent=primul; /* pentru det. pozitie element de inserat, vr */
while (curent != NULL && vr->numar > curent->numar)
anterior=curent;
curent=curent->next;
} /* vr trebuie inserat intre anterior si curent */
if(vr->numar == curent->numar) /* daca numarul exista in lista */
{free(vr); /* elibereaza spatiul alocat variabilei 'vr' */
return (primul); /* nu mai insereaza si termina inserarea */
vr->next=curent;
if (anterior == NULL) /* se insereaza in fata primului din lista */
primul=vr; /* este pus primul in lista */
else
anterior->next=vr; /* este pus dupa 'anterior' */
return (primul);
}
17
/* listrec1.cpp - programul construieste o lista de cuvinte, introduse
de la tastatura, pe care apoi le afiseaza, utilizand functii recursive:
atsare - pentru construire lista, si
afisare - pentru afisare lista;
Varianta 2: elementul din lista contine adresa cuvantului citit,
pentru care se aloca spatiu (strdup) la citire;
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMC 25
int nvl=0;
struct st_cuvant
};
int atasare (struct st_cuvant * vr)
{ /* citeste un cuvant, creaza o variabila dinamica vr si o ataseaza
la lista */
char cuv[DIMC], *pc;

if (vr->urmator==NULL) /* daca referinta este NULL se ceaza un pointer */
vr->urmator=(struct st_cuvant *)malloc(sizeof(struct st_cuvant));
if (vr->urmator==NULL)
return (0);
else
gets(cuv);
if (!strcmp(cuv,SIR_VID))
{vr->urmator=NULL;
return(0);
else
{if(!(pc=strdup(cuv)))
{vr->urmator=NULL;
return(0);
else
vr=vr->urmator;
vr->urmator = NULL;
vr->cuvant=pc;
return (1);
else /* daca s-a putut crea un pointer se continua atasarea */
return(atasare (vr->urmator));
}
void afisare (struct st_cuvant * curent)
if (curent)
printf ("%s -> ", curent -> cuvant);
nvl++;
if(nvl%5==0)
printf("\n");
afisare (curent -> urmator);
void main()
struct st_cuvant *primul;
char c[DIMC];
clrscr();
" tastatura\n");
gets(c);
primul->cuvant=strdup(c);
while (atasare(primul));
afisare (primul);
printf("NULL\n");
}
18
/* listrec1.cpp - programul construieste o lista de cuvinte, introduse
de la tastatura, pe care apoi le afiseaza, utilizand functii recursive:
Varianta 2: elementul din lista contine adresa cuvantului citit,
pentru care se aloca spatiu (strdup) la citire;
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMC 25
int nvl=0;
struct st_cuvant
};
int atasare (struct st_cuvant * &vr)
{ /* citeste un cuvant, creaza o variabila dinamica vr si o ataseaza
la lista */
char cuv[DIMC];
if (vr==NULL) /* daca referinta este NULL se ceaza un pointer */
{
vr=(struct st_cuvant *)malloc (sizeof(struct st_cuvant));
if (vr==NULL)
return (0);
else
vr->urmator = NULL;
gets(cuv);
if (!strcmp(cuv,SIR_VID))
{vr=NULL;
return(0);
else
{if(!(vr->cuvant=strdup(cuv)))
{vr=NULL;
return(0);
};
return (1);
atasare (vr->urmator);
if (curent)

nvl++;
if(nvl%5==0)
printf("\n");
void main()
primul = NULL;
clrscr();
" tastatura\n");
afisare (primul);
printf("NULL\n");
}
19
/* listrecc.cpp - programul construieste o lista de cuvinte,
introduse de la tastatura, pe care apoi le afiseaza,
utilizand functii recursive:
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMC 20
int nvl=0;
struct st_cuvant
char cuvant[DIMC]; /* sirul de caractere (cuvant) */
};
int atasare (struct st_cuvant * vr)
{ /* citeste un cuvant, creaza o variabila dinamica vr si o
ataseaza la lista */
char cuvcit[DIMC];
if (vr->urmator==NULL) /* daca referinta este NULL se ceaza un pointer */
vr->urmator=(struct st_cuvant *)malloc(sizeof(struct st_cuvant));
if (vr->urmator==NULL)
return (0);
else
{gets(cuvcit);
if (!strcmp(cuvcit,SIR_VID))
{vr->urmator=NULL;
return(0);
else {
vr=vr->urmator;
vr->urmator=NULL;
strcpy(vr->cuvant, cuvcit);
return (1);
if (curent)
nvl++;
if(nvl%5==0)
printf("\n");
}
void main()
clrscr();
primul=(struct st_cuvant *) malloc(sizeof(struct st_cuvant));
printf("Programul construieste o lista de tip coada cu cuvinte "
"de la tastatura\n");
gets(primul->cuvant);
afisare (primul);
printf("NULL\n");
20
/* listrecc.cpp - programul construieste o lista de cuvinte,
introduse de la tastatura, pe care apoi le afiseaza,
utilizand functii recursive:
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#define SIR_VID ""
#define DIMC 20
int nvl=0;
struct st_cuvant
char cuvant[DIMC]; /* sirul de caractere (cuvant) */
};
int atasare (struct st_cuvant * &vr)
{ /* citeste un cuvant, creaza o variabila dinamica vr si o
ataseaza la lista */
if (vr==NULL) /* daca referinta este NULL se ceaza un pointer */
vr=(struct st_cuvant *) malloc (sizeof(struct st_cuvant));
if (vr==NULL)
return (0);
else
vr->urmator = NULL;
gets(vr->cuvant);
if ( !strcmp(vr->cuvant,SIR_VID) )
{vr=NULL;
return(0);
else
return (1);
if (curent)
nvl++;
if(nvl%5==0)
printf("\n");
void main()
primul = NULL;
clrscr();
printf("Programul construieste o lista de tip coada cu cuvinte "
"de la tastatura\n");
afisare (primul);
printf("NULL\n");
21
/* stivacar.c - programul construieste o stiva de caractere, pe care apoi o tipareste */
#include <stdio.h>
struct st_lista
char car;
struct st_lista *urmator;
};
void main()
struct st_lista *vr, *primul;
char c;
primul = NULL;
printf("\nProgramul construieste si afiseaza o stiva de caractere.\n");
fflush(stdin);
if (c!='\n')
{vr=(struct st_lista *) malloc(sizeof(struct st_lista));
if (vr == NULL)
{ /* daca pointerul returnat de functia malloc() este
NULL */
printf("Memorie plina !!!!!!\n"); /* se tipareste un

mesaj de eroare */

caractere */
vr->car=c;
vr->urmator=primul;
primul=vr;
vr=primul; /* initializare pointer curent, vr, pentru a referi
primul caracter */
while (vr != NULL)
printf("%c -> ", vr->car);
vr=vr->urmator;
printf(" NULL");/* tiparire sfarsit lista caractere sau lista vida daca
primul era NULL */
22
/* stivatab.c - operatii cu o stiva realizata static intr-un tablou;
operatii disponibile: inserare, extragere, afisare cap stiva,
afisare stiva, afisare pointer la varful stivei */
#include <stdio.h>
#include <conio.h>
#define MaxS 10
typedef int ElTip; // ElTip - definire tip element din stiva
typedef struct {
ElTip elem [MaxS];// spatiu pentru elem. stivei
int sp;
/* index/ referinta la varful stivei (stack pointer) */
} TStiva, *AStiva;
void InitStiva (AStiva rs){
/* initializare stiva, sp nu refera un element (stiva goala) */
rs->sp=-1;
int StivaGoala (AStiva rs){
return (rs->sp == -1);
int StivaPlina (AStiva rs){
/* stiva este plina, index=MaxS-1, indice maxim,
nu se mai pot introduce elemente in stiva */
return (rs->sp == MaxS-1);
}
void Push (AStiva rs, ElTip el){
/* introduce element in stiva, daca nu este plina */
if (StivaPlina (rs))
eroare ("Stiva Plina !!!");
else {rs->sp=rs->sp+1;
rs->elem[rs->sp]=el;
ElTip Pop (AStiva rs){
/* extrage element din stiva, daca nu este goala */
ElTip e;
if (StivaGoala (rs))
{eroare ("Stiva Goala !!!");
return 0;
else
{e=rs->elem[rs->sp];
rs->sp=rs->sp-1;
return e;
ElTip CapStiva (AStiva rs){
return 0;
else
return rs->elem[rs->sp];
void AfisareStiva (AStiva rs){
/* se creaza o copie a stivei curente, pentru a utiliza functiile
definite pentru operare stiva (Pop, CapStiva, StivaGoala) */
TStiva s=*rs;
AStiva pt=&s;
if (pt->sp == -1)
eroare("Stiva Goala !!!\n");
else
while (!StivaGoala (pt))
{printf ("%d -> ", CapStiva (pt));
Pop (pt);
if (++nvl % 10 == 0)
printf("\n");
printf("NULL\n");
void Afisare_Poz_sp (AStiva rs){
printf("Referinta (indexul), sp: %d\n", rs->sp);
if (!rs->sp)
printf("\tSTIVA GOALA!!!\n");
else if (rs->sp == MaxS-1)
printf("\tSTIVA PLINA !!! ELIMINATI ...\n");
}
void main (void){
TStiva s, *rs;
char optiune[20];
ElTip n;
clrscr();
printf("Exemplu de stiva realizata utilizand un tablou.\n");
printf("Stiva este alcatuita din numere intregi.\n");
InitStiva (rs);
printf("\nOptiuni Introduc, Extrag, Afis stiva, Cap stiva, Poz sp, Stop: ");
gets(optiune);
switch(optiune[0]){
case 'i':
case 'I':if (StivaPlina(rs)){
eroare("\n\tSTIVA PLINA !!! ELIMINATI...\n");
break;}
while (scanf("%d", &n) == 1 && !StivaPlina(rs)){
Push (rs, n);
if (StivaPlina (rs)){
eroare("Stiva PLINA !!! ELIMINATI.....\n");
break;
fflush(stdin);
break;
case 'e':

while ( !StivaGoala (rs) &&
{printf ("Se extrage primul element din stiva: %d\n",
CapStiva (rs));
Pop (rs);
if (!StivaGoala (rs)){
gets(optiune);
fflush(stdin);
printf("Stiva Goala !!! INTRODUCETI ELEMENTE \n");
break;
case 'c':
case 'C': if (!StivaGoala (rs))
printf("Afisare element din capul stivei: %d\n",
CapStiva (rs));
else
break;
case 'a':
case 'A':AfisareStiva (rs);
break;
case 'p':
case 'P': Afisare_Poz_sp (rs);
break;
printf("\nOptiuni Int, Ext, Afis stiva, Cap stiva, Poz sp, Stop: ");
gets(optiune);
23
/* stivatbv.c - operatii cu o stiva realizata static intr-un tablou;
operatii disponibile: inserare, extragere, afisare cap stiva,
afisare stiva, afisare pointer la varful stivei
Varianta: functia de afisare AfisareStivaV (rs), nu mai creaza o copie
a stivei, si deci nu mai utilizeaza functiile stivei, ci un index local */
#include <stdio.h>
#include <conio.h>
#define MaxS 10
typedef int ElTip; // ElTip - definire tip element din stiva
typedef struct {
ElTip elem [MaxS];// spatiu pentru elem. stivei
int sp;
/* index/ referinta la varful stivei (stack pointer) */
} TStiva, *AStiva;
void InitStiva (AStiva rs){
/* initializare stiva, sp nu refera un element (stiva goala) */
rs->sp=-1;
int StivaGoala (AStiva rs){
return (rs->sp == -1);
int StivaPlina (AStiva rs){
/* stiva este plina, index=MaxS-1, indice maxim,
nu se mai pot introduce elemente in stiva */
return (rs->sp == MaxS-1);
}
void Push (AStiva rs, ElTip el){
/* introduce element in stiva, daca nu este plina */
if (StivaPlina (rs))
eroare ("Stiva Plina !!!");
else {rs->sp=rs->sp+1;
rs->elem[rs->sp]=el;
ElTip Pop (AStiva rs){
/* extrage element din stiva, daca nu este goala */
ElTip e;
return 0;
else
{e=rs->elem[rs->sp];
rs->sp=rs->sp-1;
return e;
ElTip CapStiva (AStiva rs){
return 0;
else
return rs->elem[rs->sp];
void AfisareStivaV (AStiva rs){
/* se utilizeaza un pointer local pentru a afisa valorile din stiva */
int psl=rs->sp;
if (rs->sp == -1)
else
while (psl != -1)
{printf ("%d -> ", rs->elem[psl]);
psl--;
if (++nvl % 10 == 0)
printf("\n");
printf("NULL\n");
void Afisare_Poz_sp (AStiva rs){
printf("Referinta (indexul), sp: %d\n", rs->sp);
if (!rs->sp)
printf("\tSTIVA GOALA!!!\n");
else if (rs->sp == MaxS-1)
printf("\tSTIVA PLINA !!! ELIMINATI ...\n");
void main (void){
TStiva s, *rs;
char optiune[20];
ElTip n;
clrscr();
printf("Exemplu de stiva realizata utilizand un tablou.\n");
printf("Stiva este alcatuita din numere intregi.\n");
InitStiva (rs);
printf("\nOptiuni Introduc, Extrag, Afis stiva, Cap stiva, Poz sp Stop: ");
gets(optiune);
switch(optiune[0]){
case 'i':
case 'I':if (StivaPlina(rs)){
eroare("\n\tSTIVA PLINA !!! ELIMINATI...\n");
break;}
while (scanf("%d", &n) == 1 && !StivaPlina(rs)){
Push (rs, n);
if (StivaPlina (rs)){
eroare("Stiva PLINA !!! ELIMINATI.....\n");
break;
fflush(stdin);
break;
case 'e':
while ( !StivaGoala (rs) &&

{printf ("Se extrage primul element din stiva: %d\n",
CapStiva (rs));
Pop (rs);
if (!StivaGoala (rs)){
gets(optiune);
fflush(stdin);
printf("Stiva Goala !!! INTRODUCETI ELEMENTE \n");
break;
case 'c':
case 'C': if (!StivaGoala (rs))
printf("Afisare element din capul stivei: %d\n",
CapStiva (rs));
else
break;
case 'a':
case 'A':AfisareStivaV (rs);
break;
case 'p':
case 'P': Afisare_Poz_sp (rs);
break;
printf("\nOptiuni Int, Ext, Afis stiva, Cap stiva, Poz sp, Stop: ");
gets(optiune);
}
}
24
/* stivcdif.c - programul construieste o stiva de caractere distincte, pe care apoi o tipareste */
#include <stdio.h>
struct st_lista
char car;
struct st_lista *urmator;
};
void main()
struct st_lista *vr, *primul;
char c;
int distinct (struct st_lista *prim, char ch);
primul = NULL;
printf("\nProgramul construieste si afiseaza o stiva de caractere.\n");
fflush(stdin);
if (c != '\n' && (distinct(primul, c)))
vr=(struct st_lista *) malloc(sizeof(struct st_lista));
if (vr == NULL)
{ /* daca pointerul returnat de functia
malloc() este NULL */
printf("Memorie plina !!!!!!\n"); /* mesaj de

eroare */
caractere */
vr->car=c;
vr->urmator=primul;
primul=vr;
vr=primul; /* initializare pointer curent, vr, pentru a referi
primul caracter */
while (vr != NULL)
{
printf("%c -> ", vr->car);
vr=vr->urmator;
printf(" NULL");/* tiparire sfarsit lista caractere sau lista vida daca
primul era NULL */
int distinct (struct st_lista *prim, char ch)
struct st_lista *ptr;
int gasit;
ptr=prim; /* initializare pointer curent cu primul din lista */
gasit=0; /* presupunem ca nu l-am gasit inca */
while (ptr != NULL && !gasit) /* cat timp nu s-a terminat lista si nu
l-am gasit */
{ /* se continua parcurgerea listei */
gasit=(ptr->car == ch);
ptr=ptr->urmator;
return (!gasit);
Sortare
1
/* HeapSMax.c - Ord. descresc., prin selectie Heapsort:
construim Heap-ul, arborele de selectie, memorat intr-un
vector, dupa care se interschmba prima valoare (maximul)

cu ultima si in vectorul ramas (n-1) se construieste
din nou Heap-ul, s.a.m.d.
*/
#include<stdio.h>
#include <conio.h>
void cerne (double a[], int l, int r)
int i,j;
double x;
i=l; j=2*i; x=a[i]; /* x ce se cerne prin arbore/ vector */
while (j<=r){
if (j<r) /* nu s-a ajuns la capat */
if (a[j]<a[j+1]) /* j-ind. val. mai mare din */
j++; /* perechea (2*i, 2*i + 1) */
if (x>a[j]) /* daca x > valoarea respectiva (j) */
goto gata; /* altfel, se muta */
a[i]=a[j]; /* valoarea mai mare a[j] la a[i], si se */
i=j; j=2*i; /* continua cernerea pe nivelul urmator */
} /* noul i devine j (vechi i), iar j=2i, daca j<r */
gata: a[i]=x; /* pune x in poz. i, a[i]<a[2i], a[i]<a[2i+1] */
void heapsort(double a[], int n){
int i, l, r;
double x;
l=(n/2)+1; r=n;
while (l>1){
l--;
cerne(a,l,r);
for( i = 1 ; i <= n ; ++i ){
printf (" %0.lf ", a[i]);
if (i%10==0)
printf("\n");
printf("\nApasa o tasta pentru continuare program!\n");
getch();
while(r>1)
{x=a[1];
a[1]=a[r];
a[r]=x;
r--;
cerne(a,l,r);
for( i = 1 ; i <= n ; ++i ){
if (i%10==0)
printf("\n");
getch();
void main(void)
double sir[1000];
int ne, i;
clrscr();
printf("HeapSort pentru ordonare crescatoare vector.\n");
printf ("Numarul de elemente: ");
scanf ("%d",&ne);
for ( i = 1 ; i <= ne ; ++i)
printf (" sir(%d)=", i);
scanf ("%lf", &sir[i]);
heapsort(sir,ne);
for( i = 1 ; i <= ne ; ++i ){
printf (" %0.lf ", sir[i]);
if (i%10==0)
printf("\n");
printf("\nPROGRAM TERMINAT! Apasa o tasta-iesire!!!\n");
getch();
2
/* HeapSmin.c - Ord. descresc., prin selectie Heapsort:
construim Heap-ul, arborele de selectie, memorat intr-un
vector, dupa care se interschmba prima valoare (minimul)
cu ultima si in vectorul ramas (n-1) se construieste
din nou Heap-ul, s.a.m.d.
*/
#include<stdio.h>
#include <conio.h>
void cerne (double a[], int l, int r)
int i,j;
double x;
i=l; j=2*i; x=a[i]; /* x ce se cerne prin arbore/ vector */
while (j<=r){
if (j<r) /* nu s-a ajuns la capat */
if (a[j]>a[j+1]) /* j-ind. val. mai mica din */
j++; /* perechea (2*i, 2*i + 1) */
if (x<a[j]) /* daca x < valoarea respectiva (j) */
goto gata; /* altfel, se muta */
a[i]=a[j]; /* valoarea mai mica a[j] la a[i], si se */
i=j; j=2*i; /* continua cernerea pe nivelul urmator */
} /* noul i devine j (vechi i), iar j=2i, daca j<r */
gata: a[i]=x; /* pune x in poz. i, a[i]<a[2i], a[i]<a[2i+1] */
void heapsort(double a[], int n){
int i, l, r;
double x;
l=(n/2)+1; r=n;
while (l>1){
l--;
cerne(a,l,r);
for( i = 1 ; i <= n ; ++i ){
if (i%10==0)
printf("\n");
getch();
while(r>1)
{x=a[1];
a[1]=a[r];
a[r]=x;
r--;
cerne(a,l,r);
for( i = 1 ; i <= n ; ++i ){
if (i%10==0)
printf("\n");
getch();
void main(void)
double sir[1000];
int ne, i;
clrscr();
scanf ("%d",&ne);
for ( i = 1 ; i <= ne ; ++i)

{
printf (" sir(%d)=", i);
heapsort(sir,ne);
for( i = 1 ; i <= ne ; ++i ){
printf (" %0.lf ", sir[i]);
if (i%10==0)
printf("\n");
printf("\nPROGRAM TERMINAT! Apasa o tasta-iesire!!!\n");
getch();
3
/*
ins_bin.c - prog. de ordonare cresc. sir, utilizand metoda de inserare binara,
adica: se considera un sir ordonat, format initial din primul element din
sirul initial, si un sir neordonat, format din restul elementelor sirului,
din care se iau pe rand celelalte elemente si li se cauta, de la dreapta
la stanga, pozitia in sirul ordonat, construit tot in sirul initial.
Cautarea se face utilizand metoda "binara".
*/
#include<stdio.h>
#include <conio.h>
int ncomp=0, nins=0; /* numar de comparatii si inserari/deplasari */
/* functia de sortare prin inserare binara */
void sort_ins_binara ( double a[], int n )
double x;
int i, j, s, d, m;
for (i=1; i<n; ++i)
x=a[i]; s=0; d=i-1;/* initializari: x-elementul de inserat */
while (s <= d) /* s, d-limitele stanga/dreapta pentru subsir dest */
{ncomp++;
m=(s+d)/2; /* mijlocul subsirului */
if (x < a[m]) /* in functie de apartenenta elementului x */
d=m-1; /* la subsirul din stanga sau dreapta */
else /* se stabileste noua limita din stanga/dreapta */
s=m+1; /* a noului subsir, in care se cauta */
} /* dupa determinarea pozitiei de inserare a elem.*/
for (j=i-1; j>=s; --j, nins++) /* se deplaseaza tot sirul cu */
a[j+1]=a[j]; /* o pozitie la dreapta, de la pozitia */
a[s]=x; /* de inserare pana la sfarsit, dupa care */
/* se insereaza noul element, x */
void main(void){
double sir[100]; int ne,i;
clrscr();
printf("Numar elemente:");
scanf("%d", &ne);
for(i=0; i<ne; i++) /* citire sir de ordonat */
printf("sir(%d)= ", i+1);
scanf("%lf", &sir[i]);
printf("Sirul ordonat este: \n");
sort_ins_binara(sir , ne); /* apelul functiei de sortare binara */
for (i=0;i<ne;i++) /* afisare sir ordonat */
printf(" sir (%2d) = %lf \n", i+1, sir[i]);
if ((ne+1)%4==0) /* tiparesc cate 4 valori pe linie */
printf("\n");
printf("\n");
printf("Ordonarea s-a realizat prin %d comparatii si %d deplasari\n",
ncomp, nins);}
4
/* ins_dir.c- prog. ordonare cresc. sir, utilizand metoda de inserare directa, adica:
se considera un sir ordonat, format initial din primul element din sirul initial,
si un sir neordonat, format din restul elementelor sirului, din care se iau pe
rand celelalte elemente si li sa cauta, de la dreapta la stanga, pozitia in
sirul ordonat, construit tot in sirul initial. */
#include <stdio.h>
#include <conio.h>
int ncomp=0, nins=0; /* numar de comparatii si inserari/ deplasari */
void sort_ins_direct (double a[], int n)

{/* functia de sortare prin inserare directa */
double x;
int i, j;
for (i=1; i<n; ++i)
x=a[i]; /* elementul curent de inserat */
j=i-1; /* dimensiunea sirului destinatie */
while (x < a[j] && j >= 0)
{ /* se cauta pozitia de inserare */
a[j+1]=a[j];
j--;
ncomp++; nins++;
a[j+1]=x; /* inseare element curent */
void main()
double sir[100];
int ne, i;
clrscr();
scanf("%d", &ne);
for(i=0; i<ne; i++) /* citirea elementelor sirului de sortat */
printf("sir(%d)= ", i+1);
}
sort_ins_direct (sir, ne); /* ordonarea sirului prin inserare directa */
printf("\n Sirul ordonat:\n");
for(i=0; i<ne; i++) /* afisare sir ordonat */
printf(" sir(%d)=%5.2lf ", i+1, sir[i]);
if ( (i+1) %5 == 0 ) /* daca s-au afisat 5 valori din sir pe o linie */
printf("\n");
ncomp, nins);
5
/* MergeSor.c - Ordonare utilizand metoda MergeSort (interclasare) */
#include <stdio.h>
#include <conio.h>
#define DIM 20
void MergeSort (int v[], int p, int q){
int m, aux;
void Interclasare(int [], int, int, int);
if (q-p <= 1){
if (v[p]>v[q]){
aux=v[p];
v[p]=v[q];
v[q]=aux;
else{
m=(p+q)/2;
MergeSort(v, p, m);
MergeSort(v, m+1, q);
Interclasare(v, p, q, m);
void Interclasare (int v[], int p, int q, int m){
int i=p, j=m+1, k=0;
int *u=(int *) malloc (DIM * sizeof(int)); // alocare memorie pentru vect. u
while (i<=m && j<=q){
if (v[i] <= v[j]){
u[k]=v[i];
i++; k++;
else{
u[k]=v[j];
j++; k++;
if (i <= m)
for (j=i; j<=m; j++){
u[k]=v[j];
k++;
}
else
for (i=j; i<=q; i++){
u[k]=v[i];
k++;
k=0;
for (i=p; i<=q; i++){
v[i]=u[k];
k++;
free(u); // eliberarea spatiului alocat pentru vectorul u
void scrie_vector(int vect[], int d){
int i;
for (i=0; i<d; i++)
printf("%5d,", vect[i]);
void main()
{int vector[]={10, 5, 6, 12, 3, 7, 15, 12, 9, 4, 3};
int ne=11;
clrscr();
MergeSort(vector, 0, ne-1);
scrie_vector(vector, ne);
printf("\nApasati o tasta pentru a termina programul!\n");
getch();
}
6
/* QuickSit.c - sortarea unui vector utilizand algoritmul QuickSort, iterativ */
#include<stdio.h>
#include<conio.h>
#define DIM 100
typedef int VECTOR[DIM];
int ncomp=0, ninv=0; /* numar de comparatii, inversiuni */
void cit_vect(int n, VECTOR v)
{int i;
for(i=0; i<n; i++)
{printf("v[%d]=", i+1);
scanf("%d", &v[i]);}
}
void scrie_vect(int n, VECTOR v)
{int i;
for(i=0; i<n; i++)
printf("v[%d]=%d\n", i+1, v[i]);
void QuickSortit (VECTOR a, int n)
/* Sortara partajata (QuickSort) realizata iterativ */
{int s, d, i, j, is, x, t;
struct st_stiva {int s, d;}; /* element stiva: pozitia stanga, dreapta */
struct st_stiva stiva[DIM]; /* stiva ce contine lista de cereri partitie */
is=1; stiva[is].s=0; stiva[is].d=n-1; d=n-1; /* initializari */
do{
s=stiva[is].s; d=stiva[is].d; is--; /* partitia curenta de realizat*/
do {i=s; j=d; /* este luata din varful stivei */
x=a[(s+d)/2]; /* santinela */
do {
while (a[i]<x) i++, ncomp++;
while (a[j]>x) j--, ncomp++;
if (i<=j)
{t=a[i];
a[i]=a[j];
a[j]=t;
i++; j--;
ninv++;
} while(i<=j);
if (i<d){ /* depun in stiva cererea de a sorta */
is++; /* partitia dreapta */

stiva[is].s=i;
stiva[is].d=d;
d=j; /* se continua sortarea partitiei stanga, (s, d) */
} while (s<d); /* pana are un singur element (s==d) */
}while (is>0); /* se reia sortarea pentru partitiile stanga */
} /* ramase nerezolvate, in stiva */
void main(void)
{int n;
VECTOR v;
clrscr();
printf("Programul ordoneaza (sorteaza) un vector cu alg. QuickSort.\n");
printf("Dimensiune vector, n=");scanf("%d", &n);
cit_vect(n, v);
QuickSortit (v, n);
printf("\nVectorul ordonat este:\n");
scrie_vect(n, v);
printf("Sortarea s-a realizat dupa %d comparatii si %d inversiuni\n",
ncomp, ninv);
getch();
}
7
/* QuickSor.c - sortarea unui vector utilizand algoritmul QuickSort */
#include<stdio.h>
#include<conio.h>
#define DIM 100
typedef int VECTOR[DIM];
{int i;
for(i=0; i<n; i++)
{printf("v[%d]=", i+1);
{int i;
for(i=0; i<n; i++)
void QuickSort(VECTOR a, int s, int d)
{int i, j, m, x, temp;
i=s;
j=d;
m=(s+d)/2;
x=a[m];
do
{while (a[i]<x) i++, ncomp++;
while (a[j]>x) j--, ncomp++;
if (i<=j)
{temp=a[i];
a[i]=a[j];
a[j]=temp;
i++;
j--;
ninv++;
}while(i<=j);
if(s < j) QuickSort(a, s, j);
if(i < d) QuickSort(a, i, d);
void main(void)
{int n;
VECTOR v;
clrscr();
printf("Dimensiune vector, n=");scanf("%d", &n);
cit_vect(n, v);
QuickSort(v, 0, n-1);
scrie_vect(n, v);
printf("Sortarea s-a realizat dupa %d comparatii si %d inversiuni\n",
ncomp, ninv);
getch();
8
/* QuickSor.cpp - sortarea unui vector utilizand algoritmul QuickSort */
#include<stdio.h>
#include<conio.h>
typedef int vector[30];
void cit_vect(int n,vector v)
{int i;
for(i=0;i<n;i++)
{printf("v[%d]=",i);
scanf("%d",&v[i]);}
void scrie_vect(int n,vector v)
{int i;
for(i=0;i<n;i++)
printf("v[%d]=%d\n",i,v[i]);
void quicksort(vector a, int s, int d)
{int i, j, m, x, temp;
i=s;
j=d;
m=(s+d)/2;
x=a[m];
do
{while (a[i]<x) i++;
while (a[j]>x) j--;
if (i<=j)
{temp=a[i];
a[i]=a[j];
a[j]=temp;
i++;
j--;
}while(i<=j);
if(s<j) quicksort(a,s,j);
if(i<d) quicksort(a,i,d);
main()
{int n;
vector v;
clrscr();
printf("Dimensiune vector, n=");scanf("%d",&n);
cit_vect(n,v);
quicksort(v,0,n-1);
scrie_vect(n,v);
getch();
9
/* sel_dir.c - programul ordoneaza un vector prin selectie directa,
utilizand pentru aceasta determinarea minimului si a pozitiei lui,
la fiecare iteratie si realizand o singura inversiune intre acest
minim si valoarea a[i], corespunzatoare iteratiei curente;
se determina si numarul de comparatii si inversiuni realizate
*/
#include<stdio.h>
#include <conio.h>
int ncomp=0, ninv=0; /* numar de comparatii si inversiuni */
void sort_sel_direct ( double a[], int n )
/* functia sorteaza un vector prin metoda de selectie directa */
double x;
int i, j, k;
for ( i = 0 ; i < n-1 ; ++i )
k = i; /* initializare indice, k, si elementul minim, x */
x = a[i];
for ( j = i+1 ; j < n ; ++j, ncomp++ ) /* determinare minim si indicele lui din sir */
if (a[j] < x)
k = j;
x = a[k];
a[k] = a[i]; /* interschimbare minim cu primul din subsirul sursa, */
a[i] = x; /* adica cu primul din subsirul neordonat */
ninv++;
void main()
double sir[100];
int ne,i, nl=0;
clrscr();
scanf("%d",&ne);
for(i=0;i<ne;i++) /* citirea elementelor sirului de ordonat */
printf("sir(%d)=",i+1);
scanf("%lf",& sir[i]);
sort_sel_direct(sir,ne); /* ordonarea sirului prin selectie directa */
for(i=0;i<ne;i++) /* afisarea sirului ordonat */
printf(" sir(%2d)=%5.1lf",i+1,sir[i]);
nl++; /* actualizare contor numar de valori afisate pe o linie */
if ( nl % 5 == 0 ) /* daca s-au afisat 5 valori pe o linie se trece pe */
printf("\n"); /* o linie noua */

}
printf("\n");
printf("Ordonarea s-a realizat prin %d comparatii si %d inversiuni\n",
ncomp, ninv);
10
/* sel_dirv.c - Program de ordonare crescatoare sir, utilizand
metoda de selectie directa, adica: din sirul initial se pune
valoarea minima pe prima pozitie, apoi pentru subsirul ramas,
[2,n], se pune valoarea minima pe pozitia 2, s.a.m.d,
prin interschimbari multiple; pentru fiecare valoare, sir[i],
ori de cate ori se determina o valoare sir[j]<sir[i],
se inverseaza cele doua valori (se determina si numarul
de comparatii si inversiuni realizate pentru ordonare)
*/
#include<stdio.h>
#include <conio.h>
void sort_sel_dir (double sir[], int nrelem)
{ /* selectie directa prin interschimbari, pentru fiecare
valoare mai mica decat iteratia curenta, i, sir[i]. */
int i, j;
double aux;
for( i = 0; i < nrelem-1; ++i)
for( j = i+1; j < nrelem ; ++j, ncomp++){
if ( sir[i] > sir[j] )
{
aux = sir[i];
sir[i] = sir[j];
sir[j] = aux;
ninv++;
void main(void)
double sir[1000];
int ne, i;
clrscr();
scanf ("%d",&ne);
for ( i = 0 ; i < ne ; ++i)
printf (" sir(%2d)=", i+1);
sort_sel_dir(sir,ne);
for( i = 0 ; i < ne ; ++i ){
printf (" sir(%2d)=%5.2lf ", i+1, sir[i]);
if ((i+1)%4==0)
printf("\n");
printf("\n");
printf("Ordonarea s-a realizat prin %d comparatii si %d inversiuni\n",
ncomp, ninv);
}
11
/* shaker.cpp - ordonare (sortare) vector utilizand metoda "ShakerSort"
*/
#include<stdio.h>
#include<conio.h>
typedef int VECTOR[30];
int ncomp=0, ninv=0; /* numar de comparatii si inversiuni/ deplasari */
{int i;
for(i=0; i<n; i++)
{printf("v[%d]=", i+1);
{int i;
for(i=0; i<n; i++)
void shaker(int n, VECTOR v)
{int t, i, k, s, d;
d=n-2; s=0; k=d; /* initializari pentru limita din stanga (s), dreapta (d) */
do /* iar k reprezinta pozitia la care s-a realizat ultima inversiune */
/* ncomp, ninv - numar de comparatii, inversiuni realizate */

{for (i=s; i<=d; i++, ncomp++) /* parcurg de la stanga la dreapta */
if (v[i] > v[i+1]) /* daca este cazul se inverseaza */
{t=v[i];
v[i]=v[i+1];
v[i+1]=t;
k=i; /* se retine pozitia ultimei inversiuni */
ninv++;}
d=k-1; /* se modifica corespunzator limita din dreapta */
for (i=d; i>=s; i--, ncomp++) /* parcurg de la dreapta la stanga */
if (v[i+1] < v[i]) /* daca este cazul se invers. elem. */
{t=v[i];
v[i]=v[i+1];
v[i+1]=t;
k=i; /* se retine pozitia ultimei inversiuni */
ninv++;}
s=k+1; /* se modifica corespunzator limita din stanga */
}while(s <= d);
void main(void)
{int n;
VECTOR v;
clrscr();
printf("\nProgramul ordoneaza (sorteaza) un vector, metoda \"Shaker\".\n");
printf("\tDimensiune vector, n= ");scanf("%d",&n);
cit_vect(n,v);
shaker(n,v);
printf("\nSirul ordonat este:\n");
scrie_vect(n,v);
ncomp, ninv);
printf("\n\tApasati o tasta pentru a termina programul\n");
getch();}
12
/* sortbule.c - programul ordoneaza un sir de valori prin
metoda inversiunilor (bulelor) - forma clasica
*/
#include <stdio.h>
#include <conio.h>
int ncomp=0, ninv=0; /* numar de comparatii si inversiuni/ deplasari */
void sort_met_bulelor (double a[], int n)
/* functia sorteaza un vector prin metoda inversiunilor (bulelor) */
{double x;
int i, j;
for (i=1; i<n; i++)
for (j=n-1; j>=i; j--, ncomp++)
if (a[j-1] > a[j])
x=a[j-1];
a[j-1]=a[j];
a[j]=x;
ninv++;
void main(){
double sir[100];
int ne,i, nl=0;

clrscr();
scanf("%d", &ne);
for(i=0; i<ne; i++) /* citirea elementelor sirului de ordonat */
{printf("sir(%d)=",i+1);
sort_met_bulelor (sir, ne); /* ordonarea sirului prin selectie directa */
for(i=0; i<ne; i++) /* afisarea sirului ordonat */
printf("sir(%2d)=%5.1lf ", i+1, sir[i]);
nl++; /* actualizare contor numar de valori afisate pe o linie */
if (nl % 5 == 0) /* daca s-au afisat 5 valori pe o linie */
printf("\n");
ncomp, ninv);
}
13
/* sortindx.c - se sorteaza indecsii unui tablou de tip structura,
care contine date pentru un numar de studenti (nume, prenume si media)
asociat acestui tablou definim un tablou cu indecsii tabloului de studenti;
vom sorta studentii dupa medii prin intermediul tabloului de indecsi,
iar sortarea indicilor se va face utiliznd algoritmul ShakerSort
*/
#include <stdio.h>
#define DIM 100
#include <conio.h>
struct tip_struct
char nume_prenum [DIM];/* numele si prenumele unui student*/
float medie;
};
void main(void)
struct tip_struct stud [100];/* consideram un tablou de studenti */
int ind[100]; /* vectorul ce contine indecsii tabloului initial, si ce
va fi ordonat in functie de valorile vectorului de ordonat "tab" */
int i, ns;
float f;
void ShakerSort (struct tip_struct tab[], int index[], int n);
clrscr();
printf("Numarul de studenti:");
scanf("%d", &ns);
f=0.0; fflush(stdin);
for (i=0; i<ns; i++) /* citire date studenti: nume, prenume si media */
printf("Numele si prenumele studentului %d: ", i+1);
gets(stud[i].nume_prenum);
printf("Media notelor sale: ");
scanf("%f", &f);
stud[i].medie=f;
while (getchar() != '\n');
for (i=0; i<ns; i++) /* initializarea tabloului de indici */
ind[i] = i;
ShakerSort (stud, ind, ns); /* sortarea vectorului */
printf("Lista ordonata cu numele / prenumele si media studentilor\n");
for (i=0; i<ns; i++)
printf("%s %.2f\n", stud[ind[i]].nume_prenum,
stud[ind[i]].medie);
void ShakerSort (struct tip_struct tab[], int index[], int n)
int i, s, d, k, t;
d=n-2; s=0; k=d;
do {
for (i=s; i<=d; i++)
if (tab[index[i]].medie < tab[index[i+1]].medie)
t=index[i];
index[i]=index[i+1];
index[i+1]=t;
k=i;
d=k-1;
for (i=d; i>=s; i--)
if (tab[index[i+1]].medie > tab[index[i]].medie)
t=index[i];
index[i]=index[i+1];
index[i+1]=t;
k=i;
s=k+1;
} while (s <= d);
}
14
/* SortShel .c - programul ordoneaza un vector cu metoda Shell */
#include <stdio.h>
#include <conio.h>
#define N_MAX 100
typedef double VECTOR [N_MAX];
void Sort_Shell (VECTOR v, int dim){
int i, pas, inv;
double a;
pas = dim;
while (pas >1 )
pas=pas/2 ;
do
inv=0 ; /* fals */
for (i=0; i < dim-pas; i++)
{ncomp++;
if (v[i] > v[i+pas])
a=v[i+pas];
v[i+pas]=v[i];
v[i]=a;
inv=1;
ninv++;
}
}
} while (inv);
void main (void)
VECTOR sir, a;
int n, i, j , inv ;
clrscr();
printf ("Numarul de elemente ale sirului (<=100): " ) ;
scanf ("%d", &n) ;
for (i=0; i<n; ++i)
printf ("sir[%2d]= ", i+1);
scanf ("%lf", &sir[i]) ;
Sort_Shell(sir, n);
for (i=0; i<n; ++i){
printf ("sir[%2d]=%5.2lf ", i+1, sir[i]);
if ((i+1)%4==0)
printf("\n");
printf("\nSortarea s-a realizat dupa %d comparatii si %d inversiuni\n",
ncomp, ninv);
getch();

Liste Arbori Sortari

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Liste Arbori Sortari

Încărcat de

Drepturi de autor:

Formate disponibile

Liste si arbori

de numere intregi, utilizand functiile recursive: 'inserare', 'listare'.

Arborele contine pe langa valorile intregi ordonate (SRD)

si numarul de aparitii pentru valorile ce se repeta.

Programul permite elimiarea unei anumite valori (chei), adica

un nod din arbore ce contine cheia, pastrand arborele de cautare (SRD).

typedef struct tnod

struct tnod *pstg;

struct tnod *pdr;

void inserare (ARB * &v, int val){

{v = new ARB; v->nr=val; v->ap=1;

else if (v->nr > val)

else if (v->nr < val)

void inlocuire_nod(ARB * &n){ // n - nodul de eliminat

// se inlocuieste cu maximul de pe subarborele stang (acum maximul din n),

// care este pe ramura dreapta a lui 'n',

// sau cu minimul de pe subarborele drept (adica minimul din arborele n),

// rezultatul final fiind acelasi, adica un arbore de cautare

else {e->nr=n->nr; // e - nodul care se elimina (continutul sau)

e->ap=n->ap; // se actualizeaza valorile lui 'e' cu maximul din

e=n; // arborele nodului 'n' , ramura dreapta

n=n->pstg; // pastrez legatura la ramura stanga a nodului

free(e); // pentru care elimin ramura dreapta, a carei

} // valori s-au mutat in nodul 'eliminat' (inlocuit)

void elimina_nod (ARB * &a, int x){// a-arbore, x-valoarea de eliminat

printf("\nCheia cautata %d nu este in arbore!\n", x);

else if (x < a->nr) // se cauta pozitia valorii 'x'

elimina_nod (a->pstg, x);

elimina_nod (a->pdr, x);

else // s-a gasit pozitia lui 'x'

if (!a->pstg){ // are subarborele stang vid

a=a->pdr; // se conecteaza subarborele drept

free(e); // si eliberez spatiul alocat

else if (!a->pdr){// are subarborele drept vid

a=a->pstg; // se conecteaza subarborele stang

free(e); // si eliberez spatiul alocat

inlocuire_nod(a->pstg); // sau cu parametru 'a->pdr'

} // cu modificarile respective in functia de inlocuire

void listare_SRD (ARB *v){

printf("%3d(%d) -> ", v->nr, v->ap);

printf("Se construieste un arbore de cautare si permite elimarea unui nod.\n");

printf ("\nIntroduceti un sir de valori, terminat cu EOF.\n");

while ( scanf ("%d", &valoare) != EOF) {

printf("\nListare arbore SRD:\n");

printf("\nValoare de eliminat: ");

/* afisare arbore dupa eliminare */

printf("\nListare arbore SRD, dupa eliminarea valorii %d:\n", valoare);

nel=0; // initializare contor afisare pe ecran

printf("Terminare dupa apasarea unei taste!\n");

arbinnum - programul construieste recursiv si tipareste un arbore de intregi,

utilizand functiile recursive: 'inserare' si 'listare'.

Arborele contine pe langa valorile intregi ordonate (SRD)

si numarul de aparitii pentru valorile ce se repeta

- afiseaza arborele si inaltimea lui

typedef struct tnod

struct tnod *pstg;

struct tnod *pdr;

void inserare (ARB * &v, int val){

{v = new ARB; v->nr=val; v->ap=1;

else if (v->nr < val)

else if (v->nr > val)

void listare_SRD (ARB *v){

printf("%3d(%2d) -> ", v->nr, v->ap);

char cuvant; / pointer la cuvantul citit */

struct st_arbore st, dr;

char cuvant; / pointer la cuvantul citit */

struct st_arbore st, dr;