LISTA SIMPLU INLANTUITA

#include<iostream>
using namespace std;
struct Rochie{
char *culoare;
int marime;
};
struct Lista{
Rochie *info;
Lista *next;
};
Rochie *creareInfo(char *buffer, int marime)
{
Rochie *info=NULL;
info=(Rochie*)malloc(sizeof(Rochie));
info->culoare=(char*)malloc(strlen(buffer)+1);
strcpy(info->culoare,buffer);
info->marime=marime;
return info;
}
Lista *creareNod(Rochie *info)
{
Lista *nod=NULL;
nod=(Lista*)malloc(sizeof(Lista));
nod->info=info;
nod->next=NULL;
return nod;
}
void inserareNod(Lista *&head, Lista *nod)
{
if(head==NULL)
head=nod;
else
{
Lista *tmp=head;
while(tmp->next!=NULL)
tmp=tmp->next;
tmp->next=nod;
}
}
void parcurgereLista(Lista *head)
{
while(head!=NULL)
{
printf("%s %d\n",head->info->culoare,head->info->marime);
head=head->next;
}
}
void main()
{
FILE *pfile=fopen("Text.txt","r");
Lista *head=NULL;
if(pfile)
{
char buffer[50];
int marime;
fscanf(pfile,"%s",buffer);
while(!feof(pfile))
{
fscanf(pfile,"%d",&marime);

Rochie *info=creareInfo(buffer, marime);

Lista *nod=creareNod(info);
inserareNod(head, nod);
fscanf(pfile,"%s",buffer);
}
fclose(pfile);

}
parcurgereLista(head);
}

LISTA SIMPLU INLANTUITA CIRCULARA

#include<iostream>
using namespace std;
struct Rochie{
char *culoare;
int marime;
};
struct Lista{
Rochie *info;
Lista *next;
};
Rochie *creareInfo(char *buffer, int marime)
{
Rochie *info=NULL;
info=(Rochie*)malloc(sizeof(Rochie));
info->culoare=(char*)malloc(strlen(buffer)+1);
strcpy(info->culoare,buffer);
info->marime=marime;
return info;
}
Lista *creareNod(Rochie *info)
{
Lista *nod=NULL;
nod=(Lista*)malloc(sizeof(Lista));
nod->info=info;
nod->next=NULL;
return nod;
}
void inserareNod(Lista *&head, Lista *nod)
{
if(head==NULL)
{
head=nod;
nod->next=head;
}
else
{
Lista *tmp=head;
while(tmp->next!=head)
tmp=tmp->next;
tmp->next=nod;
nod->next=head;
}
}
void parcurgereLista(Lista *head)
{
Lista *tmp=head;

while(tmp->next!=head)
{
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
tmp=tmp->next;
}
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);

}
void main()
{
FILE *pfile=fopen("Text.txt","r");
Lista *head=NULL;
if(pfile)
{
char buffer[50];
int marime;
fscanf(pfile,"%s",buffer);
while(!feof(pfile))
{
fscanf(pfile,"%d",&marime);

Rochie *info=creareInfo(buffer, marime);

Lista *nod=creareNod(info);
inserareNod(head, nod);
fscanf(pfile,"%s",buffer);
}
fclose(pfile);
}
parcurgereLista(head);
}

STIVA implementare ca LISTA SIMPLU

INLANTUITA CIRCULARA
#include<iostream>
using namespace std;
struct Rochie{
char *culoare;
int marime;
};
struct Lista{
Rochie *info;
Lista *next;
};
Rochie *creareInfo(char *buffer, int marime)
{
Rochie *info=NULL;
info=(Rochie*)malloc(sizeof(Rochie));
info->culoare=(char*)malloc(strlen(buffer)+1);
strcpy(info->culoare,buffer);
info->marime=marime;
return info;
}
Lista *creareNod(Rochie *info)
{
Lista *nod=NULL;

nod=(Lista*)malloc(sizeof(Lista));
nod->info=info;
nod->next=NULL;
return nod;

}
void inserareNod(Lista *&head, Lista *nod)
{
if(head==NULL)
{
head=nod;
nod->next=head;
}
else
{
Lista *tmp=head;
while(tmp->next!=head)
tmp=tmp->next;
tmp->next=nod;
nod->next=head;
}
}
void parcurgereLista(Lista *head)
{
Lista *tmp=head;
while(tmp->next!=head)
{
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
tmp=tmp->next;
}
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
}
Lista *popNod(Lista *&head)
{
Lista *element=NULL;
if(head!=NULL)
{
Lista *tmp=head;
if(tmp->next!=head)
{
while(tmp->next->next!=head)
tmp=tmp->next;
element=tmp->next;
tmp->next=head;
}
else
{
element=tmp;
head=NULL;
}
}
return element;
}
void main()
{
FILE *pfile=fopen("Text.txt","r");
Lista *head=NULL;
if(pfile)
{
char buffer[50];
int marime;
fscanf(pfile,"%s",buffer);
while(!feof(pfile))
{

fscanf(pfile,"%d",&marime);
Rochie *info=creareInfo(buffer, marime);
Lista *nod=creareNod(info);
inserareNod(head, nod);
fscanf(pfile,"%s",buffer);
}
fclose(pfile);
}
parcurgereLista(head);
while(head!=NULL)
{
Lista *element=popNod(head);
printf("%s %d\n",element->info->culoare,element->info->marime);
printf("-------------------\n");
}
}

LISTA DUBLU INLANTUITA

#include<iostream>
using namespace std;
struct Rochie{
char *culoare;
int marime;
};
struct Lista{
Rochie *info;
Lista *next;
Lista *prev;
};
Rochie *creareInfo(char *buffer, int marime)
{
Rochie *info=NULL;
info=(Rochie*)malloc(sizeof(Rochie));
info->culoare=(char*)malloc(strlen(buffer)+1);
strcpy(info->culoare,buffer);
info->marime=marime;
return info;
}
Lista *creareNod(Rochie *info)
{
Lista *nod=NULL;
nod=(Lista*)malloc(sizeof(Lista));
nod->info=info;
nod->next=NULL;
nod->prev=NULL;
return nod;
}
void inserareNod(Lista *&head, Lista *nod)
{
if(head==NULL)
head=nod;
else
{
Lista *tmp=head;
while(tmp->next!=NULL)
tmp=tmp->next;

tmp->next=nod;
nod->prev=tmp;

}
}
void parcurgereLista(Lista *head)
{
while(head->next!=NULL)
{
printf("%s %d\n",head->info->culoare,head->info->marime);
head=head->next;
}
printf("%s %d\n",head->info->culoare,head->info->marime);
printf("--------------------\n");
while(head!=NULL)
{
printf("%s %d\n",head->info->culoare,head->info->marime);
head=head->prev;
}
}
void main()
{
FILE *pfile=fopen("Text.txt","r");
Lista *head=NULL;
if(pfile)
{
char buffer[50];
int marime;
fscanf(pfile,"%s",buffer);
while(!feof(pfile))
{
fscanf(pfile,"%d",&marime);
Rochie *info=creareInfo(buffer, marime);
Lista *nod=creareNod(info);
inserareNod(head, nod);
fscanf(pfile,"%s",buffer);
}
fclose(pfile);
}
parcurgereLista(head);
}

LISTA DUBLU INLANTUITA CIRCULARA

#include<iostream>
using namespace std;
struct Rochie{
char *culoare;
int marime;
};
struct Lista{
Rochie *info;
Lista *next;
Lista *prev;
};
Rochie *creareInfo(char *buffer, int marime)
{
Rochie *info=NULL;

info=(Rochie*)malloc(sizeof(Rochie));
info->culoare=(char*)malloc(strlen(buffer)+1);
strcpy(info->culoare,buffer);
info->marime=marime;
return info;
}
Lista *creareNod(Rochie *info)
{
Lista *nod=NULL;
nod=(Lista*)malloc(sizeof(Lista));
nod->info=info;
nod->next=NULL;
nod->prev=NULL;
return nod;
}
void inserareNod(Lista *&head, Lista *nod)
{
if(head==NULL)
{
head=nod;
nod->next=head;
nod->prev=head;
}
else
{
nod->next=head;
nod->prev=head->prev;
head->prev=nod;
nod->prev->next=nod;
}
}
void parcurgereLista(Lista *head)
{
Lista *tmp=head;
while(tmp->next!=head)
{
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
tmp=tmp->next;
}
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
printf("--------------------\n");
while(tmp!=head)
{
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
tmp=tmp->prev;
}
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
}
void main()
{
FILE *pfile=fopen("Text.txt","r");
Lista *head=NULL;
if(pfile)
{
char buffer[50];
int marime;
fscanf(pfile,"%s",buffer);
while(!feof(pfile))
{
fscanf(pfile,"%d",&marime);
Rochie *info=creareInfo(buffer, marime);
Lista *nod=creareNod(info);

inserareNod(head, nod);
fscanf(pfile,"%s",buffer);
}
fclose(pfile);
}
parcurgereLista(head);
}

COADA implementata ca LISTA DUBLU

INLANTUITA CIRCULARA
#include<iostream>
using namespace std;
struct Rochie{
char *culoare;
int marime;
};
struct Lista{
Rochie *info;
Lista *next;
Lista *prev;
};
Rochie *creareInfo(char *buffer, int marime)
{
Rochie *info=NULL;
info=(Rochie*)malloc(sizeof(Rochie));
info->culoare=(char*)malloc(strlen(buffer)+1);
strcpy(info->culoare,buffer);
info->marime=marime;
return info;
}
Lista *creareNod(Rochie *info)
{
Lista *nod=NULL;
nod=(Lista*)malloc(sizeof(Lista));
nod->info=info;
nod->next=NULL;
nod->prev=NULL;
return nod;
}
void inserareNod(Lista *&head, Lista *nod)
{
if(head==NULL)
{
head=nod;
nod->next=head;
nod->prev=head;
}
else
{
nod->next=head;
nod->prev=head->prev;
head->prev=nod;
nod->prev->next=nod;

}
}
void parcurgereLista(Lista *head)
{
Lista *tmp=head;
while(tmp->next!=head)
{
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
tmp=tmp->next;
}
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
printf("--------------------\n");
while(tmp!=head)
{
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
tmp=tmp->prev;
}
printf("%s %d\n",tmp->info->culoare,tmp->info->marime);
}
Lista *getNod(Lista *&head)
{
Lista *tmp=head;
if(head->next==head && head->prev==head)
head=NULL;
else
{
head=head->next;
head->prev=tmp->prev;
head->prev->next=head;
}
return tmp;
}
void main()
{
FILE *pfile=fopen("Text.txt","r");
Lista *head=NULL;
if(pfile)
{
char buffer[50];
int marime;
fscanf(pfile,"%s",buffer);
while(!feof(pfile))
{
fscanf(pfile,"%d",&marime);
Rochie *info=creareInfo(buffer, marime);
Lista *nod=creareNod(info);
inserareNod(head, nod);
fscanf(pfile,"%s",buffer);
}
fclose(pfile);

}
parcurgereLista(head);

while(head!=NULL)
{
Lista *element=getNod(head);
printf("%s %d\n",element->info->culoare,element->info->marime);
printf("-------------------\n");
}

HASHTABLES
#include<iostream>
using namespace std;
struct Rochie{
char *culoare;
int marime;
};
struct Lista{
Rochie *info;
Lista *next;
};
struct HashTable{
Lista **vector;
int nrElemente;
};
void initHashTable(HashTable &htab, int dim)
{
htab.nrElemente=dim;
htab.vector=(Lista**)malloc(sizeof(Lista*)*dim);
memset(htab.vector, 0,sizeof(Lista*)*dim);
}
int fct_hash(int cheie, int dim)
{
return cheie%dim;
}
Rochie *creareInfo(char *buffer, int marime)
{
Rochie *info=NULL;
info=(Rochie*)malloc(sizeof(Rochie));
info->culoare=(char*)malloc(strlen(buffer)+1);
strcpy(info->culoare,buffer);
info->marime=marime;
return info;
}
Lista *creareNod(Rochie *info)
{
Lista *nod=NULL;
nod=(Lista*)malloc(sizeof(Lista));
nod->info=info;
nod->next=NULL;
return nod;
}
void inserareLista(HashTable &htab, Lista *nod)
{
if(htab.vector!=NULL)
{
int pozitie=fct_hash(nod->info->marime, htab.nrElemente);
Lista *lista=htab.vector[pozitie];
nod->next=lista;
lista=nod;
htab.vector[pozitie]=lista;
}

}
void parcurgereHashTable(HashTable htab)
{
if(htab.vector!=NULL)

>marime);

for( int i =0;i<htab.nrElemente;i++)

{
if(htab.vector[i]!=NULL)
{
printf(" Lista nr %d\n",i);
Lista *tmp=htab.vector[i];
while(tmp!=NULL)
{
printf(" %s %d\n",tmp->info->culoare,tmp->info}
}

tmp=tmp->next;

}
}
Lista *getElementHashTable(HashTable htab, int cheie)
{
int pozitie=fct_hash(cheie, htab.nrElemente);
Lista *lista=htab.vector[pozitie];
return lista;
}
void main()
{
FILE *pfile=fopen("Text.txt","r");
HashTable htab;
initHashTable(htab, 30);
if(pfile)
{
char buffer[50];
int marime;
fscanf(pfile,"%s",buffer);
while(!feof(pfile))
{
fscanf(pfile,"%d",&marime);
Rochie *info=creareInfo(buffer, marime);
Lista *nod=creareNod(info);
inserareLista(htab, nod);
fscanf(pfile,"%s",buffer);
}
fclose(pfile);

}
parcurgereHashTable(htab);
printf("----------\n");

Lista *elemente=getElementHashTable(htab, 44);

while(elemente!=NULL)
{
printf(" %s %d\n",elemente->info->culoare,elemente->info->marime);
elemente=elemente->next;
}
}

ARBORI BINARI DE CAUTARE

#include<iostream>
using namespace std;
struct Rochie{

char *culoare;
int marime;

};
struct NodArbore{
Rochie *info;
NodArbore *stang;
NodArbore *drept;
};
Rochie *creareInfo(char *buffer, int marime)
{
Rochie *info=NULL;
info=(Rochie*)malloc(sizeof(Rochie));
info->culoare=(char*)malloc(strlen(buffer)+1);
strcpy(info->culoare,buffer);
info->marime=marime;
return info;
}
NodArbore *creareNod(Rochie *info)
{
NodArbore *nod=NULL;
nod=(NodArbore*)malloc(sizeof(NodArbore));
nod->info=info;
nod->stang=nod->drept=NULL;
return nod;
}
void inserareNodArbore(NodArbore *&radacina, NodArbore *nod)
{
if(radacina==NULL)
radacina=nod;
else
if(strcmp(nod->info->culoare,radacina->info->culoare)<0)
inserareNodArbore(radacina->stang,nod);
else
if(strcmp(nod->info->culoare,radacina->info->culoare)>0)
inserareNodArbore(radacina->drept,nod);
}
int max(int a, int b)
{
return (a>b)? a:b;
}
int getInaltime(NodArbore *radacina)
{
if(radacina!=NULL)
return 1+max(getInaltime(radacina->drept),getInaltime(radacina->stang));
else
return 0;
}
void parcurgereRSD(NodArbore *radacina)
{
if(radacina!=NULL)
{
printf("%s \n",radacina->info->culoare);
parcurgereRSD(radacina->stang);
parcurgereRSD(radacina->drept);
}
}
void parcurgereSRD(NodArbore *radacina)
{
if(radacina!=NULL)
{
parcurgereSRD(radacina->stang);
printf("%s \n",radacina->info->culoare);

parcurgereSRD(radacina->drept);
}

void parcurgereSDR(NodArbore *radacina)

{
if(radacina!=NULL)
{
parcurgereSDR(radacina->stang);
parcurgereSDR(radacina->drept);
printf("%s \n",radacina->info->culoare);
}
}
void main()
{
FILE *pfile=fopen("Text.txt","r");
NodArbore *radacina=NULL;
if(pfile)
{
char buffer[50];
int marime;
fscanf(pfile,"%s",buffer);
while(!feof(pfile))
{
fscanf(pfile,"%d",&marime);
Rochie *info=creareInfo(buffer, marime);
NodArbore *nod=creareNod(info);
inserareNodArbore(radacina, nod);
fscanf(pfile,"%s",buffer);
}
fclose(pfile);
}
parcurgereRSD(radacina);//preOrdine
printf("----------------\n");
parcurgereSRD(radacina);//inOrdine
printf("----------------\n");
parcurgereSDR(radacina);//postOrdine
printf("----------------\n");
}

printf("Inaltime arbore: %d ",getInaltime(radacina));