Liste simplu înlănțuite by Daniela Nicoleta Dragus

Definiție

danieladragusscoala — 2020-05-04 07:10:05 UTC

Ghiorghioiu Denisa
Lista simplu înlănțuită este structura de reprezentare a informațiilor cea mai cunoscută și implicit cea mai utilizată atunci când ne referim la alocarea dinamică a memoriei.

Imagine listă

danieladragusscoala — 2020-05-04 07:10:33 UTC

Bâja Alexandra

Declarare

danieladragusscoala — 2020-05-04 07:11:13 UTC

Candrea Monica:
struct nod
{tip inf;
nod*leg;}
*prim,*ultim;

Exemplu practic

danieladragusscoala — 2020-05-04 07:11:29 UTC

Robert Oltean

struct nod{
  int info;
  nod * urm;
};

nod * prim = NULL;

Functie creare lista

danieladragusscoala — 2020-05-04 07:11:56 UTC

Tocan Robert
void init(nod *prim)
{ prim=NULL; }

Inserarea unui element la începutul listei- desen

danieladragusscoala — 2020-05-04 07:12:20 UTC

Miruna Mituca

Inserarea unui element la începutul listei-funcție

danieladragusscoala — 2020-05-04 07:14:30 UTC

Vintilă Andreea
void adaug_la_inceput( tip x, nod *prim )

{ nod *p;

p=new nod;

p->inf=x;

p->leg=prim;

prim=p; }

Adăugarea unui element la finalul listei-desen

danieladragusscoala — 2020-05-04 07:16:43 UTC

Diana Oltean

Adăugarea unui element în interiorul listei-desen

danieladragusscoala — 2020-05-04 07:17:41 UTC

Stefan Ana Marina

void adaug_dupa_o_valoare( int x, nod *q)

{nod *p;

p=new LISTA;

p->inf=x;

p->leg=q->leg;
q->leg=p; }

Adăugarea unui element la finalul listei-funcție

danieladragusscoala — 2020-05-04 07:18:56 UTC

void adauga_la_sfarsit( tip x, nod*ultim )

{nod *p;

p=new nod;

p->leg=NULL;

p->inf=x;

ultim->leg=p;

ultim=p; }

Adăugarea unui element în interiorul listei-funcție

danieladragusscoala — 2020-05-04 07:19:16 UTC

Popa Iulia
void adaug_dupa_o_valoare(int x, nod *q)
{nod*p;
p=new lista;
p->inf=x;
p->leg=q->leg;
q->leg=p;}

Funcție parcurgere listă

danieladragusscoala — 2020-05-04 07:19:46 UTC

Popescu Andreea
void parcurgere (nod *prim )

{ nod *p;

p=prim;

while (p!=NULL)

{ cout<inf;

p=p->leg; } }

Funcție ștergere element din listă

danieladragusscoala — 2020-05-04 07:20:22 UTC

Hileaga Maria
-stergerea primului element;
-stergerea ultimului element;
-stergerea unui nod din interiorul listei;
void stergere(nod *r)

{ nod *s,*q;

if (r==prim) {

s=prim;

prim=prim->leg;

delete s; }

else if (r==ultim) {

q=prim;

while (q->leg != ultim)

q=q->leg;

s=ultim;

ultim=q;

ultim->leg=NULL;

delete s; }

else {

s = r->leg;

r->inf = r->leg->inf;

r->leg = r->leg->leg;

delete s; }
}

Stergerea primului element al listei-desen

danieladragusscoala — 2020-05-04 07:20:56 UTC

Fățan Cristina

Stergerea ultimului element al listei- desen

danieladragusscoala — 2020-05-04 07:21:23 UTC

Mihălțan Iulia

Stergerea unui nod din interiorul listei-desen

danieladragusscoala — 2020-05-04 07:21:57 UTC

Galdeanu Nicole
void stergere(nod*r)
{nod *s,*q;
if(r==prim)
s=prim;
prim=prim->leg;
delete s;}
else
if(r==ultim)
{q=prim;
while(q->leg!=ultim)
q=q->leg;
s=ultim;
ultim=q;
ultim->leg=NULL;
delete s;
}
else
{s=r->leg;
r->inf=r->leg->inf;
r->leg=r->leg->leg;
delete s;}}

Crearea unei liste cu numerele dintr-un fisier

danieladragusscoala — 2020-05-04 07:27:10 UTC

Dreghiciu Ana Maria
#include
#include
using namespace std;
struct nod
{
int inf;
nod*leg;
}
*prim,**ultim,*p;
nod*creare()
{
ifstream f("numere.in");
int x;
while(f>>x)
if(prim==NULL)
{
prim=new nod;
prim->inf=x;
prim->leg=NULL;
ultim=prim;
}
else
{ p=new nod;
p->inf=x;
p->leg=NULL;
ultim->leg=p;
ultim=p;
}
f.close();
return prim;
}
void afisare(nod*p)
{
while(p)
{
cout<inf;
p=p->leg;
}
}
int main()
{
prim=creare();
afisare(prim);
return 0;
}

Pb1

danieladragusscoala — 2020-05-04 07:27:42 UTC

George Carpinisan
Fisierul ''numere.in" contine maxim 10000 de numere intregi. Sa se creeze o lista cu numerele prime din fisier.
#include
#include
using namespace std;
int pr(int n)
{ int t=2,ok=1;
while(t<=n/2&&ok)
{
if(n%t==0) ok=0;
t++;
}
return ok;

}
struct nod
{int inf;
nod *leg;}
*prim,*ultim, *p;
nod *creare()
{ ifstream f("numere.in");
int x;
while(f>>x)
if(prim==NULL){if(pr(x)==1){
prim=new nod;
prim->inf=x;
prim->leg=NULL;
ultim=prim;}
}
else{if(pr(x)==1){ p=new nod;
p->inf=x;
p->leg=NULL;
ultim->leg=p;
ultim=p;}}

f.close();
return prim;
}
void afisare( nod *p)
{
while(p)

{
cout<inf<<” “;
p=p->leg;
}
}
int main()
{ prim=creare();
afisare(prim);
return 0;
}

Pb2

danieladragusscoala — 2020-05-04 07:27:49 UTC

Obreja Romana
Fisierul ''numere.in" contine maxim 10000 de numere intregi. Sa se creeze o lista cu numerele pare din fisier.
#include
#include
using namespace std;
struct nod
{ int inf;
nod *leg;
}
*prim,*ultim,*p;
nod *creare()
{ ifstream f("numere.in");
int x;
while(f>>x)
if(prim==NULL && x%2==0)
{
prim=new nod;
prim->inf=x;
prim->leg=NULL;
ultim=prim;
}
else
{
p=new nod;
p->inf=x;
p->leg=NULL;
ultim->leg=p;
ultim=p;
}
f.close();
return prim;
}
void afisare(nod *p)
{ while(p)
{ cout<inf;
p=p->leg;
}

}
int main()
{
prim=creare();
afisare(prim);

return 0;
}

Pb3

danieladragusscoala — 2020-05-04 07:27:53 UTC

Dogar Darius
Să se scrie o funcție C++ care afișează pe ecran valorile pare memorate într-o lista simplu înlănțuită.
void afisare(nod * p)
{
while(p)
{
if(p->info%2==0)
cout<info<<" ";
p=p->urm;
}
}

Pb4

danieladragusscoala — 2020-05-04 07:27:57 UTC

Hindorean Rares
Să se scrie o funcție C++ care adaugă o valoarea la finalul unei liste simplu înlănțuită.

NEW

[12:46 PM]

Pb5

danieladragusscoala — 2020-05-04 07:28:39 UTC

Rablou Gheorghe
Să se scrie o funcție C++ care inserează o anumită valoare după un element dat dintr-o lista simplu înlănțuită.

void inserare(nod * p, nod * q, int x)
{

nod * aux = p, r=new nod;

r->info=x;

while(aux!=NULL && aux!=q)

aux=aux->urm;

if(aux==q)

{
r->urm=q->urm;

q->urm=r;
}
}

Pb6

danieladragusscoala — 2020-05-04 07:28:47 UTC

arsu rares
Să se scrie o funcție C++ care determină câte perechi de elemente consecutive egale sunt memorate într-o lista simplu înlănțuită.

int numarare(nod *p)
{int k=0;
while(p->urm!=NULL)
{int a=p->info;
nod *q=p->urm;
if(q!=NULL)
{int b=q->info;
if(a==b) k++;}
p=p->urm;}
return k;}

Pb7

danieladragusscoala — 2020-05-04 07:28:51 UTC

Botanel Mirona
Sa se creeze o lista cu numerele impare din fisierul "numere.in".
#include

#include

using namespace std;

struct nod

{int inf;

nod *leg;}

*prim,*ultim, *p;

nod *creare()

{ifstream f("numere.in");

int x;

while(f>>x)

if(prim==NULL)

if(x%2==1)

{{prim=new nod;

prim->inf=x;

prim->leg=NULL;

ultim=prim;}

else

{p=new nod;

p->inf=x;

p->leg=NULL;

ultim->leg=p;

ultim=p;}}

f.close();

return prim;}

void afisare( nod *p)

{while(p)

{cout<inf;

p=p->leg;}}

int main()

{prim=creare();

afisare(prim);

return 0;}

Pb8

danieladragusscoala — 2020-05-04 07:28:55 UTC

DAVID ROLAND
Sa se creeze o lista cu numerele divizibile cu 3 din fisierul "numere.in".
#include

#include

using namespace std;

struct nod

{int inf;

nod *leg;}

*prim,*ultim, *p;

nod *creare()

{ifstream f("numere.in");

int x;

while(f>>x)

if(prim==NULL)

if(x%3==0)

{{prim=new nod;

prim->inf=x;

prim->leg=NULL;

ultim=prim;}

else

{p=new nod;

p->inf=x;

p->leg=NULL;

ultim->leg=p;

ultim=p;}}

f.close();

return prim;}

void afisare( nod *p)

{while(p)

{cout<inf;

p=p->leg;}}

int main()

{prim=creare();

afisare(prim);

return 0;}

Pb9

danieladragusscoala — 2020-05-04 07:28:59 UTC

Baraian Adrian
Să se scrie o funcție C++ care determină câte perechi de elemente prime între ele sunt memorate într-o lista simplu înlănțuită.

int numarare(nod *p)
{int k=0;
while(p->urm!=0)
{int x=p->info;
nod*q=p->urm;
while(q)
{int a=x;
int b=q->info;
while(a!=b)
{if(a>b)
a=a-b;
else
b=b-a;}
if(a==1)k++;
q=q->urm;}
p=p->urm;}
return k;}

Pb10

danieladragusscoala — 2020-05-04 07:29:02 UTC

Daichendt Ioana
Să se scrie o funcție C++ care determina și returnează suma elementelor impare situate între două elemente pare din lista pentru care primul element are adresa memorată în pointerul p.

#include 

using namespace std;

int suma(nod*p)
{
    if(p==NULL||p->urm==NULL||p->urm->urm==NULL)
        return 0;
    else {
        int s=0;
        nod *q=p, *r=p->urm, *t=r->urm;
        if((q->info)%2==0&&(t->info)%2==0&&(r->info)%2!=0) s=s+r->info;
        while(t->urm!=NULL){q=q->urm;
                            t=t->urm;
                            r=r->urm;
                            if((q->info)%2==0&&(t->info)%2==0&&(r->info)%2!=0) s=s+r->info;
                           }
 return s;
    }
}

Pb11

danieladragusscoala — 2020-05-04 07:29:06 UTC

Draghici Alex
Se considera o lista liniara simplu inlantuita. Sa se stearga toate elementele pare din lista.

#include
#include
using namespace std;
struct nod
{int inf;
nod *leg;}
*prim,*ultim, *p;
void stergere(nod *r)
{ nod *s,*q;

if(r==prim)
{
s=prim;
prim=prim->leg;
delete s;
}
else if (r==ultim)
{
q=prim;
while (q->leg != ultim)
q=q->leg;
s=ultim;
ultim=q;
ultim->leg=NULL;
delete s;
}
else
{
s = r->leg;
r->inf = r->leg->inf;
r->leg = r->leg->leg;
delete s; }
}
nod *creare()
{ ifstream f("numere.in");
int x;
while(f>>x)
if(prim==NULL){
prim=new nod;
prim->inf=x;
prim->leg=NULL;
ultim=prim;
if(x%2==0) stergere(prim);
}
else{ p=new nod;
p->inf=x;
p->leg=NULL;
ultim->leg=p;
ultim=p;
if(x%2==0) stergere(p);}

f.close();
return prim;
}

void afisare( nod *p)
{
while(p)
{
cout<inf;
p=p->leg;
}
}
int main()
{ prim=creare();
afisare(prim);
return 0;
}

Pb12

danieladragusscoala — 2020-05-04 07:29:10 UTC

Jian Valentin
Să se scrie o funcție C++ care adaugă o valoare la începutul unei liste simplu înlănțuită.

void adaugare (nod * &p, int x)
{ if(p==NULL)
{
p = new nod;
p->info=x;
p->urm=NULL;
}
else
{nod * t = new nod;
t -> info = x;
t -> urm = p;
p = t;}
}

Pb13

danieladragusscoala — 2020-05-04 07:29:13 UTC

Schiau Dragos
Să se scrie o funcție C++ care șterge dintr-o lista simplu înlănțuită elementul situat după un element dat.

void sterge(nod *p, nod *q) 
{
if(p==NULL)
return;
if(p->urm==NULL) 
if(p==q) 
{
delete p;
return;
}
while(p!=NULL&&p!=q) 
p=p->urm;
if(p==q )
if(p->urm!=NULL)
if(p->urm->urm!=NULL) 
{
if(p->urm->urm==NULL)
return;
p->urm=p->urm->urm;
}
}

Pb14

danieladragusscoala — 2020-05-04 07:29:17 UTC

Cosma Tudor

Sa se creeze o lista liniara simplu inlantuita care contine elemente intregi citite dintr-ul fisier text.
Se citeste apoi o valoare intreaga x. Sa se stearga primul nod care contine valoarea x.

#include
#include
using namespace std;
ifstream f("l.in");
struct nod{
       int info;
       nod* urm;
       };
nod *prim, *ultim;

void adaugs(int  x)
{
     nod*nou=new nod;
     nou->info=x;
     nou->urm=NULL;
     if(prim==NULL) prim=nou;
     else ultim->urm=nou;
     ultim=nou;
}       

void afis()
{ nod *p=prim;
  while(p)
  { cout<info<<" ";
    p=p->urm;
  }  
}

void stergere(int x)
{
     nod *p,*q;
     p=prim;
     while(p->urm!=NULL && p->urm->info!=x) p=p->urm;
     if(p->urm==NULL) cout<<"Nu s-a gasit valoarea cautata";
     else
     { q=p->urm;
       p->urm=q->urm;
       delete q;
     }
}

int main()
{
    int x,v;
    prim=NULL;
    ultim=NULL;
    while(f>>x) adaugs(x);
    afis();
    cout<>x;
    stergere(x);
    afis();
    return 0;
}

Pb15

danieladragusscoala — 2020-05-04 07:29:21 UTC

Muntean Iunia

O librarie are nevoie de un software de organizare a cartilor. Acest program trebuie sa contina urmatoarele caracteristici:
1. Sa poata adauga inregistrari noi
2. Sa afiseze inregistrarile existente
3. Sa afiseze cartile de pe stoc
4. Sa modifice inregistrarile existente
5. Sa stearga inregistrari la alegere

O inregistrare reprezinta un nod al unei liste simplu inlantuite, care contine titlul cartii, numele autorului si ,,In_Sock” daca se gaseste cartea pe stoc, respectiv ,,Out_of_Stock” daca nu. Inregistrarile nu vor contine spatii, in loc se va folosi caracterul “_”. Se va folosi un fisier pentru citire si scriere, “books. txt”.