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;
next este pointerul care retine
struct nod* next;
}; adresa unei structuri de tip nod

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));
q->cod = cod1;
q->cant = cant1;
q->pret = pret1;
q->next = NULL;
p->next = q;
p = q;
}
}

void traversare(nod *cap)

{
nod *p;
float val = 0;
printf("\nCod Cantitate Pret Valoare");
p = cap;
while (p)
{
 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;
};

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

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;
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;
}

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
{
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);
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>
#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 inf2

next next
NULL

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

cap spec

inf1 inf2

next next NULL

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

inf2
inf3
next
next NULL
 ----------------------------------------------------

spec 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->next = q;
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

prev
NULL

next NULL

nou
cap p

prod

prev
prev
next
next

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 in cate un vector (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

pointer 4
pointer2 pointer3
pointer1

cod (vector) denumire(vector) cantitate(vector) pret(vector)

cap

pr

prev

next

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

v[0] v[1]

v[0].cod v[0].denumire
v[0].cant v[0].pret
 nou cap
p

punem in informatie primul element al

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

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 p

v[0] v[1]

prev prev
NULL

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

i
a[0][0].cod a[0][1].denumire a[0][2].cant a[0][3].pret

a[1][0] a[1][1] a[1][2] 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();
}
//alocare si dezalocare

#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)

{ inserare din structura intr-o
nod* nou; lista, urmatoarea inserare
nou = (nod*)malloc(sizeof(nod)); se face la sfarsitul listei
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 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

pr1 pr2
NULL prev prev
return nou
next next NULL