DATA STRUCTURES test nr. 10

1. Stergerea pentru lista dubla inseamna:
   a) initializarea cu NULL a pointerului spre primul element al listei duble
   b) dealocarea de zone de memorie element cu element de la primul spre ultimul
   c) dealocarea de zone de memorie de la ultimul element al listei duble catre primul
   d) stergerea unui element din lista dubla
   e) stergerea unui sir compact de elemente din lista dubla
   
   
2. Functia strcmp() este utilizata la:
   
   a) identificarea elementului dupa o cheie definita char [] intr-o procedura de cautare;
   b) identificarea elementului unei liste simple dupa o cheie definita char [] intr-o procedura de cautare;
   c) identificarea elementului dintr-o structura dinamica dupa cheia definita char [] intr-o procedura de cautare;
   d) identificarea dupa cheia definita char [] in procedura de cautare in liste ;
   e) identificarea dupa o cheie definita char [] in procedura:
   struct arb_bin *cautare(pradacina, cheie)
   {
   struct arb_bin *pradacina, *paux;
   int cheie;
   paux=pradacina;
   if(paux)
   {
   if(cheie==paux->info) return(paux);
   cautare(paux->pst,cheie);
   cautare(paux->pdr,cheie);
   }
   else
   return(NULL); }
   
   
   
   
   
3. Prin secventa:
   struct LISTA_SIMPLA {
   int info;
   struct LISTA_SIMPLA *p_urmator;
   }
   a) s-a definit un tip de date de tip articol care se redefineste prin:
   typedef struct LISTA_SIMPLA lista_simpla;
   b) s-a definit tipul articol autoreferit printr-un pointer
   c) sunt create conditii pentru a defini variabilele:
   struct lista_simpla var1, var2, var3, var4, *p_caplista; daca in prealabil s-a efectuat definirea:
   typedef struct LISTA_SIMPLA lista_simpla;
   d) sunt create conditii pentru a defini variabilele:
   struct LISTA_SIMPLA var1, var2, var3, var4, p_caplista;
   e) sunt create conditii pentru a defini variabilele elementare:
   struct LISTA_SIMPLA var1, var2, var3, var4, **p_caplista;
   
   
4. Pentru secventa de program:
   s=0;
   for(i=0;i s+=x[i];
   sunt necesare:
   a) definirile:
   int n;
   int s;
   int x[100];
   b) int n10;
   int s=0=10;
   int x[100];
   c) int n=10=11;
   int s=10=0;
   int x[100];
   d) int n=int s=0;
   int x[100];
   dupa care n si x[i] se initializeaza de la tastatura
   e) int n, errr=0;
   int s;
   int x[100];
   urmate de instructiunile:
   ................
   if(n<0||n>99) errr++; else {
   for(i=0;i if(x[i]<-327 || x[i]>327)errr++;}
   
   
5. Lista simpla se defineste prin
   
   a) struct dlista {
   int informatia_utila;
   struct dlista * p_precedent;
   }
   b) struct s_lista {
   int pointer;
   struct s_lista_ pointer;
   }
   c) struct lista_simpla{
   struct lista_simpla *p_precedent;
   double lista_simpla_;
   }
   d) struct slista{
   int a[10];
   struct slista x;
   struct slista *x;
   }
   e) struct listasimpla {
   struct lista_simpla * p_urmator;
   }
   
   
6. Definirea variabilei pointer cu care se refera primul element al listei simple se realizeaza prin secventa:
   a) struct slista {
   int iutil;
   struct slista *purmator;
   } * p_slista;
   b) struct slista {
   int iutil;
   struct slista *purmator;
   } p_slista;
   c) struct slista {
   int iutil;
   struct slista *purmator;
   }x, * p_slista=x;
   d) struct slista {
   int iutil;
   struct slista *purmator;
   } *x, * p_slista=&x;
   e) struct slista {
   int iutil;
   struct slista *purmator;
   } * p_slista=&slista;
   
   
   
7. Numararea elementelor pozitive dintr-un masiv unidimensional definiti prin
   int x[100];
   se realizeaza prin secventa:
   a) for(i=0;i if(x[i]>0)contor++;
   b) int i=0,contor=0;
   for(i=0;i if(x[i]>0)contor++;
   c) int i=0,
   for(i=0;int contor=0;i if(x[i]>0)contor++;
   d) int i=0,contor=0;
   for(inti=0;i if(x[i]>0)contor++;
   e) int contor=0;
   for(int i=0;i if(x[i]>0)contor++;
   
   
8. Compararea a doua liste simple inseamna:
   a) comparea continutului informatiei utile din cele doua liste simple
   b) comparea lungimilor ca numar de elemente din cele doua liste simple
   c) traversarea structurilor de la primul spre ultimul element
   d) comparea continutului element cu element din cele doua liste simple
   e) apelarea unei proceduri care are doi parametri, cei doi pinteri ce refera, respectiv, primul element fiecarei liste simple; procedura returneaza o variabila booleana
   
   
9. Doua fisiere F1 si F2 sunt diferite daca:
   a) au articole cu lungimi diferite
   b) au etichetele cu lungimi diferite
   c) au toti baitii corespondenti cu continut diferit
   d) au articole cu continut diferit
   e) au lungimi diferite sau cel putin o pereche de baiti corespondenti cu continut diferit
   
   
10. Traversarea unui arbore binar se efectueaza:
    a) inordine sau "stanga-radacina-dreapta";
    b) inordine sau "radacina-stanga-dreapta"
    c) in preordine sau "stanga-dreapta -radacina"
    d) in preordine sau "dreapta-stanga-radacina"
    e) in postordine sau "drepta-radacina-stanga"
    
    
11. Daca arborele binar este definit prin:
    struct arbin{
    int info; // informatia utila
    struct arbin *pst; // pointer spre descendent stang
    struct arbin *pdr; // pointer spre descendent drept
    }
    typedef struct arbin * PARBIN; // definire tip pointer spre arbin
    atunci procedura pentru traversarea inordine este:
    a) void inordine (PARBIN pradacina)
    {
    if(pradacina)
    {
    inordine(pradacina->pst);
    prelucrare(pradacina->info); //procedura utilizator de prelucrare informatie utila
    inordine(pradacina->pdr);
    }
    }
    b) void inordine (PARBIN *pradacina)
    {
    if(pradacina)
    {
    //prelucrare(pradacina); //procedura utilizator de prelucrare informatie utila
    inordine(pradacina->pst);
    prelucrare(pradacina->info); //procedura utilizator de prelucrare informatie utila
    inordine(pradacina->pdr);
    //prelucrare(pradacina); //procedura utilizator de prelucrare informatie utila
    }
    }
    c) void inordine (PARBIN pradacina)
    {
    if(pradacina)
    {
    inordine(pradacina->pdr);
    prelucrare(pradacina->info); //procedura utilizator de prelucrare informatie utila
    intordine(pradacina->pst);
    }
    }
    d) void inordine (PARBIN pradacina)
    {
    if(pradacina)
    {
    inordine(pradacina->pst->pst);
    prelucrare(*pradacina->info); //procedura utilizator de prelucrare informatie utila
    intordine(pradacina->pdr->pdr);
    //prelucrare(pradacina); //procedura utilizator de prelucrare informatie utila
    }
    }
    e) void inordine (PARBIN pradacina)
    {
    if(pradacina)
    {
    inordine(pradacina->pdr);
    prelucrare(pradacina->info); //procedura utilizator de prelucrare informatie utila
    inordine(pradacina->pst);
    }
    }
    
12. Secventa:
    struct dlista {
    int iutil;
    struct dlista *purmator, p_precedent;
    } * p_slista;
    a) defineste tipul de data articol pentru lista dubla
    b)defineste o structura de date utilizabila in construirea unei liste simple
    c) defineste o variabila pointer spre un o structura de tip articol care se initializeaza cu NULL
    d) defineste doua variabile de tip pointer, fiecareia alocandu-i-se cate 2 baiti la definire;
    e) defineste o structura de date autoreferita si o variabila spre tipul structura lista dubla
    
    
13. Daca arborele binar are o radacina R un descendent stang A si un descendent drept B; nodul A are un descendent stang C si un descendent drept D; nodul B adre un descendent stang E si un descendent drept F; nodul D are un descendent stang X un descendent mijlociu XX si un descendent drept Y; nodul F are un descendent stang W si un descendent drept V, atunci:
    a) traversarea dupa regula "stanga-drapta-radacina" inseamna referirea nodurilor
    C X XX Y D A E W V F B R
    b) traversarea in postordine sau inseamna referirea nodurilor
    C X Y D A E W V B F R
    c) traversarea dupa regula "stanga-dreapta-radacina" inseamna referirea nodurilor
    C X XX Y D E A W V F B R
    d) traversarea in postordine inseamna referirea nodurilor
    D A R C B E R X XX Y W V
    e) traversarea dupa regula "stanga-dreapta-radacina" inseamna referirea nodurilorstrict intr-un arbore binar
    
    
    
14. Instructiunea typedef struct dlista * LISTA_DUBLA;
    a) trebuie sa fie precedata de secventa:
    
    structu dlista {
    int informatie_utila;
    struct dlista * p_precedent, *p_urmator;
    }
    b) este utilizata pentru a defini pointerul cu care se refera primul element al listei duble prin:
    LISTA_DUBLA * p_cap_lista_dubla;
    c) se utilizeaza pentru a aloca zona de memorie:
    LISTA_DUBLA pointer_ld;
    .................
    pointer_ld=(LISTA_DUBLA)malloc(sizeof(d_lista));
    d) se utilizeaza pentru a aloca zona de memorie:
    LISTA_DUBLA pointer_ld;
    .................
    pointer_ld=(LISTA_DUBLA)malloc(sizeof(LISTA_DUBLA));
    e) se utilizeaza pentru a aloca zona de memorie:
    LISTA_DUBLA pointer_ld;
    .................
    pointer_ld=(dlista)malloc(sizeof(dlista));
    
    
    
15. Secventa destinata alocarii zonei de memorie corespunzatoare unui element al listei duble este:
    a) o functie de forma:
    struct dlist *creare_element()
    {
    struct dlist *p_capdlist;
    p_capdlist=(struct dlist *)malloc (sizeof(struct dlist));
    return(p_capdlist);
    }
    b) presupune alocare si dealocare de zone de memorie
    c) este obligatoriu sa contina initializarea cu NULL a pointerilor definiti in dlist
    d) inclusa in toate procedurile de stregere a listelor duble
    e) este o functie care are doi parametri: pointerul spre zona de memorie ce trebuie alocata si informatia utila
    
    
16. Pentru dealocarea zonei de memorie corespunzatoare unui element dintr-o lista dubla:
    a) se initializeaza cu NULL cei doi pointeri ai elementului
    b) este suficienta numai distrugerea legaturilor cu celelalte elemente ale listei
    c) se foloseste functia
    void sterge_element (struct dlist * p_caplistadubla){
    free(p_caplistadubla);
    }
    d) se foloseste functia
    void sterge_element (struct dlist * p_caplistadubla){
    free(p_caplistadubla);
    return(p_caplistadubla); }
    e) se foloseste functia
    struct dlist * sterge_element (struct dlist * p_caplistadubla){
    free(p_caplistadubla);
    return (NULL);
    }
    
    
    
17. Pentru testarea daca o lista simpla este vida se procedeaza astfel:
    a) se apeleaza functia:
    int verifica (p_capls)
    struct lista_simpla p_capls;
    {
    return((p_capls->p_urmator == NULL) ? 1: 0);
    }
    b) se apeleaza o functie care returneaza NULL
    c) se apeleaza o functie care numara elementele listei si transmite numarul elementelor gasite, lasand in seama programatorului sa verifice daca numarul gasit este NULL
    d) se testeaza de la stanga la dreapta pointerii spre urmatorul element
    e) se apeleaza functia:
    int verifica (p_capls)
    struct lista_simpla p_capls;
    {
    return((p_capls->p_urmator == NULL) ? 1: 1);
    }
    
    
    
18. pentru adaugarea unui element intr-o lista simpla se utilizeaza procedura:
    a) void adaugare_element(struct slista * p_ls, int valoare)
    {
    struct slista *p_temp;
    p_temp=(struct slista *) malloc (sizeof(struct slista));
    p_temp->informatia_utila=valoare;
    p_temp->urmator=NULL;
    p_ls->urmator=p_temp;
    }
    b) void adaugare_element(struct slista * p_ls, int valoare)
    {
    struct slista *p_temp;
    p_temp=(struct slista *) malloc (sizeof(struct slista));
    p_temp->informatia_utila=&valoare;
    p_temp->urmator=NULL;
    p_ls.urmator=p_temp;
    }
    c) void adaugare_element(struct slista * p_ls, int valoare)
    {
    struct slista *p_temp;
    p_temp=(struct slista *) malloc (sizeof(struct slista));
    p_temp->informatia_utila=valoare;
    p_temp.urmator=NULL;
    p_ls.urmator=p_temp;
    }
    d) void adaugare_element(struct slista * p_ls, int valoare)
    {
    struct slista *p_temp;
    p_temp=(struct slista *) malloc (sizeof(struct slista));
    p_temp->informatia_utila=valoare;
    p_temp->urmator=NULL;
    p_ls->urmator=p_temp->urmator;
    }
    e) void adaugare_element(struct slista * p_ls, int valoare)
    {
    struct slista *p_temp;
    p_temp=(struct slista *) malloc (sizeof(struct slista));
    p_temp.informatia_utila=valoare;
    p_temp.urmator=NULL;
    p_ls.urmator=p_temp;
    }
    
    
    
19. Cautarea intr-o lista simpla este realizata de:
    a) functia cu tre parametri si anume: parametrul unu este pointerul spre caul listei, parametrul doi indica pozitia elementului cautat si parametrul trei da valoarea cheii de cautare
    b) functia care are doi parametri si anume: cheia si pozitia; pointerul cu care se refera primul element este obligatoriu definit variabila statica;
    c) o functie care returneaza NULL d)functia:
    struct slist *( cautare struct slist * plist, valoare)
    {
    struct slist p_temp;
    for(p_temp=plist; p_temp != NULL; p_temp=p_temp->p_urmator)
    if(p_temp->informatia_utila == valoare) return (p_temp);
    return(NULL);
    }
    d) o functie care mai intai traverseaza intrega lista pentru a vedea ca nu este lista vida si dupa aceea se executa cautarea dupa valoare si dupa cheie
    e) functia:
    struct slist *( cautare struct slist * plist, valoare)
    {
    struct slist p_temp;
    for(p_temp=plist; p_temp != NULL; p_temp=p_temp->p_urmator)
    if(p_temp->informatia_utila == valoare) return (p_temp);
    else functia:
    return(NULL);
    }
    
    
20. Inversarea elementelor unui masiv unidimensional
    definit prin:
    ................
    #define K 10 int x[2*K];
    se realizeaza :
    a) inversarea elementelor doua cate doua elemente
    b) folosind variabile de lucru definite prin instructiunea
    int a,b;
    ...............
    a=1/x[i];
    b=1/x[j]:
    x[i]=b;
    x[j]=a;
    ...........
    c) folosind o singura variabila elementara, obligatoriu definita statica temp, prin secventa:
    temp=1/x[i];
    x[i]=1/x[j];
    x[j]=temp;
    d) folosind o singura variabila elementara, obligatoriu denumita temp definita prin
    int temp;
    utilizata prin secventa:
    temp=x[i]-1;
    x[i]=y[j]-1;
    x[j]=temp;
    e)folosind o singura variabila elementara, denumita temp, prin secventa:
    for(i=0; i {
    temp=x[i];
    x[i]=x[2*K-i+1];
    x[2*K-i+1]=temp;
    }
    
    
21. Traversarea unei liste simplu inlantuita este asigurata de implementarea structurii repetitive:
    a)
    paux=pcls;
    while( paux->purm)
    {
    ....................
    paux=paux->purm;
    }
    
    unde:
    pcls - pointer spre adresa primului element al listei simple
    paux - variabila pointer de lucru
    purm - variabila membru in alcatuirea unui element al listei simple,
    care memoreaza adresa urmatorului element al listei
    b)
    pcls=paux;
    while( pcls->purm)
    {
    ....................
    pcls=pcls->purm;
    }
    
    unde:
    pcls - pointer spre adresa primului element al listei simple
    paux - variabila pointer de lucru
    purm - variabila membru in alcatuirea unui element al listei simple,
    care memoreaza adresa urmatorului element al listei
    c)
    while( pcls->purm)
    {
    ....................
    pcls=pcls->purm;
    }
    
    unde:
    pcls - pointer spre adresa primului element al listei simple
    purm - variabila membru in alcatuirea unui element al listei simple,
    care memoreaza adresa urmatorului element al listei
    d) for(pcls=paux; pcls->purm; pcls=pcls->purm)
    unde:
    pcls - pointer spre adresa primului element al listei simple
    paux - variabila pointer de lucru
    purm - variabila membru in alcatuirea unui element al listei simple,
    care memoreaza adresa urmatorului element al listei
    e) for(pcls=paux; pcls->purm!=NULL; pcls=pcls->purm)
    unde:
    pcls - pointer spre adresa primului element al listei simple
    paux - variabila pointer de lucru
    purm - variabila membru in alcatuirea unui element al listei simple,
    care memoreaza adresa urmatorului element al listei
    
    
22. Daca tipul de data pentru o lista simpla este definit prin:
    struct slista
    {
    int info;
    struct slista *peu;
    }
    si daca variabilele pointer pclx, pcly, pclz, pclw definite prin:
    struct slista *cplx, *cply, *cplz, *cplw, *paux;
    contine adresele elementelor consecutive cu pozitiile m, m+1, m+2, m+3 din lista, pentru interschimbul elementelor m+1 si m+2 intre ele este necesara secventa:
    a) paux=cplx.peu;
    pclx=pcly.peu;
    pcly.peu=pclz.peu;
    pclz.peu=paux;
    b) paux=cplx->peu;
    pclx=pcly->peu;
    pcly->peu=pclz>peu;
    pclz->peu=paux;
    c) pclw=cplx.peu;
    pclx=pcly.peu;
    pcly.peu=pclz.peu;
    pclz.peu=pauw;
    d) paux.peu=cplx.peu;
    pclx=pcly.peu;
    pcly.peu=pclz.peu;
    pclz.peu=paux.peu;
    
    e) paux=cplx.peu;
    pclx=pcly.peu;
    pcly.peu=pclz.peu;
    pclz.peu=paux;
    daca s-a efectuat alocare de memorie prin:
    paux=(struct slista *) malloc(sizeof(struct slista)); si s-a efectuat obligatoriu initializarea:
    paux->peu=NULL;
    paux->info=0;
    
    
23. Daca o lista dubla are tipul definit prin:
    typedef struct dlista {
    int info;
    struct dlista *pprec;
    struct dlista *purm;
    } DLISTA;
    a) procedura pentru adaugarea unui element dupa ultimul element preuspune cautarea acestui ultim element
    b) procedura pentru adaugarea unui element dupa ultimul element preuspune cautarea acestui ultim element
    c) procedura pentru adaugarea unui element dupa ultimul element preuspune si initializarile
    pinsert->pprec=NULL;
    pinsert->purm=NULL;
    pinsert->info=valoare;
    d) procedura care se apeleaza pentru adaugarea dupa ultimul este:
    void adaugare(DLISTA *pcld, DLISTA *pinsert) {
    DLISTA paux=pcld;
    while(paux->purm)
    paux=paux->purm;
    paux.purm=pinsert;
    pinsert.pprec=paux;
    }
    dupa ce elementul de inserat are memorie alocata si este initializat
    e) procedura care se apeleaza pentru adaugarea dupa ultimul este:
    void adaugare(DLISTA *pcld) {
    DLISTA *pinsert, *paux=pcld;
    pinsert=(DLISTA *) malloc (sizeof(DLISTA));
    printf("\n initializare informatie utila a elementului lista dubla");
    scanf("%d", pinsert.info);
    pinsert->purm=NULL;
    while(paux->purm)
    paux=paux->purm;
    paux.purm=pinsert;
    pinsert.pprec=paux;
    }