Liste simplu inlantuite

//program care realizeaza o lista simplu inlantuita ale carei noduri sunt campurile
Cod, Cantitate,Pret si Valorea(pret*cantitate)

#include<stdio.h>
#include<malloc.h>
#include<conio.h>
struct nod
{
float cod, cant, pret;
struct nod* next;
};

nod

Cod
Cantitate
pret
next

void crearelista(nod **cap, int n)

{
nod *p, *q;
float cod1, cant1, pret1;
printf("\n");
printf("Codul=");
scanf("%f", &cod1);
printf("Cantitatea=");
scanf("%f", &cant1);
printf("Pretul=");
scanf("%f", &pret1);
(*cap) = (nod*)malloc(sizeof(nod));
(*cap)->cod = cod1;
(*cap)->cant = cant1;
(*cap)->pret = pret1;
(*cap)->next = NULL;
p = (*cap);
for (int i = 1; i<n; i++)
{
printf("Codul=");
scanf("%f", &cod1);
printf("Cantitatea=");
scanf("%f", &cant1);
printf("Pretul=");
scanf("%f", &pret1);
q = (nod*)malloc(sizeof(nod));

next este pointerul care retine

adresa unei structuri de tip nod

q->cod = cod1;
q->cant = cant1;
q->pret = pret1;
q->next = NULL;
p->next = q;
p = q;
}
}

Cod=1
Cod1
Cantitate=20
Pret=5

Cant1

Pret1

**cap

*cap

0x00979b88

Cod1 (1)
Cant1 (20)
Pret1 (5)
next

NULL

Primul element al listei

**cap

*cap

*p
0x00979b88

Cod1 (1)
Cant1 (20)
Pret1 (5)
next

Adaugarea urmatorului nod:

Cod1

Cod=1
Cantitate=20

Cant1

Pret=5
Cod=2

Pret1

Cantitate=25
Pret=10

0x00979b88

*q

Cod1 (2)
Cant1 (25)
Pret1 (10)
next

NULL

Cum se face legatura dintre cele doua noduri ale listei?

**cap

0x0018fad8

*cap

*p

Cod1 (1)
Cant1 (20)
Pret1 (5)
next

*q

*p

Cod1 (2)
Cant1 (25)
Pret1 (10)
next

NULL

void traversare(nod *cap)

{
nod *p;
float val = 0;
printf("\nCod Cantitate Pret Valoare");
p = cap;
while (p) //p nu este NULL
{
printf("\n%5.2f %5.2f %5.2f %5.2f", p->cod, p->cant, p->pret, (p>cant)*(p->pret));
val += (p->cant)*(p->pret);
p = p->next;
}
printf("\nValoare totala=%5.2f", val);
}

int main(void)
{
nod *cap;
int n;
printf("Numar produse=");
scanf("%d", &n);
crearelista(&cap, n);
traversare(cap);
_getch();
return 0;
}

1. Creati o lista simplu inlantuita care sa contina campurile :Cod_student, Nota_romana,

Nota_mate,Nota_fizica si calculeaza media de Bac pt fiecare student.

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//creez un nod de tip struct care contine campurile: Cod_student, Nota_romana,
Nota_mate, Nota_fizica
struct nod
{
int Cod_student;
float Nota_romana;
float Nota_mate;
float Nota_fizica;
struct nod* next;
};
//creez lista simplu inlantuita
void crearelista(nod **cap, int n)
{
nod *p, *q;
int Cod1;
float Nota_rom1, Nota_mate1, Nota_fiz1;
printf("\nCod_student=");
scanf("%d", &Cod1);
printf("\nNota_romana=");
scanf("%f", &Nota_rom1);
printf("\nNota_mate=");
scanf("%f", &Nota_mate1);
printf("\nNota_fizica=");
scanf("%f", &Nota_fiz1);
(*cap) = (nod*)malloc(sizeof(nod));
(*cap)->Cod_student = Cod1;
(*cap)->Nota_romana = Nota_rom1;
(*cap)->Nota_mate = Nota_mate1;
(*cap)->Nota_fizica = Nota_fiz1;
(*cap)->next = NULL;
p = (*cap);
for (int i = 1; i < n; i++)
{
q = (nod*)malloc(sizeof(nod));
printf("\nCod_student=");
scanf("%d", &Cod1);
printf("\nNota_romana=");
scanf("%f", &Nota_rom1);
printf("\nNota_mate=");
scanf("%f", &Nota_mate1);
printf("\nNota_fizica=");
scanf("%f", &Nota_fiz1);
q->Cod_student = Cod1;
q->Nota_romana = Nota_rom1;
q->Nota_mate = Nota_mate1;
q->Nota_fizica = Nota_fiz1;
q->next = NULL;
p->next = q;
p = q;
}

}
void traversarelista(nod *cap)
{
nod *p;
printf("\nCod_student Nota_romana Nota_mate Nota_fizica Media_BAC");
printf("\n");
p = cap;
while (p)
{
printf("\n%d %5.2f %5.2f %5.2f %5.2f", p->Cod_student, p>Nota_romana, p->Nota_mate, p->Nota_fizica,((p->Nota_romana)+(p->Nota_mate)+(p>Nota_fizica))/3);
p = p->next;
}
}
void main()
{
int n;
nod *cap;
printf("Introduceti numarul de studenti=");
scanf("%d", &n);
crearelista(&cap, n);
traversarelista(cap);
_getch();
}

#include<stdio.h>
#include<malloc.h>
#include<conio.h>
struct produs
{
int cod;
float cantitate;
float pret;
};

nod

struct nod
{
produs inf;
struct nod* next;
};

inf
next

cod
cant
pret

nod* crearelista(nod *cap, int n)

{
nod *p, *q;
cap = (nod*)malloc(sizeof(nod));
printf("\n");
printf("Codul=");
scanf("%d", &cap->inf.cod);
printf("Cantitatea=");
scanf("%f", &cap->inf.cantitate);
printf("Pretul=");
scanf("%f", &cap->inf.pret);
cap->next = NULL;
p = cap;

*cap

*p

inf
next

cod
cant
pret

NULL

NULL

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

{
q = (nod*)malloc(sizeof(nod));
printf("Codul=");
scanf("%d", &q->inf.cod);
printf("Cantitatea=");
scanf("%f", &q->inf.cantitate);
printf("Pretul=");
scanf("%f", &q->inf.pret);
q->next = NULL;
p->next = q;
p = q;
}
return cap;
}

*q

inf
next

NULL

cod
cant
pret

*cap

inf
next

*q

*p

cod
inf

pret

next

cant
cod
cant
pret

NULL

void traversare(nod *cap)

{
nod *p;
float val = 0;
printf("\nCod Cantitate Pret Valoare");
p = cap;
while (p)
{
printf("\n%d %5.2f %5.2f %5.2f", p->inf.cod, p->inf.cantitate, p>inf.pret, (p->inf.cantitate)*(p->inf.pret));
val += (p->inf.cantitate)*(p->inf.pret);
p = p->next;
}
printf("\nValoare totala=%5.2f", val);
}
void main()
{
nod *cap = NULL;
int n;
printf("Numar produse=");
scanf("%d", &n);
cap = crearelista(cap, n);
traversare(cap);
_getch();
}

#include<stdio.h>
#include<conio.h>
#include<malloc.h>
//structura de tip student
struct student
{
int Cod_student;

float Nota_romana;
float Nota_mate;
float Nota_fizica;
};
//nod
struct nod
{
student info;
struct nod *next;
};
//creare lista
nod* crearelista(nod *cap, int n)
{
nod *p, *q;
cap = (nod*)malloc(sizeof(nod));
printf("Cod_student=");
scanf("%d", &cap->info.Cod_student);
printf("Nota_romana=");
scanf("%f", &cap->info.Nota_romana);
printf("Nota_mate=");
scanf("%f", &cap->info.Nota_mate);
printf("Nota_fizica=");
scanf("%f", &cap->info.Nota_fizica);
cap->next = NULL;
p = cap;
for (int i = 1; i < n; i++)
{
q = (nod*)malloc(sizeof(nod));
printf("Cod_student=");
scanf("%d", &q->info.Cod_student);
printf("Nota_romana=");
scanf("%f", &q->info.Nota_romana);
printf("Nota_mate=");
scanf("%f", &q->info.Nota_mate);
printf("Nota_fizica=");
scanf("%f", &q->info.Nota_fizica);
q->next = NULL;
p->next = q;
p = q;
}
return cap;
}
void traversare(nod *cap)
{
nod *p;
printf("\nCod_student Nota_romana Nota_mate Nota_fizica Medie_BAC");
printf("\n");
p = cap;
while (p)
{
printf("\n%d %5.2f %5.2f %5.2f %5.2f", p->info.Cod_student, p>info.Nota_romana, p->info.Nota_mate,p->info.Nota_fizica,((p->info.Nota_mate)+(p>info.Nota_mate)+(p->info.Nota_fizica))/3 );
p = p->next;
}

}
void main()
{
int n;
nod *cap=NULL;
printf("Introduceti numarul de studenti=");
scanf("%d", &n);
cap = crearelista(cap, n);
traversare(cap);
_getch();
}

//program care calculeaza valoarea pt fiecare produs si valoarea totala, iar articolul are campurile
cod, denumire, cantitate si pret.(lista simplu inlantuita)
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
struct produs
{
//4x4 = 16B
int cod;
char *denumire;
float cantitate;
float pret;
};
struct nod
{
produs inf;

struct nod* next;

};
nod* crearelista(nod *cap, int n)
{
nod *p, *q;
char buffer[20];
cap=(nod*)malloc(sizeof(nod));
printf("\n");
printf("Codul=");
scanf("%d",&cap->inf.cod);
printf("Denumirea=");
scanf("%s",buffer);
cap->inf.denumire=(char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(cap->inf.denumire,buffer);
printf("Cantitatea=");
scanf("%f",&cap->inf.cantitate);
printf("Pretul=");
scanf("%f",&cap->inf.pret);
cap->next=NULL;
p=cap;
for (int i=1;i<n;i++)
{
q=(nod*)malloc(sizeof(nod));
printf("Codul=");
scanf("%d",&q->inf.cod);
printf("Denumirea=");
scanf("%s",buffer);
q->inf.denumire=(char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(q->inf.denumire,buffer);
printf("Cantitatea=");
scanf("%f",&q->inf.cantitate);
printf("Pretul=");
scanf("%f",&q->inf.pret);
q->next=NULL;
p->next=q;
p=q;
}
return cap;
}
void traversare(nod *cap)
{
nod *p;
float val=0;
printf("\nCod Denumire Cantitate Pret Valoare");
p=cap;
while(p)
{
printf("\n%d %s %5.2f %5.2f %5.2f",p->inf.cod, p->inf.denumire, p>inf.cantitate, p->inf.pret,(p->inf.cantitate)*(p->inf.pret));
val+=(p->inf.cantitate)*(p->inf.pret);
p=p->next;
}
printf("\nValoare totala=%5.2f",val);
}
void main()
{
nod *cap=NULL;
int n;
printf("Numar produse=");

scanf("%d",&n);
cap=crearelista(cap,n);
traversare(cap);
getch();
}

#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<malloc.h>
//structura de tip student
struct student
{
int Cod_student;
char *Nume_student;
float Nota_romana;
float Nota_mate;
float Nota_fizica;
};
//nod pt articolul student
struct nod
{
student info;
struct nod *next;
};
//creare lista

nod* crearelista(nod *cap, int n)

{
nod *p, *q;
char buffer[25];
cap = (nod*)malloc(sizeof(nod));
printf("Cod_student=");
scanf("%d", &cap->info.Cod_student);
printf("Nume_student=");
scanf("%s", buffer);
cap->info.Nume_student = (char*)malloc((strlen(buffer) + 1)*sizeof(char));
strcpy(cap->info.Nume_student, buffer);
printf("Nota_romana=");
scanf("%f", &cap->info.Nota_romana);
printf("Nota_mate=");
scanf("%f", &cap->info.Nota_mate);
printf("Nota_fizica=");
scanf("%f", &cap->info.Nota_fizica);
cap->next = NULL;
p = cap;
for (int i = 1; i < n; i++)
{
q = (nod*)malloc(sizeof(nod));
printf("Cod_student=");
scanf("%d", &q->info.Cod_student);
printf("Nume_student=");
scanf("%s", buffer);
q->info.Nume_student = (char*)malloc((strlen(buffer) + 1)*sizeof(char));
strcpy(q->info.Nume_student, buffer);
printf("Nota_romana=");
scanf("%f", &q->info.Nota_romana);
printf("Nota_mate=");
scanf("%f", &q->info.Nota_mate);
printf("Nota_fizica=");
scanf("%f", &q->info.Nota_fizica);
q->next = NULL;
p->next = q;
p = q;
}
return cap;
}
//traversam articolul student
void traversare(nod *cap)
{
nod *p;
printf("\nCod_student Nume_student Nota_romana Nota_mate Nota_fizica
Medie_BAC");
printf("\n");
p = cap;
while (p)
{
printf("\n%d %s %5.2f %5.2f %5.2f %5.2f", p->info.Cod_student, p>info.Nume_student, p->info.Nota_romana, p->info.Nota_romana, p->info.Nota_fizica,
((p->info.Nota_romana) + (p->info.Nota_mate) + (p->info.Nota_fizica)) / 3);
p = p->next;
}
}
void main()
{

nod *cap=NULL;
int n;
printf("Introduceti numarul de studenti=");
scanf("%d", &n);
cap = crearelista(cap, n);
traversare(cap);
_getch();
}

//lista simplu inlantuita care are campurile cod, denumire, cantitate, pret. In aceasta lista simplu
inlantuita se adauga un nod nou si se afiseaza din nou lista

#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
struct produs
{
int cod;
char *denumire;
float cantitate;
float pret;
};
struct nod
{

produs inf;
struct nod* next;
};
nod* crearelista(nod *cap, int n)
{
nod *p, *q;
char buffer[20];
cap = (nod*)malloc(sizeof(nod));
printf("\n");
printf("Codul=");
scanf("%d", &cap->inf.cod);
printf("Denumirea=");
scanf("%s", buffer);
cap->inf.denumire = (char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(cap->inf.denumire, buffer);
printf("Cantitatea=");
scanf("%f", &cap->inf.cantitate);
printf("Pretul=");
scanf("%f", &cap->inf.pret);
cap->next = NULL;
p = cap;
for (int i = 1; i<n; i++)
{
q = (nod*)malloc(sizeof(nod));
printf("Codul=");
scanf("%d", &q->inf.cod);
printf("Denumirea=");
scanf("%s", buffer);
q->inf.denumire = (char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(q->inf.denumire, buffer);
printf("Cantitatea=");
scanf("%f", &q->inf.cantitate);
printf("Pretul=");
scanf("%f", &q->inf.pret);
q->next = NULL;
p->next = q;
p = q;
}
return cap;
}

//inseram noul nod la sfarsitul listei, vom avea doua capete pt lista, p copiind
adresa la care se afla lista si fiind temporar, pentru ca el va lua pe rand adresa
fiecarui nod pana se va pozitiona pe ultimul nod din lista, dupa care se va face
legatura intre ultimul nod al listei si nodul nou inserat.
void inserare(nod *cap, produs prod)
{
nod *p;
nod *q = (nod*)malloc(sizeof(nod));
//q->inf.cod=prod.cod;
//q->inf.denumire=prod.denumire;
//q->inf.cantitate=prod.cantitate;
//q->inf.pret=prod.pret;
q->inf = prod;
q->next = NULL;
for (p = cap; p->next; p = p->next);
p->next = q;
}
void traversare(nod *cap)

{
nod *p;
float val = 0;
printf("\nCod Denumire Cantitate Pret Valoare");
p = cap;
while (p)
{
printf("\n%d %s %5.2f %5.2f %5.2f", p->inf.cod, p->inf.denumire, p>inf.cantitate, p->inf.pret, (p->inf.cantitate)*(p->inf.pret));
val += (p->inf.cantitate)*(p->inf.pret);
p = p->next;
}
printf("\nValoare totala=%5.2f", val);
}
void main()
{
nod *cap = NULL;
int n;
printf("Numar produse=");
scanf("%d", &n);
cap = crearelista(cap, n);
traversare(cap);
//inseram un nou produs, introducand valori de la tastatura pentru fiecare camp
produs pnou;
char buffer[20];
printf("\nCodul nou=");
scanf("%d", &pnou.cod);
printf("Denumirea noua=");
scanf("%s", buffer);
pnou.denumire = (char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(pnou.denumire, buffer);
printf("Cantitatea noua=");
scanf("%f", &pnou.cantitate);
printf("Pretul nou=");
scanf("%f", &pnou.pret);

Cod
M

Denumire *
Cantitate
Pret

inserare(cap, pnou);
traversare(cap);
_getch();
}

Creati o lista simplu inlantuita si inserati un nod nou la inceputul listei.

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

\n

#include<string.h>
struct produs
{
int cod;
char *denumire;
float cantitate;
float pret;
};
struct nod
{
produs inf;
struct nod* next;
};
nod* crearelista(nod *cap, int n)
{
nod *p, *q;
char buffer[20];
cap = (nod*)malloc(sizeof(nod));
printf("\n");
printf("Codul=");
scanf("%d", &cap->inf.cod);
printf("Denumirea=");
scanf("%s", buffer);
cap->inf.denumire = (char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(cap->inf.denumire, buffer);
printf("Cantitatea=");
scanf("%f", &cap->inf.cantitate);
printf("Pretul=");
scanf("%f", &cap->inf.pret);
cap->next = NULL;
p = cap;
for (int i = 1; i<n; i++)
{
q = (nod*)malloc(sizeof(nod));
printf("Codul=");
scanf("%d", &q->inf.cod);
printf("Denumirea=");
scanf("%s", buffer);
q->inf.denumire = (char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(q->inf.denumire, buffer);
printf("Cantitatea=");
scanf("%f", &q->inf.cantitate);
printf("Pretul=");
scanf("%f", &q->inf.pret);
q->next = NULL;
p->next = q;
p = q;
}
return cap;
}

//inseram noul nod la inceputul listei

//cream un nod nou in care vom pune informatia introdusa de la tastatura din
//programul principal, facem legatura dintre nodul nou creat si capul listei, dupa
care noul cap al listei va avea adresa
//nodului nou creat si se va returna capul listei
nod* inserare(nod *cap, produs prod)
{

nod *q;
q = (nod*)malloc(sizeof(nod));
//q->inf.cod=prod.cod;
//q->inf.denumire=prod.denumire;
//q->inf.cantitate=prod.cantitate;
//q->inf.pret=prod.pret;
q->inf = prod;
q->next = cap;
cap = q;
return cap;
}
void traversare(nod *cap)
{
nod *p;
float val = 0;
printf("\nCod Denumire Cantitate Pret Valoare");
p = cap;
while (p)
{
printf("\n%d %s %5.2f %5.2f %5.2f", p->inf.cod, p->inf.denumire, p>inf.cantitate, p->inf.pret, (p->inf.cantitate)*(p->inf.pret));
val += (p->inf.cantitate)*(p->inf.pret);
p = p->next;
}
printf("\nValoare totala=%5.2f", val);
}
void main()
{
nod *cap = NULL;
int n;
printf("Numar produse=");
scanf("%d", &n);
cap = crearelista(cap, n);
traversare(cap);
//inseram un nou produs, introducand valori de la tastatura pentru fiecare camp
produs pnou;
char buffer[20];
printf("\nCodul nou=");
scanf("%d", &pnou.cod);
printf("Denumirea noua=");
scanf("%s", buffer);
pnou.denumire = (char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(pnou.denumire, buffer);
printf("Cantitatea noua=");
scanf("%f", &pnou.cantitate);
printf("Pretul nou=");
scanf("%f", &pnou.pret);
cap=inserare(cap, pnou);
traversare(cap);
_getch();
}

Inserati un nod nou dupa primul element dintr-o lista simpla inlantuita.
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
using namespace std;
struct produs
{
int cod;
char *denumire;
float cantitate;
float pret;
};
struct nod
{
produs inf;
struct nod* next;
};
nod* crearelista(nod *cap, int n)
{
nod *p, *q;
char buffer[20];
cap = (nod*)malloc(sizeof(nod));
printf("\n");
printf("Codul=");
scanf("%d", &cap->inf.cod);
printf("Denumirea=");
scanf("%s", buffer);
cap->inf.denumire = (char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(cap->inf.denumire, buffer);
printf("Cantitatea=");
scanf("%f", &cap->inf.cantitate);

printf("Pretul=");
scanf("%f", &cap->inf.pret);
cap->next = NULL;
p = cap;
for (int i = 1; i<n; i++)
{
q = (nod*)malloc(sizeof(nod));
printf("Codul=");
scanf("%d", &q->inf.cod);
printf("Denumirea=");
scanf("%s", buffer);
q->inf.denumire = (char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(q->inf.denumire, buffer);
printf("Cantitatea=");
scanf("%f", &q->inf.cantitate);
printf("Pretul=");
scanf("%f", &q->inf.pret);
q->next = NULL;
p->next = q;
p = q;
}
return cap;
}

//inseram noul nod dupa primul element

nod* inserare(nod *cap, produs prod)
{
//cream un nod nou si ii alocam memorie, il vom folosi ca sa memoram primul nod
cu informatie din lista
nod *q;
q=(nod*)malloc(sizeof(nod));
//cream un nod spec care va avea adresa de memorie a capului listei
nod *spec;
spec = (nod*)malloc(sizeof(nod));
//spec va avea adresa de memorie a lui cap
spec = cap;
//facem legatura intre nodul care urmeaza dupa nodul nou inserat in void main si al
treilea nod din lista
q->next = spec->next;
//punem in q informatia pe care am inserat-o
q->inf = prod;
//facem legatura intre primul nod si nodul q=nou
cap->next = q;
return spec;
}
pt n=2(noduri)

cap

inf1
next

inf2
next

NULL

----------------------------------------------------------------

cap

spec

inf1

inf2

next

next

NULL

----------------------------------------------------------------

q
----------------------------------------------------

inf2
inf3
next
next
spec

NULL

cap
q

inf1

inf3

inf2

next

next

next

NULL

void traversare(nod *cap)

{
nod *p;
float val = 0;
printf("\nCod Denumire Cantitate Pret Valoare");
p = cap;
while (p)
{
printf("\n%d %s %5.2f %5.2f %5.2f", p->inf.cod, p->inf.denumire, p>inf.cantitate, p->inf.pret, (p->inf.cantitate)*(p->inf.pret));
val += (p->inf.cantitate)*(p->inf.pret);
p = p->next;
}
printf("\nValoare totala=%5.2f", val);

}
void main()
{
nod *cap = NULL;
nod *spec = NULL;
int n;
printf("Numar produse=");
scanf("%d", &n);
cap = crearelista(cap, n);
traversare(cap);
//inseram un nou produs, introducand valori de la tastatura pentru fiecare camp
produs pnou;
char buffer[20];
printf("\nCodul nou=");
scanf("%d", &pnou.cod);
printf("Denumirea noua=");
scanf("%s", buffer);
pnou.denumire = (char*)malloc(strlen(buffer)+1)*sizeof(char));
strcpy(pnou.denumire, buffer);
printf("Cantitatea noua=");
scanf("%f", &pnou.cantitate);
printf("Pretul nou=");
scanf("%f", &pnou.pret);
spec= inserare(cap, pnou);
printf("gata");
traversare(cap);
_getch();
}

Liste dublu inlantuite(next,

prev)

1.Creati o lista dublu inlantuita care sa aiba noduri in care informatia contine: cod, denumire,
cantitate, pret.
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
#include<string.h>
//cream o structura pt informatia pe care vrem sa o punem in fiecare nod din lista
struct produs
{
int cod;
char *denumire;
float cantitate;
float pret;
};
//cream nodul care va contine informatia de tip produs si 2 pointeri de legatura cu
nodul anterior respectiv urmator
struct nod
{
produs info;
nod *next, *prev;
};
//cream lista dublu inlantuita, cap va retine adresa intregii liste, il folosim pentru
a gasi lista
nod *crearelista(nod *cap, int n)
{
nod *p, *q;
//variabile care sa ne preia din consola valoarea pe care o introducem
int cod1;
float cant1;
float pret1;
//avem nevoie de un vector de caractere, in fiecare elem al lui va fi o litera a
denumirii
char buffer[20];
//introducem informatia pentru nod
printf("Codul=");

scanf("%d", &cod1);
printf("Denumirea=");
scanf("%s", buffer);
printf("Cantitatea=");
scanf("%f", &cant1);
printf("Pretul=");
scanf("%f", &pret1);
//cream primul nod al listei si punem informatia
cap = (nod*)malloc(sizeof(nod));
cap->info.cod = cod1;
cap->info.denumire = (char*)malloc((strlen(buffer) + 1)*sizeof(char));
strcpy(cap->info.denumire, buffer);
cap->info.cantitate = cant1;
cap->info.pret = pret1;
cap->next =NULL;
cap->prev =NULL;
//ii facem o copie lui cap
p = cap;
//pana acum am creat primul nod al listei
//cream al doilea nod al listei
for (int i = 1; i < n; i++)
{
q = (nod*)malloc(sizeof(nod));
printf("Codul=");
scanf("%d", &cod1);
printf("Denumirea=");
scanf("%s", buffer);
printf("Cantitatea=");
scanf("%f", &cant1);
printf("Pretul=");
scanf("%f", &pret1);
//punem ce am introdus in informatia nodului
q->info.cod = cod1;
q->info.denumire = (char*)malloc((strlen(buffer) + 1)*sizeof(char));
//copiem din buffer in informatia din nodul q corespunzatoare pt denumire
strcpy(q->info.denumire, buffer);
q->info.cantitate = cant1;
q->info.pret = pret1;
//facem legatura intre primul si al doilea nod, dar folosim copia pe care
am facut-o lui cap, cap retine adresa inlantuirii de noduri
p->next = q;
//noul nostru p va fi q
q->next = NULL;
q->prev = p;
p = q;
}
return cap; //retine adresa intregii liste
}
//traversam lista pentru a o afisa pe ecran
void traversare(nod *cap)
{
nod *p;
float val = 0;
//in val vom retine valoarea totala a produselor
printf("\nCod Denumire Cantitate Pret Valoare");
p = cap;
while (p)
{
printf("\n%d %s %5.2f %5.2f %5.2f", p->info.cod, p->info.denumire, p>info.cantitate, p->info.pret, (p->info.cantitate)*(p->info.pret));

val = val + (p->info.cantitate)*(p->info.pret);

//ne mutam pe urmatorul nod
p = p->next;
}
printf("\nValoarea totala este %5.2f", val);
}
void main()
{
nod *cap = NULL;
int n;
printf("Introduceti nr de produse=");
scanf("%d", &n);
cap = crearelista(cap, n);
traversare(cap);
_getch();
}

Creati o lista dublu inlantuita in care sa inserati valorile introduse de la tastatura

in structura care este de fapt informatia nodului din lista. Lista avand informatia
:cod, cantitate, pret, denumire.

-introducem de la tastatura valori pt structura noastra (produs inf)

inf

cod

------------------

denumire
cantitate
pret

-inseram informatia inf in informatia nodului ( produs prod)

nou

cap

<---------------------------------------------------------------------------------

prod
prev
next

NULL

-il facem pe nou primul nod

nou

prod
NULL

prev
NULL
next

cap

nou
prod
NULL

prev
next

prod

prev
next

NULL
se plaseaza pe
urmatorul nod

#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
//cream o structura care sa aiba cod, denumire, cantitate, pret, aceasta structura va
fi informatia din nodul nostru
struct produs
{
int cod;
char *denumire;
float cant;
float pret;
};
//facem un nod care are informatia de tipul structurii produs
struct nod
{
produs pr;
struct nod *prev, *next;
};
nod* inserare(nod* cap, produs prod)

{
nod* nou;
nou = (nod*)malloc(sizeof(nod));
nou->pr = prod;
nou->next = NULL;

if (cap == NULL)
{
nou->prev = NULL;
return nou;
}
nod* p;
for (p = cap; p->next; p = p->next);
p->next = nou;
nou->prev = p;
return cap;
}
//traversam lista dublu inlantuita si o afisam pe ecran
void traversare(nod *cap)
{
nod *p;
float val = 0;
printf("\nCod Denumire Cantitate Pret Valoare");
p = cap;
while (p)
{
printf("\n%d %s %5.2f %5.2f %5.2f", p->pr.cod, p->pr.denumire, p>pr.cant, p->pr.pret, (p->pr.cant)*(p->pr.pret));
val += (p->pr.cant)*(p->pr.pret);
p = p->next;
}
printf("\nValoare totala=%5.2f", val);
}
void main()
{
nod *cap = NULL;
int n;
char buffer[20];
produs inf;
printf("Numar produse=");
scanf("%d", &n);
//introducem valorile pt structura inf
for (int i = 0; i<n; i++)
{
printf("Codul=");
scanf("%d", &inf.cod);
printf("Denumirea=");
scanf("%s", buffer);
inf.denumire = (char*)malloc((strlen(buffer) + 1)*sizeof(char));
strcpy(inf.denumire, buffer);
printf("Cantitatea=");
scanf("%f", &inf.cant);
printf("Pretul=");
scanf("%f", &inf.pret);
//inseram informatia care contine valorile pt cod, denumire, pret,
cantitate intr-o lista dublu inlantuita
cap = inserare(cap, inf);
}
traversare(cap);
_getch();

Scrieti un program care creeaza o lista dublu inlantuita in care informatia contine campurile :
cod, denumire, cantitate, pret ca pointeri (int *, char *, float *, float *).
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
struct produs
{
int *cod;
char *denumire;
float *cant;
float *pret;
};
struct nod
{
produs pr;
struct nod *prev, *next;
};
nod* inserare(nod* cap, produs prod)
{
nod* nou;
nou = (nod*)malloc(sizeof(nod));
nou->pr = prod;
nou->next = NULL;
if (cap == NULL)
{
nou->prev = NULL;
return nou;

}
nod* p;
for (p = cap; p->next; p = p->next);
p->next = nou;
nou->prev = p;
return cap;
}
void traversare(nod *cap)
{
nod *p, *q;
float val = 0;
printf("\nCod Denumire Cantitate Pret Valoare");
p = cap;
while (p)
{
printf("\n%d %s %5.2f %5.2f %5.2f", *p->pr.cod, p->pr.denumire, *p>pr.cant, *p->pr.pret, (*p->pr.cant)*(*p->pr.pret));
val += (*p->pr.cant)*(*p->pr.pret);
p = p->next;
}
printf("\nValoare totala=%5.2f", val);
//dezalocare memorie
//se face mai intai dezalocarea fiecarui vector in care am retinut valoarea pt campul
respectiv, si apoi se face dezalocarea pointerului care retine adresa nodului in care
avem informatia respectiva
p = cap;
while (p)
{
q = p->next;
free(p->pr.cod);
free(p->pr.denumire);
free(p->pr.cant);
free(p->pr.pret);
free(p);
p = q;
}
}
void main()
{
nod *cap = NULL;
int n;
char buffer[20];
produs inf;
printf("Numar produse=");
scanf("%d", &n);
for (int i = 0; i<n; i++)
{
printf("Codul=");
inf.cod = (int*)malloc(sizeof(int));
scanf("%d", inf.cod);
printf("Denumirea=");
scanf("%s", buffer);
inf.denumire = (char*)malloc((strlen(buffer) + 1)*sizeof(char));
strcpy(inf.denumire, buffer);
printf("Cantitatea=");
inf.cant = (float*)malloc(sizeof(float));
scanf("%f", inf.cant);
printf("Pretul=");
inf.pret = (float*)malloc(sizeof(float));
scanf("%f", inf.pret);

cap = inserare(cap, inf);

}
traversare(cap);
_getch();
}

//vectori pt lista dublu inlantuita

#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
struct produs
{
int *cod;
char *denumire;
float *cant;
float *pret;
};
struct nod
{
produs pr;
struct nod *prev, *next;
};
nod* conversie(produs *v, int n, nod* cap)
{
nod* nou = (nod*)malloc(sizeof(nod));
nou->pr = v[0];
nou->next = NULL;
nou->prev = NULL;
cap = nou;
nod* p = cap;
for (int i = 1; i<n; i++)
{
nou = (nod*)malloc(sizeof(nod));
nou->pr = v[i];

nou->next = NULL;
nou->prev = p;
p->next = nou;
p = nou;
}
return cap;
}
void traversare(nod *cap)
{
nod *p, *q;
float val = 0;
printf("\nCod Denumire Cantitate Pret Valoare");
p = cap;
while (p)
{
printf("\n%d %s %5.2f %5.2f %5.2f", *p->pr.cod, p->pr.denumire, *p>pr.cant, *p->pr.pret, (*p->pr.cant)*(*p->pr.pret));
val += (*p->pr.cant)*(*p->pr.pret);
p = p->next;
}
printf("\nValoare totala=%5.2f", val);
//dezalocare memorie
/*p=cap;
while(p)
{
q=p->next;
free(p->pr.cod);
free(p->pr.denumire);
free(p->pr.cant);
free(p->pr.pret);
free(p);
p=q;
}*/
}
void main()
{
nod* cap = NULL;
produs *v;
int i, n;
char buffer[20];
printf("Nr. de elemente ale vectorului=");
scanf("%d", &n);
v = (produs*)malloc(n*sizeof(produs));
for (i = 0; i<n; i++)
{
printf("Codul=");
v[i].cod = (int*)malloc(sizeof(int));
scanf("%d", &v[i].cod);
printf("Denumirea=");
scanf("%s", buffer);
v[i].denumire = (char*)malloc((strlen(buffer) + 1)*sizeof(char));
strcpy(v[i].denumire, buffer);
printf("Cantitatea=");
v[i].cant = (float*)malloc(sizeof(float));
scanf("%f", &v[i].cant);
printf("Pretul=");
v[i].pret = (float*)malloc(sizeof(float));
scanf("%f", &v[i].pret);
}

cap = conversie(v, n, cap);

traversare(cap);
//dezalocare memorie
for (i = 0; i<n; i++)
{
free(v[i].cod);
free(v[i].denumire);
free(v[i].cant);
free(v[i].pret);
}
free(v);
_getch();
}

produs

pointer1

cod (vector)

pointer2

pointer3

denumire(vector)

pointer 4

cantitate(vector)

pret(vector)

cap

pr

prev
next

Informatia care se pune in nod este de tip vector: (ex n=2)

v[0]

v[0].cod

v[1]

v[0].denumire

v[0].cant

v[0].pret

nou

cap

punem in informatie primul element al

vectorului in care am introdus
informatie, acesta va fi primul nod al
listei, cap va retine adresa inlantuirii de
noduri, il folosim pe nou ca sa facem
introducem urmatoarele elem din
vector

v[0]
prev

NULL

next

NULL

cap=nou
p=cap
alocam memorie pt nou pentru a introduce urmatorul element din vector
nou

v[1]
prev

next

NULL

p=nou => se pozitioneaza pe urmatorul nod

cap

NULL

v[0]

v[1]

prev

prev

next

next
NULL

//alta metoda de a face o lista dublu inlantuita sub forma unei matrici si folosind conversia
dupa
matrice cu doua linii si o coloana

j
i
a[0][0].cod a[0][1].denumire

a[1][0]

a[1][1]

a[0][2].cant

a[1][2]

a[0][3].pret

a[1][3]

pointer care
retine adresa
matricii (a)

#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
struct produs
{
int *cod;
char *denumire;
float *cant;
float *pret;
};
struct nod
{
produs pr;
struct nod *prev, *next;
};
nod* conversie(nod *cap, produs **a, int nrlin, int nrcol)
{
nod *p;
for (int i = 0; i<nrlin; i++)
for (int j = 0; j<nrcol; j++)
{
nod* nou = (nod*)malloc(sizeof(nod));
//nou->pr=a[i][j];

nou->pr.cod = (int*)malloc(sizeof(int));
nou->pr.denumire = (char*)malloc((strlen(a[i][j].denumire) +
1)*sizeof(char));
nou->pr.cant = (float*)malloc(sizeof(float));
nou->pr.pret = (float*)malloc(sizeof(float));
*nou->pr.cod = *a[i][j].cod;
strcpy(nou->pr.denumire, a[i][j].denumire);
*nou->pr.cant = *a[i][j].cant;
*nou->pr.pret = *a[i][j].pret;
if (cap == NULL)
{
nou->next = NULL;
nou->prev = NULL;
cap = nou;
}
else
{
for (p = cap; p->next; p = p->next);
p->next = nou;
nou->prev = p;
nou->next = NULL;
p = nou;
}
}
return cap;
}
void traversare(nod *cap)
{
nod *p, *q;
float val = 0;
printf("\nCod Denumire Cantitate Pret Valoare");
p = cap;
while (p)
{
printf("\n%d %s %5.2f %5.2f %5.2f", *p->pr.cod, p->pr.denumire, *p>pr.cant, *p->pr.pret, (*p->pr.cant)*(*p->pr.pret));
val += (*p->pr.cant)*(*p->pr.pret);
p = p->next;
}
printf("\nValoare totala=%5.2f", val);
//dezalocare memorie
p = cap;
while (p)
{
q = p->next;
free(p->pr.cod);
free(p->pr.denumire);
free(p->pr.cant);
free(p->pr.pret);
free(p);
p = q;
}
}
void main()
{
nod* cap = NULL;
produs **a;
int n, m, i, j;
char buffer[20];
printf("\nNr. linii=");

scanf("%d", &n);
printf("\nNr. coloane=");
scanf("%d", &m);
a = (produs**)malloc(n*sizeof(produs*));
for (i = 0; i<n; i++)
a[i] = (produs*)malloc(m*sizeof(produs));
for (i = 0; i<n; i++)
for (j = 0; j<m; j++)
{
printf("Codul=");
a[i][j].cod = (int*)malloc(sizeof(int));
scanf("%d", a[i][j].cod);
printf("Denumirea=");
scanf("%s", buffer);
a[i][j].denumire = (char*)malloc((strlen(buffer) + 1)*sizeof(char));
strcpy(a[i][j].denumire, buffer);
printf("Cantitatea=");
a[i][j].cant = (float*)malloc(sizeof(float));
scanf("%f", a[i][j].cant);
printf("Pretul=");
a[i][j].pret = (float*)malloc(sizeof(float));
scanf("%f", a[i][j].pret);
}
cap = conversie(cap, a, n, m);
traversare(cap);
//dezalocare memorie
for (i = 0; i<n; i++)
{
for (j = 0; j<m; j++)
{
free(a[i][j].cod);
free(a[i][j].denumire);
free(a[i][j].cant);
free(a[i][j].pret);
}
free(a[i]);
}
free(a);
_getch();
}

a[0]

prev

prev

a[0][0].cod

a[0][1].cod

a[0][0].den

a[0][1].den

a[0][0].cant

a[0][1].cant

a[0][0].pret

a[0][1].pret

next

next

a[1]

prev

prev

a[1][0].cod

a[1][1].cod

a[1][0].den

a[1][1].den

a[1][0].cant

a[1][1].cant

a[1][0].pret

a[1][1].pret

next

next

cap

NULL

prev

prev

prev

prev

a[0][0].cod

a[0][1].cod

a[1][0].cod

a[1][1].cod

a[0][0].den

a[0][1].den

a[1][0].den

a[1][1].den

a[0][0].cant

a[0][1].cant

a[1][0].cant

a[1][1].cant

a[0][0].pret

a[0][1].pret

a[1][0].pret

a[1][1].pret

next

next

next

next

NULL

//lista circulara
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
struct produs
{
int *cod;
char *denumire;
float *cant;
float *pret;
};
struct nod
{
produs pr;
struct nod *prev, *next;
};
nod* inserare(nod* cap, produs prod)
{
nod* nou;
nou=(nod*)malloc(sizeof(nod));
if (cap==NULL)
{
nou->pr=prod;
nou->next=nou;
nou->prev=nou;
return nou;
}
nod* p=cap;
while (p->next!=cap)
p=p->next;
nou->pr=prod;
p->next=nou;
nou->prev=p;
nou->next=cap;
cap->prev=nou;
return cap;
}
void traversare(nod *cap)
{
nod *p,*q;
float val=0;
printf("\nCod Denumire Cantitate Pret Valoare");
p=cap;
while(p->next!=cap)
{
printf("\n%d %s %5.2f %5.2f %5.2f",*p->pr.cod, p->pr.denumire, *p>pr.cant, *p->pr.pret, (*p->pr.cant)*(*p->pr.pret));
val+=(*p->pr.cant)*(*p->pr.pret);
p=p->next;
}
printf("\n%d %s %5.2f %5.2f %5.2f",*p->pr.cod, p->pr.denumire, *p->pr.cant,
*p->pr.pret, (*p->pr.cant)*(*p->pr.pret));
val+=(*p->pr.cant)*(*p->pr.pret);
printf("\nValoare totala=%5.2f",val);

//dezalocare memorie
p=cap;
while(p->next!=cap)
{
q=p->next;
free(p->pr.cod);
free(p->pr.denumire);
free(p->pr.cant);
free(p->pr.pret);
free(p);
p=q;
}
free(p->pr.cod);
free(p->pr.denumire);
free(p->pr.cant);
free(p->pr.pret);
free(p);
}
void main()
{
nod *cap=NULL;
int n;
char buffer[20];
produs inf;
printf("Numar produse=");
scanf("%d",&n);
for (int i=0;i<n;i++)
{
printf("Codul=");
inf.cod=(int*)malloc(sizeof(int));
scanf("%d",inf.cod);
printf("Denumirea=");
scanf("%s",buffer);
inf.denumire=(char*)malloc((strlen(buffer)+1)*sizeof(char));
strcpy(inf.denumire,buffer);
printf("Cantitatea=");
inf.cant=(float*)malloc(sizeof(float));
scanf("%f",inf.cant);
printf("Pretul=");
inf.pret=(float*)malloc(sizeof(float));
scanf("%f",inf.pret);
cap=inserare(cap,inf);
}
traversare(cap);
getch();
}

Creati o lista dublu inlantuita care are in informatie: cod, denumire, cantitate, pret (vectori)
si insereaza la inceputul listei un nod nou.
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#include<string.h>
struct produs
{
int *cod;
char *denumire;
float *cant;
float *pret;
};
struct nod
{
produs pr;
struct nod *prev, *next;
};
nod* inserare(nod* cap, produs prod)
{
nod* nou;
nou = (nod*)malloc(sizeof(nod));
nou->pr = prod;
nou->next = NULL;
if (cap == NULL)
{
nou->prev = NULL;
return nou;
}
nod* p;
for (p = cap; p->next; p = p->next);
p->next = nou;
nou->prev = p;
return cap;
}

inserare din structura intr-o

lista, urmatoarea inserare
se face la sfarsitul listei

inserare nod nou la

inceputul listei
nod* inserare_inainte(nod* cap, produs prod)
{
nod* nou;
nou = (nod*)malloc(sizeof(nod));
nou->pr = prod;
nou->prev = NULL;
nou->next = cap;
cap->prev = nou;
cap = nou;
return cap;
}
void traversare(nod *cap)
{
nod *p, *q;
float val = 0;
printf("\nCod Denumire Cantitate Pret Valoare");
p = cap;
while (p)
{
printf("\n%d %s %5.2f %5.2f %5.2f", *p->pr.cod, p->pr.denumire, *p>pr.cant, *p->pr.pret, (*p->pr.cant)*(*p->pr.pret));
val += (*p->pr.cant)*(*p->pr.pret);
p = p->next;
}
printf("\nValoare totala=%5.2f", val);
//dezalocare memorie
/*p=cap;
while(p)
{
q=p->next;
free(p->pr.cod);
free(p->pr.denumire);
free(p->pr.cant);
free(p->pr.pret);
free(p);
p=q;
}*/
}
void main()
{
nod *cap = NULL;
int n;
char buffer[20];
produs inf, k;
printf("Numar produse=");
scanf("%d", &n);
for (int i = 0; i<n; i++)
{
printf("Codul=");
inf.cod = (int*)malloc(sizeof(int));
scanf("%d", inf.cod);
printf("Denumirea=");
scanf("%s", buffer);
inf.denumire = (char*)malloc((strlen(buffer) + 1)*sizeof(char));
strcpy(inf.denumire, buffer);
printf("Cantitatea=");
inf.cant = (float*)malloc(sizeof(float));
scanf("%f", inf.cant);
printf("Pretul=");
inf.pret = (float*)malloc(sizeof(float));

scanf("%f", inf.pret);
cap = inserare(cap, inf);
}
traversare(cap);
printf("\nProdusul de inserat:");
printf("\nCodul=");
k.cod = (int*)malloc(sizeof(int));
scanf("%d", k.cod);
printf("Denumirea=");
scanf("%s", buffer);
k.denumire = (char*)malloc((strlen(buffer) + 1)*sizeof(char));
strcpy(k.denumire, buffer);
printf("Cantitatea=");
k.cant = (float*)malloc(sizeof(float));
scanf("%f", k.cant);
printf("Pretul=");
k.pret = (float*)malloc(sizeof(float));
scanf("%f", k.pret);
cap = inserare_inainte(cap, k);
traversare(cap);
_getch();
}

inserare la inceputul listei

nou

prod

prev
NULL

next

cap

NULL

pr1

pr2

prev

prev

next

next

NULL