DATA STRUCTURES test nr. 5

1. Pentru construirea unei structuri de tip graf corespunzatoare matricei:
   ...A B C D E F G
   .A.61 10 15 25 37 0 0
   .B. 0 0 0 0 20 0 0
   .C. 0 0 0 0 21 0 0
   .D. 0 0 0 0 31 40 0
   .E. 0 0 0 0 0 0 50
   .F. 0 0 0 0 0 0 28
   .G. 0 0 28 0 0 0 0
   
   a) se aloca un masiv bidiemnsional int a[7][7] si un vector definit prin char nume[20] pentru a memora numele nodurilor si se initializeaza prin secventa:
   .............
   for(i=0;i<7; i++){
   printf("\n a[",%d,][",%d,"]=",i,j)
   scanf("%d",&a[i][j]); }
   inclusa intr-o procedura
   b) se utilizeaza o lista limpla utilizata pentru memorarea matricelor rare (nod sursa, nod destinatie, valoare)in care informatia utila este dedicata nodurilor ce definesc arcele;
   lista are atatea elemente cate arce are graful
   c) se foloseste un vector de 7 pointeri spre structura cu atatea componente cate noduri are graful si 7 liste simple
   d) se construieste o lista de liste cu 7*7 noduri
   e) se foloseste o lista simpla unde informatia utila a fiecarui element contine definiri ale nodurilor si un pointer spre primul element al unei liste simple ce contine elemente de identificare a arcelor incidente spre exterior
   
   
2. Intrucat functiile nu returneaza masive unidimensionale, atunci definirea:
   a) int functie()[];
   este incorecta
   b) int functie()();
   este corecta
   c) int functie[]();
   este incorecta
   d) int functie[]()[10];
   este corecta
   e) int functie[][10];
   este corecta
   
   
3. Prin secventa:
   struct LISTA_DUBLA {
   struct LISTA_DUBLA *p_precedent;
   int info;
   struct LISTA_SIMPLA *p_urmator;
   }
   a) s-a definit tipul articol care se redefineste prin:
   typedef struct LISTA_DUBLA lista_dubla;
   b) s-a definit tipul articol autoreferit prin doi pointeri
   c) sunt create conditii pentru a defini variabilele:
   struct lista_dubla var1, var2, var3, var4, p_caplista; daca in prealabil s-a efectuat definirea:
   typedef struct LISTA_DUBLA lista_dubla;
   d) sunt create conditii pentru a defini variabilele:
   struct LISTA_DUBLA var1, var2, var3, var4, p_caplista;
   necesare lucrului cu o lista dubla
   e) sunt create conditii pentru a defini variabilele elementare:
   struct LISTA_DUBLA var1, var2, var3, var4, **p_caplista;
   
   
4. Inserarea unui element A pe pozitia K a unui masiv unidimensional
   cu N componente initializate, N < 15,K int x[20];
   se realizeaza prin secventa:
   a) for(i=N-1; i>K;i++)
   x[N-i+1]=x[N-i];
   x[i]=A; b) for(i=N-1; i>K-1;i--)
   x[i+1]=x[N-i];
   x[i]=A
   
   c) for(i=N; i>K-1;i++)
   x[N-i+1]=x[N-i];
   x[i]=A
   
   d) for(i=0; i>K-1;i++)
   x[i+1]=x[N-i-1];
   x[i]=A
   
   e) procedura:
   int inserare(int x[], int N, int K)
   {
   int i, vb=0;
   if(K for(i=N-1; i>K;i--)
   x[i+1]=x[i];
   x[i]=A
   }
   else
   vb=1;
   return(vb);
   }
   
5. Pentru expresia:
   e = a*a + b*b + c*c;
   unde variabilele sunt definite prin:
   int a,b,c,e;
   a) domeniul de definitie este [-32768; +32767]
   b) domeniul de definitie este [-10922; +10922
   c) domeniul de definitie este [-32767; +32767]
   d) domeniul de definitie este cel al tipului int
   e) domeniul de definitie este [-104; +104]
   
   
6. Pentru a verifica daca o lista simpla este ordonata stict descrescator dupa o cheie:
   a) se scrie o procedura
   b) se utilizeaza secventa:
   for(vb=0,paux=pcpls; paux; paux=paux->purmator) if(paux->cheie >=paux->cheie->cheie) vb=1;
   c) se urilizeaza secventa:
   while(paux){
   if(paux->cheie >=paux->cheie->cheie) vb=1;
   paux=paux->purmator;
   }
   d) se utilizeaza procedura:
   int verificare(struct lista_simpla *pcpls) {
   int vb=0;
   while(paux){
   if(paux->cheie >=paux->cheie->cheie) vb=1;
   paux=paux->purmator;
   }
   return(vb)
   }
   e) se utilizeaza procedura:
   int verificare(struct lista_simpla *pcpls) {
   int vb=0;
   while(paux->purmator){
   if(paux->cheie >=paux->cheie->cheie) vb=1;
   paux=paux->purmator;
   }
   return(vb)
   }
   
   
7. 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;
   }
   
8. 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;
   
   
9. Traversarea unui arbore binar se efectueaza:
   a) in postordine ordine;
   b) in preordine sau "stanga-radacina-dreapta"
   c) de sus in jos
   d) de jos in sus
   e) de la stanga la dreapta
   
   
10. Daca tipul asociat unui arbore binar este definit prin:
    struct arbin{
    int *pinfo; // pointer spre int pentru 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 stergerea arborelui este:
    a) void stergere (PARBIN pradacina)
    {
    if(pradacina)
    {
    pradacina->pinfo=(int* )pradacina;
    stergere(pradacina->pst);
    stergere(pradacina->pdr);
    delete(pradacina);
    }
    }
    b) void stergere_preordine (PARBIN pradacina,int*pinfo)
    {
    if(pradacina!=NULL)
    {
    stergere(pradacina->pst);
    pradacina->pinfo=(int* )pradacina;
    stergere(pradacina->pdr);
    delete(pradacina);
    }
    }
    
    c) void stergere_inordine (PARBIN pradacina)
    {
    if(pradacina)
    {
    stergere(pradacina->pst);
    delete(pradacina);
    pradacina->pinfo=(int* )pradacina;
    stergere(pradacina->pdr);
    }
    }
    d) delete_all(pradacina);
    {
    while(pradacina)delete(radacina);
    delete_all(radacina->pst);
    delete_all(radacina->pdr);
    }
    e) void stergere (PARBIN pradacina)
    {
    if(pradacina)
    {
    pradacina->pinfo=(int* )pradacina;
    delete(pradacina);
    stergere(pradacina->pst);
    stergere(pradacina->pdr);
    }
    }
    
    
11. Compararea indiferent de sensul de parcurgere a doua liste duble inseamna:
    a) comparea continutului informatiei utile din cele doua liste duble
    b) comparea lungimilor ca numar de elemente din cele doua liste duble
    c) traversarea structurilor de la primul spre ultimul element
    d) apelarea procedurii:
    int comparare_LD_dreaptastaqnga(struct lista_dubla *pcpld_primul, struct lista_dubla *pcpld2_primul, struct lista_dubla *pcpld_ultim, struct lista_dubla *pcpld2_ultim, int sensul_parcurgerii)
    {
    struct lista_dubla *paux1, *paux2;
    int vb=1, lungime_list1, lungime_list2;
    if(sensul_parcurgerii==1){
    paux1=cpld1_ultim;
    paux2=cpld2_ultim;
    lungime_list1=sizeof_lista_simpla(paux1);
    lungime_list2=sizeof_lista_simpla(paux2);
    if(lungime_list1!=lungime_list2) return (vb=0);
    while(paux1 && paux2){
    if(paux1->info != paux2->info) return (vb=0);
    paux1=paux1->p_precedent;
    paux2=paux2->p_precedent;
    }
    return (vb); }
    else
    ){
    paux1=cpld1_primul;
    paux2=cpld2_primul;
    lungime_list1=sizeof_lista_simpla(paux1);
    lungime_list2=sizeof_lista_simpla(paux2);
    if(lungime_list1!=lungime_list2) return (vb=0);
    while(paux1 && paux2){
    if(paux1->info != paux2->info) return (vb=0);
    paux1=paux1->p_urmator;
    paux2=paux2->p_urmator;
    }
    return (vb); }
    }
    
    
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. 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));
    
    
14. 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
    
    
15. 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);
    }
    
    
    
16. 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 si un descendent drept Y; nodul F are un descendent stang W si un descendent drept V, atunci:
    a) traversarea inordine sau "stanga-radacina-drapta" inseamna referirea nodurilor
    C A D X D Y R E B W F V
    b) traversarea in preordine sau inseamna referirea nodurilor
    C A D X D Y E R B V F W
    c) traversarea in preordine sau inseamna referirea nodurilor
    A R C E Y X B E D W V
    d) traversarea in preordine sau inseamna referirea nodurilor
    D A R C B E R X Y W V
    e) traversarea in preordine sau inseamna referirea nodurilor
    W B A D X Y C E F R V
    
    
17. Pentru expresia:
    e = a*a + b + c*a;
    unde variabilele sunt definite prin:
    int a,b,c,e;
    a) domeniul de definitie este [-32768; +32767]
    b) domeniul de definitie este [-10922; +10922
    c) domeniul de definitie este [-104; +104]
    d) domeniul de definitie este cel al tipului int
    e) domeniul de definitie este [-104; +104] pentru variabilele a si c
    si [-10922; +10922] pentru variabila b
    
    
    
    
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. Pentru expresia:
    e = a*a*a + b*b*b + c*c*c;
    unde variabilele sunt definite prin:
    int a,b,c,e;
    a) domeniul de definitie este [-32768; +32767]
    b) domeniul de definitie este [-10922; +10922
    c) domeniul de definitie este [-32767; +32767]
    d) domeniul de definitie este cel al tipului int
    e) domeniul de definitie este [-22; +22]
    
    
20. Variabila ptr definita prin:
    int *ptr[];
    a) nu este o variabila elementara
    b) este un vector de pointeri multiplu
    c) este pointer care memoreaza adresele unor zone de memorie de tip intreg sau pointeri spre intreg
    d) este un vector de pointeri spre int
    e) se refera prin expresia (&ptr+i)
    
    
21. Daca lista simpla este definita prin:
    struct slista
    {
    int info;
    struct slista *peu;
    } *pcpls, *pinsert;
    iar pcpls este pointer spre primul element al listei si pinsert este pointer
    spre lemenetul care se insereaza, atunci procedura:
    a) void insertie (struct slista *pcpls, struct slista *pinsert)
    {
    //construire element de inserat pinsert=(struct slista *) malloc(sizeof(struct slista)); pinsert.peu=NULL; scanf("%d",&pinsert->info);
    pinsert.peu=pcpls;
    pcpls=pinsert;
    }
    estre destinata inserarii unui element in capul listei
    b) void insertie (struct slista *pcpls, struct slista *pinsert)
    {
    //construire element de inserat pinsert=(struct slista *) malloc(sizeof(struct slista)); pinsert->peu=NULL; scanf("%d",&pinsert->info);
    pinsert->peu=pcpls;
    pcpls=pinsert;
    }
    estre destinata inserarii unui element in capul listei
    
    c) void insertie (struct slista *pcpls, struct slista *pinsert)
    {
    pinsert.peu=pcpls;
    pcpls=pinsert;
    }
    estre destinata inserarii unui element in capul listei,
    daca elementul care trebuie inserat a fost construit
    d) void insertie (struct slista *pcpls, struct slista *pinsert,int winfo)
    {
    //construire element de inserat pinsert=(struct slista *) malloc(sizeof(struct slista)); pinsert.peu=NULL; scanf("%d",&pinsert->info);
    *pinsert.info=winfo;
    pinsert.peu=pcpls;
    pcpls.peu=pinsert;
    }
    estre destinata inserarii unui element in capul listei
    
    e) void insertie (SLISTA *pcpls, SLISTA *pinsert)
    {
    //construire element de inserat pinsert=(struct slista *) malloc(sizeof(struct slista)); pinsert.peu=NULL; scanf("%d",&pinsert->info);
    pinsert.peu=pcpls;
    pcpls=pinsert;
    }
    estre destinata inserarii unui element in capul listei dacatipul SLISTA a fost definit prin :
    
    typedef struct slista * SLISTA;