DATA STRUCTURES test nr. 15

1. Transpusa matricei rare avand k elemente nenule, k<=37 definita prin secventa:
   struct matrice_rara{
   int linie;
   int coloana;
   int valoare;
   } a[37];
   se obtine prin:
   a) secventa de instructiuni:
   for(i=0;i aux=a[k].linie;
   a[k].linie=a[k].coloana;
   a[k].coloana=aux;
   }
   b)interschimbul liniilor cu coloanele din matrice
   c) procedura care are patru parametri ce corespund vectorilor pentru linie, coloana, valoare si, respectiv, numarului de elemente nenule
   d)se obtine prin secventa de instructiuni:
   while(k){
   aux=a[k].linie;
   a[k].linie=a[k].coloana;
   a[k].coloana=aux;
   k--;
   }
   e)se obtine prin secventa de instructiuni:
   while(k){
   aux=a[k].linie;
   a[k].linie=a[k].coloana;
   a[k].coloana=aux;
   k++;
   }
   
   
2. Functia strcmp() este utilizata la:
   a) identificarea dupa cheia definita char [] in procedura:
   struct dlista *cautare(struct dlista *pcld, cheie)
   {
   struct dlista *paux;
   int *cheie;
   paux=pcld;
   if(paux)
   {
   if(*cheie==paux->info) return(*paux);
   cautare(paux->purm,cheie);
   }
   else
   return(NULL); }
   
   b) identificarea dupa cheia definita char [] in procedura:
   struct dlista *cautare(p_ultim, cheie)
   {
   struct dlista *p_ultim, *paux;
   int cheie;
   paux=p_ultim;
   if(paux)
   {
   if(cheie==paux->info) return(*paux);
   cautare(paux->p_precedent,cheie);
   }
   else
   return(0); }
   
   daca p_ultim contine adresa ultimului element al listei duble
   c) identificarea elementului dintr-o structura dinamica sau statica dupa cheia definita char [] intr-o procedura de cautare;
   d) identificarea dupa cheia definita char [] in procedura de cautare in liste si arbori daca este folosita o variabila de selectie;
   e) identificarea dupa cheia definita char [] in procedura:
   struct dlista *cautare(pcld, cheie)
   {
   struct dlista *pcld, *paux;
   int cheie;
   paux=pcld;
   if(paux)
   {
   if(cheie==paux->info) return(paux);
   cautare(paux->purm,cheie);
   }
   else
   return(NULL); }
   
   
3. Prin secventele:
   struct LISTA_SIMPLA {
   int info;
   struct LISTA_SIMPLA *p_urmator;
   }
   ..................
   struct LISTA_SIMPLA
   var1={100},
   var2={200},
   var3={300},
   var4={400}, *p_caplista; a) s-a definit numai un tip de date de tip articol care se redefineste prin:
   typedef struct LISTA_SIMPLA lista_simpla;
   iar variabilele var1, var2, var3 si var4 sunt definite incomplet
   b) s-a definit tipul articol autoreferit printr-un pointer si au fost initializate variabilele var1,var2,var3,var4 la definire
   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;
   dupa care s-a incarcat o lista simpla cu 4 elemente
   d) sunt create conditii pentru a realiza lista simpla prin expresiile de atribuire:
   p_caplista=&var1;
   var1.p_urmator=&var2;
   var2.p_urmator=&var3;
   var3.p_urmator=&var4;
   var4.p_urmator=NULL;
   
   e) sunt create conditii pentru a defini variabilele elementare:
   struct LISTA_SIMPLA var1, var2, var3, var4, **p_caplista;
   dupa care prin expresiile de atribuire: p_caplista=&var1;
   var1.p_urmator=&var2;
   var2.p_urmator=&var3;
   var3.p_urmator=&var4;
   
   
4. Inversarea elementelor unui masiv unidimensional
   definit prin:
   ................
   #define K 10 int x[2*K];
   se realizeaza :
   a) interschimband primul cu ultimul element,
   al doilea cu penultimul element,
   al treilea cu antepenultimul element, si tot asa mai departe ,
   elementul din mijloc ramane nemodificat
   b) folosind variabile de lucru definite prin instructiunea
   int a,b;
   ca in secventa C++
   ...............
   a=x[i];
   b=x[2*K-i]:
   x[i]=b;
   x[2*K-i]=a;
   pentru i=0,1,2,3,....,K
   ...........
   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;
   }
   
5. Lista simpla este:
   a) o structura de date dinamica;
   b) o insiruire aleatoare de articole
   c) variabile pointer care asigura referire din aproape in aproape
   d) parametru in procedura de concatenare
   e) o structura de date initializata cu NULL
   
   
6. 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;
   }
   
7. 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;
   
   
8. Numararea elementelor nule, pozitive, respectiv, negative dintr-un masiv bidimensional definit prin
   int x[10][10];
   se realizeaza prin secventa:
   a) inti,j, contor_plus=0, contor_nul=0, contor_neg=0;
   for(i=0;i for(j=0;j {
   if(x[i][j]>0)contor_plus++;
   else
   if(x[i][j]<)contor_neg++;
   if(x[i][j]==0)contor_nul++;
   }
   b) int j=0,i=0,contor=0;
   for(;i for(;j if(x[i][j]==VAL)contor++;
   c) int i=0,j=0;
   for(i=0;int contor=0;i for(;j if(x[i][j]==VAL)contor++;
   d) int j,i=0,contor=0;
   for(inti=0;i for(j=0;j if(x[i][j]==VAL)contor++;
   e) inti,j, contor_plus=0, contor_nul=0, contor_neg=0;
   for(i=0;i for(j=0;j {
   if(x[i][j]>0)contor_plus++;
   if(x[i][j]<)contor_neg++;
   if(x[i][j]==0)contor_nul++;
   }
   
   
9. Fisierul F1 este copia fisierului F2 daca:
   a) au fost create cu programe identice
   b) au organizari identice
   c) au aceleasi valori ale cheilor
   d) au articole cu structura identica
   e) fisierul F1 a fost creat prin citirea articolelor fisierului F2 si scrierea lor fara modificari in fisierul F1;
   cele doua fisiere au acelasi numar de articole,
   au aceeasi lungime si acelasi continut pe baitii corespondenti
   
10. Traversarea unui arbore binar se efectueaza:
    a) "stanga-dreapta-radacina" sau postordine;
    b) "radacina-stanga-dreapta" sau postordine
    c) "stanga-radacina-dreapta" sau postordine
    d) "dreapta-stanga-radacina" sau post ordine
    e) "drepta-radacina-stanga" sau postordine
    
    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 FIC D A E W V F B R ,dupa ce a fost introdus nodul fictiv FIC pentru a transforma arborele oarecare in arbore binar
    b) traversarea in postordine sau inseamna referirea nodurilor
    C X Y D A E W V F B R daca ar lipsi nodul XX
    c) traversarea dupa regula "stanga-dreapta-radacina" inseamna referirea nodurilor
    C X XX Y D E A W V F B R , nu se efectueaza transformarea arborelui oarecare in arbore binar cu noduri fictive
    
    d) traversarea in postordine inseamna referirea consecutiva a nodurilor
    D A R C B E R X XX Y W V
    
    e) traversarea dupa regula "stanga-dreapta-radacina" nu se aplica deoarece arborele nu este binar
    
    
    
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 in preordine este:
    a) void preordine (PARBIN pradacina)
    {
    if(pradacina)
    {
    prelucrare(pradacina); //procedura utilizator de prelucrare informatie utila
    preordine(pradacina->pst);
    preordine(pradacina->pdr);
    }
    }
    b) void preordine (PARBIN *pradacina)
    {
    if(pradacina)
    {
    prelucrare(pradacina); //procedura utilizator de prelucrare informatie utila
    preordine(pradacina->pst);
    preordine(pradacina->pdr);
    }
    }
    c) void preordine (PARBIN pradacina)
    {
    if(pradacina)
    {
    prelucrare(pradacina); //procedura utilizator de prelucrare informatie utila
    preordine(pradacina->pdr);
    preordine(pradacina->pst);
    }
    }
    d) void preordine (PARBIN pradacina)
    {
    if(pradacina)
    {
    prelucrare(pradacina); //procedura utilizator de prelucrare informatie utila
    preordine(pradacina->pst->pst);
    preordine(pradacina->pdr->pdr);
    }
    }
    e) void preordine (PARBIN pradacina)
    {
    if(pradacina)
    {
    prelucrare(pradacina->pst->info); //procedura utilizator de prelucrare informatie utila
    prelucrare(pradacina->pdr->info); //procedura utilizator de prelucrare informatie utila
    preordine(pradacina->pst);
    preordine(pradacina->pdr);
    }
    }
    
    
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. 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) apelarea procedurii:
    int comparare_LS(struct lista_simpla *pcpls1, struct lista_simpla *pcpls2)
    {
    struct lista_simpla *paux1, *paux2;
    int vb=1;
    paux1=cpls1;
    paux2=cpls2;
    while(paux1 && paux2){
    if(paux1->info != paux2->info) return (vb=0);
    paux1=paux1->p_urmator;
    paux2=paux2->p_urmator;
    }
    return (vb); }
    
    e) apelarea unei proceduri care are doi parametri, cei doi pinteri ce refera, respectiv, primul element fiecarei liste simple; procedura returneaza o variabila booleana
    
    
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. Daca lista simpla este definita, creata si initializata, atunci:
    a) se poate stoca imediat intr-un fisier cu articole de lungime variabila cu numar necunoscut de articole
    b) se apeleaza procedura recursiva de stergere a listei
    c) se apeleaza procedura:
    struct lista_simpla (struct lista_simpla *pcpls, int vb, int variabila)
    {
    int k;
    struct lista_simpla *paux=pcls;
    if(vb==2){
    k=0;
    for(paux=pcpls;paux;paux=paux->p_urmator,k++) if(k==valoare) return (paux); return(NULL);
    }
    else
    if(vb==1){
    paux=pcpls;
    while(paux){
    if(paux->info==valoare) return(paux):
    paux=paux->p_urmator;
    }
    return (0);
    }
    pentru cautarea unui element dupa pozitie sau dupa cheie
    d) se apeleaza o procedura pentru cautarea unui element dupa pozitie daca variabila vb == 1
    sau dupa cheie daca vb==2 rezultata din alipirea a doua proceduri pentru cautate dupa cheie, respectiv, dupa pozitie
    e) se apeleaza o procedura de forma:
    struct lista_simpla (struct lista_simpla *pcpls, int *pozitie)
    {
    while(pcpls) {
    if(pcpls->pozitie==*pozitie) return (pcpls); pcpls=pcpls->p_urmator; }
    return(NULL);
    }
    pentru cautarea unui element dupa pozitie