R-1921 Panis Traian-Sefan

Portofoliu Programarea Calculatorului

Efectuat:Panis Traian-Stefan
R-1921 Panis Traian-Sefan

Lucrare de Laborator nr.1

#include<iostream>
using namespace std;
struct Nod
{
int valoare;

Nod *next,*back;
};
Nod *prim, *ultim;
int n;
void creare_lista()
{Nod *c;
c=new Nod;
}
else
{ultim->next=c;
c->back=ultim;
ultim=c;
ultim->next=0;
}
}
void listare_stanga_dreapta()
{Nod *c;
c=prim;
while(c)
{cout<<c->valoare<<" ";
c=c->next;}
}
void creaza_lista_circulara()
{ultim->next=prim;
prim->back=ultim;
}
void afiseaza_lista_circulara(Nod *c)
{for(int i=1;i<=n;i++)
{cout<<c->valoare<<" ";
c=c->next;}
}
R-1921 Panis Traian-Sefan
void main()
{int i;
clrscr();
cout<<"cate elemente va avea lista?";
cin>>n;
for(i=1;i<=n;i++)
creare_lista();
cout<<endl<<"Elementele listei de la stanga la dreapta sunt:"<<endl;
listare_stanga_dreapta();
creaza_lista_circulara();
cout<<endl<<"afiseaza lista circulara incepand de la primul :"<<endl;
afiseaza_lista_circulara(prim);
cout<<endl<<"afiseaza lista circulara incepand de la al doilea :"<<endl;
afiseaza_lista_circulara(prim->next);
cout<<endl<<"afiseaza lista circulara incepand de la ultimul :"<<endl;
afiseaza_lista_circulara(ultim);
Nod* stergere(Nod *prim,char *nume){
Nod *q,*p;
if(prim!=NULL){
if(strcmp(prim->nume,nume)==0){
q=prim;
prim=prim->urm;
free(q);
return prim;
}
q=prim;
while(q->urm!=NULL && strcmp(q->urm->nume,nume)!=0)
q=q->urm;
if(q->urm!=NULL && strcmp(q->urm->nume,nume)==0){
p=q->urm;
q->urm=q->urm->urm;
free(p);
}
return prim;
}
else{
printf(“\nLista vida!”);
return prim;
}
}
return();

Lucrare de Laborator nr.2

R-1921 Panis Traian-Sefan

#include <iostream>
using namespace std;
bool isEmpty(int nrtotal){
if(nrtotal==0){
return true;
}
else{
return false;

}
}
void push(char stiva[],int &nrtotal, int numar){
nrtotal=nrtotal+1;
stiva[nrtotal]=numar;
}
int peek(char stiva[],int nrtotal){
return stiva[nrtotal];
}
int pop(char stiva[],int &nrtotal){
int rezultat=peek(stiva,nrtotal);
nrtotal=nrtotal-1;
return rezultat;
}
void invers(char stiva[],int nrtotal){
for(int i=nrtotal-1;i>=0;i--)
cout<<stiva[i];
}
int main()
{
char nrtotal=0;char nume[25];
cout<<"Introduceti numele: ";cin>>nume;
R-1921 Panis Traian-Sefan
while(nume[nrtotal]!='\0'){
nrtotal++;
}
invers(nume,nrtotal);
}

Lucrare de laborator nr.3

#include <fstream>
using namespace std;
ifstream fin("suma.in");
ofstream
fout("suma.out");
int n,v[100];
int a=(79,40,23,110,11,73,20,60,3);
int main()
{
int i, s=0;
fin>>n;
for ( i = 0; i < n; i++ )
{
fin>>v[i]; s= s + v[i];
}
{
int i, vmax;
fin>>n;
for ( i = 0; i < n; i++ )
fin>>v[i];
vmax = v[0];
for ( i = 1; i < n; i++ )
if (vmax < v[i] )
vmax = v[i];
fout<<vmax;
}
fout<<s; fin.close();
fout.close();
return 0;}
R-1921 Panis Traian-Sefan

Structuri dinamice de date cu toate tipurile

• Listele simplu înlănțuite sunt structuri de date dinamice. Fiecare nod al listei
conține informația utila și adresa următorului element.
• Informația utilă reprezintă informația propriu-zisă memorată în elementul
liste (numere, șiruri de caractere, etc.), iar informația de legătură precizează
adresa următorului element al listei.

#include<iostream>
using namespace std;
struct Nod
{
int valoare;

Nod *next,*back;
};
Nod *prim, *ultim;
int n;
void creare_lista()
{Nod *c;
c=new Nod;
}
else
{ultim->next=c;
c->back=ultim;
ultim=c;
ultim->next=0;
}
}
void listare_stanga_dreapta()
{Nod *c;
c=prim;
while(c)
{cout<<c->valoare<<" ";
c=c->next;}
}
void creaza_lista_circulara()
{ultim->next=prim;
prim->back=ultim;
}
void afiseaza_lista_circulara(Nod *c)
{for(int i=1;i<=n;i++)
{cout<<c->valoare<<" ";
c=c->next;}
}
R-1921 Panis Traian-Sefan
void main()
{int i;
clrscr();
cout<<"cate elemente va avea lista?";
cin>>n;
for(i=1;i<=n;i++)
creare_lista();
cout<<endl<<"Elementele listei de la stanga la dreapta sunt:"<<endl;
listare_stanga_dreapta();
creaza_lista_circulara();
cout<<endl<<"afiseaza lista circulara incepand de la primul :"<<endl;
afiseaza_lista_circulara(prim);
cout<<endl<<"afiseaza lista circulara incepand de la al doilea :"<<endl;
afiseaza_lista_circulara(prim->next);
cout<<endl<<"afiseaza lista circulara incepand de la ultimul :"<<endl;
afiseaza_lista_circulara(ultim);
Nod* stergere(Nod *prim,char *nume){
Nod *q,*p;
if(prim!=NULL){
if(strcmp(prim->nume,nume)==0){
q=prim;
prim=prim->urm;
free(q);
return prim;
}
q=prim;
while(q->urm!=NULL && strcmp(q->urm->nume,nume)!=0)
q=q->urm;
if(q->urm!=NULL && strcmp(q->urm->nume,nume)==0){
p=q->urm;
q->urm=q->urm->urm;
free(p);
}
return prim;
}
else{
printf(“\nLista vida!”);
return prim;
}
}
return();

Stiva
R-1921 Panis Traian-Sefan

 Stiva (sau „stack” in limba engleza) este o structură de date liniara ce lucreaza
cu o colectie de date avand doua operatii principale:

#include <iostream>

using namespace std;

bool isEmpty(int nrtotal){

if(nrtotal==0){

return true;

else{

return false;

void push(char stiva[],int &nrtotal, int numar){

nrtotal=nrtotal+1;

stiva[nrtotal]=numar;

int peek(char stiva[],int nrtotal){

return stiva[nrtotal];

int pop(char stiva[],int &nrtotal){

int rezultat=peek(stiva,nrtotal);

nrtotal=nrtotal-1;

return rezultat;

void invers(char stiva[],int nrtotal){

for(int i=nrtotal-1;i>=0;i--)

cout<<stiva[i];

int main()

{
R-1921 Panis Traian-Sefan
char nrtotal=0;char nume[25];

cout<<"Introduceti numele: ";cin>>nume;

while(nume[nrtotal]!='\0'){

nrtotal++;

invers(nume,nrtotal);

Coada
Coada (sau „queue” in limba engleza) este o structura de date liniara ce
lucreaza cu o colectie de date avand doua operatii principale:

#include <iostream>
using namespace std;
const int LIM = 100;
bool isEmpty(int k) {
if(k == 0)
return true;
return false;
}
void push(int coada[], int &k, int numar) {
k = k + 1;
coada[k] = numar;
}
int front(int coada[]) {
return coada[1];
}
int pop(int coada[], int &k) {
int rezultat = coada[1];
for(int i = 1; i < k - 1; i++)
coada[i] = coada[i + 1];
k = k - 1;
return rezultat;
}
int size(int k) {
return k;
}
int main() {
int coada[LIM], k = 0;
push(coada, k, 2);
push(coada, k, 4);
push(coada, k, 6);
push(coada, k, 7);
R-1921 Panis Traian-Sefan
push(coada, k, 8);
cout << pop(coada, k);
cout << pop(coada, k);
cout << pop(coada, k);
return 0;
}

Arbore binary

Numim arbore un graf conex si fara cicluri. Un arbore este determinat de cateva
proprietati:  Un nod special numit radacina in care nu intra nici un arc.  Din
fiecare nod pot iesi zero, unul sau mai multe arce, numite fii.  Din fiecare nod
(mai putin radacina) poate intra un singur arc, dintr-un nod numit parinte. 
Nodurile sunt organizate pe nivele, primul nivel este ocupat numai de radacina,
iar ultimul nivel contine numai noduri din care nu iese nici un arc, numite noduri
terminale, sau frunze.  Fiecare nod poate contine o informatie numita
informatie utila sau cheie a arborelui.

#include<iostream>
Int main()
struct NodLista
{
NodLista(TipArbore info, NodLista* leg = NULL)
: Informatii(info), Legatura(leg) {}
};
NodLista* Concatenare(NodLista *cap1, NodLista *cap2)
{
if (cap1 == NULL)
return cap2;
while (cap1->Legatura != NULL)
cap1 = cap1->Legatura;
cap1->Legatura = cap2;

return cap1;
}
// procedura recursiva de parcurgere a unui arbore binar
NodLista* Parcurgere(NodArbore *nod)
{
if (nod == NULL)
return NULL;
NodLista *cap = NULL;
cap = Concatenare(cap, Parcurgere(nod->Stanga));
R-1921 Panis Traian-Sefan
cap = Concatenare(cap, new NodLista(nod->Informatii));
cap = Concatenare(cap, Parcurgere(nod->Dreapta));
return cap;
}

Metoda trierii

Se numește metoda trierii metoda ce identifică toate soluțiile unei probleme in

dependență de mulțimea soluțiilor posibile. Toate soluțiile se indentifică prin
valori, ce aparțin tipurilor de date studiate: integer, boolean, enumerare sau
subdomeniu. În probleme mai complicate este nevoie de a reprezenta aceste
elemente prin tablouri, articole sau mulțimi.’

#include <iostream>
using namespace std;
int n,m,i,k;
int SumaCifrelor(int num) {
int s=0;
do{
s=s+num$10;
num=num/10;

}
while (num!=0);
return s;

I
bool SolutiePosibila (int num) {
if (SumaCifrelor (num)==m)
return true;
else return false;

}
R-1921 Panis Traian-Sefan

void PrelucrareaSolutiei (int num, int &k){

cout<<num<<" "; k++;

int main () (
cout<< " "; cin >> n;
cout<< "M= "; cin >> m;

cout<< "\nElemente cu proprietatea: \"";

cout<< "Suma cifrelor numarului este "<<m<<"!\"\n\t";
for ( i<=n; ++i)
if (SolutiePosibila(i))
PrelucrareaSolutiei (i,k);
if (k==0) cout <<"Nu exista!";
return 0;

Metoda Greedy

Metoda de programare Greedy se aplică problemelor de optimizare. Aceasta

metoda constă în faptul că se construieşte solutia optimă pas cu pas, la fiecare
pas fiind selectat în solutie elementul care pare „cel mai bun/cel mai optim” la
momentul respectiv, în speranta că această alegere locală va conduce la optimul
global.

#include <iostream>

#include <fstream>

using namespace std;

ifstream f("suma.in");

int a[100];
R-1921 Panis Traian-Sefan

int n;

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

{ f>>n;

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

f>>a[i];

void afisare (int a[], int n)

{ cout<<"Multimea A-{ ";

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

cout<<a[i]<<" ";

cout<<"}"<<endl;

int main()

{ int i,sumaxim=0;

citire(a,n);

afisare(a,n);

cout<<"Submultimea de suma maxima este S-{";

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

if(a[i]>=0)

{ cout<<a[i]<<" ";

sumaxim=sumaxim+a[i];

cout<<"}"<<endl;

cout<<"Valoarea sumei elemetelor este :"<<sumaxim;

return 0;
R-1921 Panis Traian-Sefan

Metoda backtracking

#include <iostream>
using namespace std;
int x1[100], nl, nrsol1=0;
void Afisare () {
int i;
for (i=1;i<=n1;it+)
cout<<xl[i]<<" ";
cout<<endl;
nrsolltt;
}
int Valid(int k) {
int i;
for (i=1;i<=k-1;itt)
if (x1[k]==x1[i]) return 0;
return 1;
}
void BackRecl(int k){
int i;
for (i=1;i<=nl; itt) {
x1 [k]=i;
if (Valid(k))
if (k==nl) Afisare();
else BackRecl (k+1) ;
)
}
int main (){
cout<<"Introduceti valoarea lui n:

ein>>al;

cout<<"Permutarile primelor "<<n1<<"

numere naturale (n<100)"<<endl;
R-1921 Panis Traian-Sefan

BackRecl (1) ;

cout<<"Numar solutii: ";

cout<<arsoll<<endl ;

return 0;
}

Metoda Desparte si stapineste

Metoda de programare DIVIDE ET IMPERA consta in impartirea problemei

initiale de dimensiuni [n] in doua sau mai multe probleme de dimensiuni
reduse. In general se executa impartirea in doua subprobleme de dimensiuni
aproximativ egale si anume [n/2].

#include<iostream.h>

int a[10],n;

void sort(int p,int q,int a[10])

void interc (int p,int q, int m, int a[10])

else

if (i<=m)

for(j=i;j<=m;j++)

else

for(i=j;i<=q;i++)

k=1;

for(i=p;i<=q;i++)

void divimp(int p,int q, int a[10])

R-1921 Panis Traian-Sefan

main()

divimp(1,n,a);

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

cout<<a[i]<<' ';