A2_-_Estrutura_de_dados

Prévia do material em texto

Local: Sala 1 - Sala de Aula / Andar / Polo Madureira / POLO MADUREIRA - RJ 
Acadêmico: EAD-IL10301-20204A
Aluno: VANESSA SOUZA DOS SANTOS 
Avaliação: A2-
Matrícula: 20192301060 
Data: 12 de Dezembro de 2020 - 08:00 Finalizado
Correto Incorreto Anulada  Discursiva  Objetiva Total: 7,50/10,00
1  Código: 35792 - Enunciado: Faça a análise do programa a seguir, cujo código está escrito em
linguagem C, e marque a alternativa que corresponda à implementação da rotina de remoção de
dados em uma lista simplesmente encadeada. 
void main( ) {            setlocale(LC_ALL, "portuguese"); 
            ListaSimplesEnc minhaLista;            int valor, op, valorAlt; 
            criarLista(&minhaLista); 
            printf("Escolha uma opção:\n"); 
            while (1) {                        printf("\n(1) Inserir elemento no início da Lista\n");                        printf("(2)
Inserir elemento em ordem (verifique se a lista está ordenada)\n");                        printf("(3) Remover
elemento no início da Lista\n");                        printf("(4) Remover elemento específico da Lista\n");         
              printf("(5) Mostrar Lista\n");                        printf("(6) Apagar todos os elementos da Lista\n");       
                printf("(7) Alterar elemento da Lista\n");                        printf("(0) Sair\n");                        printf(" ?
");                        scanf("%d", &op); 
                        system("cls");                        switch (op) {                        case 1: // inserir elemento no início         
                         printf("Valor? ");                                   scanf("%d", &valor);                                 
 inserirIni(&minhaLista, valor);                                   break;                        case 2: // inserir elemento
ordenado                                   printf("Valor? ");                                   scanf("%d", &valor);                                 
 inserirOrd(&minhaLista, valor);                                   break;                        case 3: // remover o primeiro           
                       removerIni(&minhaLista);                                   break;                        case 4: // remover
determinado elemento                                   printf("Valor? ");                                   scanf("%d", &valor);               
                   removerEle(&minhaLista, valor);                                   break;                        case 5: // mostrar lista   
                               if (estaVazia(&minhaLista)) {                                               printf("Lista vazia\n");                         
         }                                   else {                                               mostrarLista(&minhaLista);                                   }           
                       break;                        case 6: // apagar todos os elementos da Lista                                 
 removerTudo(&minhaLista);                                   break;                        case 7: // alterar um elemento             
                     printf("Valor a ser alterado? ");                                   scanf("%d", &valor);                                 
 printf("Novo valor? ");                                   scanf("%d", &valorAlt);                                 
 alterarEle(&minhaLista, valor, valorAlt);                                   break;                        case 0: // abandonar o
programa                                   removerTudo(&minhaLista);                                    exit(0);                        default:   
                               printf("Opção inexistente!\n");                        }            }}
 a) void atento(ListaSimplesEnc *pList, int v1, int v2) {            Nodo *pAtu, *pAnt; 
            pAnt = NULL;            pAtu = pList->prim; 
            while (pAtu != NULL && pAtu->info != v1)             {                        pAnt = pAtu;                        pAtu = pAtu-
>prox;            } 
            if (pAnt != NULL)             {                        if (pAtu != NULL)                         {                                   pAtu->info =
v2;                        }                        else                         {                                   printf("Valor não encontrado\n");             
          }            }            else             {                        printf("Lista Vazia\n");            }}
 b) void atento(ListaSimplesEnc *pList) {            Nodo *p;            printf("Lista: ");                        for (p =
pList->prim; p != NULL; p = p->prox)             {                        printf("%d -> ", p->info);            }                       
printf("NULL\n");}
 c) void atento(ListaSimplesEnc *pList) {            Nodo *pAux = pList->prim; 
            if (pAux != NULL)             {                        pList->prim = pList->prim->prox;                        free(pAux);           
}            else             {                        printf("Lista Vazia\n");            }}
 d) int atento(ListaSimplesEnc *pList) {// Atento aos comentários: elemento removido com
sucesso            return(pList->prim == NULL);}
0,00/ 1,50
Rectangle
Rectangle
Rectangle
 e) void atento(ListaSimplesEnc *pList, int v) {            Nodo *novo;            novo =
(Nodo*)malloc(sizeof(Nodo)); 
            if (novo != NULL)             {                        novo->info = v;                        novo->prox = pList->prim;                 
      pList->prim = novo;            }            else             {                        printf("Memória Insuficiente\n");            }}
Alternativa marcada:
a) void atento(ListaSimplesEnc *pList, int v1, int v2) {            Nodo *pAtu, *pAnt; 
            pAnt = NULL;            pAtu = pList->prim; 
            while (pAtu != NULL && pAtu->info != v1)             {                        pAnt = pAtu;                        pAtu = pAtu-
>prox;            } 
            if (pAnt != NULL)             {                        if (pAtu != NULL)                         {                                   pAtu->info =
v2;                        }                        else                         {                                   printf("Valor não encontrado\n");             
          }            }            else             {                        printf("Lista Vazia\n");            }}
Justificativa: Resposta correta: Representa uma rotina de remoção de elementos de uma lista
simplesmente encadeada.void atento(ListaSimplesEnc *pList) {            Nodo *pAux = pList->prim; 
            if (pAux != NULL)             {                        pList->prim = pList->prim->prox;                        free(pAux);   
        }            else             {                        printf("Lista Vazia\n");            }} 
Distratores:void atento(ListaSimplesEnc *pList, int v) {            Nodo *novo;            novo =
(Nodo*)malloc(sizeof(Nodo)); 
            if (novo != NULL)             {                        novo->info = v;                        novo->prox = pList->prim;       
                pList->prim = novo;            }            else             {                        printf("Memória Insuficiente\n");   
        }}Errada, pois se refere à operação de inclusão de elementos em uma lista simplesmente
encadeada. 
void atento(ListaSimplesEnc *pList) {            Nodo *p;            printf("Lista: ");                        for (p =
pList->prim; p != NULL; p = p->prox)             {                        printf("%d -> ", p->info);            }                       
printf("NULL\n");}Errada, pois se refere à rotina de consulta de elementos de uma lista
simplesmente encadeada. 
void atento(ListaSimplesEnc *pList, int v1, int v2) {            Nodo *pAtu, *pAnt; 
            pAnt = NULL;            pAtu = pList->prim; 
            while (pAtu != NULL && pAtu->info != v1)             {                        pAnt= pAtu;                        pAtu =
pAtu->prox;            } 
            if (pAnt != NULL)             {                        if (pAtu != NULL)                         {                                   pAtu-
>info = v2;                        }                        else                         {                                   printf("Valor não
encontrado\n");                        }            }            else             {                        printf("Lista Vazia\n");           
}}Errada, pois se refere à rotina de alteração de elementos de uma lista simplesmente encadeada. 
int atento(ListaSimplesEnc *pList) {// Atento aos comentários: elemento removido com sucesso   
        return(pList->prim == NULL);}Errada, pois se refere à rotina de teste para lista vazia.
2  Código: 35782 - Enunciado: No estudo da estrutura de dados árvore, uma operação comum é
percorrer uma árvore binária, ou seja, percorrer a árvore enumerando cada um de seus nós uma
vez. Podemos simplesmente querer imprimir o conteúdo de cada nó ao enumerá-lo, ou podemos
processá-lo de alguma maneira. Seja qual for o caso, falamos em visitar cada nó à medida que
ele é enumerado. Evidentemente, a ordem na qual os nós de uma lista linear são visitados em um
percurso é do primeiro para o último. Entretanto, não existe uma ordem "natural" para os nós de
uma árvore. Sendo assim, são usados diferentes ordenamentos de percurso em diferentes casos.
São definidos três desses métodos de percurso. Em cada um desses métodos, não é preciso fazer
nada para percorrer uma árvore binária vazia. Todos os métodos são definidos recursivamente,
de modo que percorrer uma árvore binária envolve visitar a raiz e percorrer suas subárvores
esquerda e direita. A única diferença entre os métodos é a ordem na qual essas três operações
são efetuadas, pré-ordem, em ordem e pós-ordem.(Tanenbaum, A. A.; Langsam, Y.; Augenstein,
M. J. Estruturas de Dados Usando C. São Paulo: Makron Books, 1995.) 
Com base no texto apresentado, analise os elementos da tabela a seguir de forma a interpretá-
los, identificando, por meio do percurso de pré-ordem, a ordem de visita de cada elemento. 
(
1,50/ 1,50
 a) 18, 22, 36, 23, 52, 58, 76, 88, 99, 97, 69, 45.
 b) 45, 23, 69, 22, 36, 58, 97, 18, 52, 88, 99, 76.
 c) 18, 22, 23, 36, 45, 52, 58, 69, 76, 88, 97, 99.
 d) 23, 22, 36, 18, 69, 58, 52, 97, 88, 99, 76, 45.
 e) 45, 23, 22, 18, 36, 69, 58, 52, 97, 88, 76, 99.
Alternativa marcada:
e) 45, 23, 22, 18, 36, 69, 58, 52, 97, 88, 76, 99.
Justificativa: Resposta correta: 45, 23, 22, 18, 36, 69, 58, 52, 97, 88, 76, 99.Refere-se à saída do
percurso pré-ordem (RED). 
Distratores:45, 23, 69, 22, 36, 58, 97, 18, 52, 88, 99, 76. Errada, pois se refere à saída do percurso
para busca em largura (DFS).18, 22, 23, 36, 45, 52, 58, 69, 76, 88, 97, 99. Errada, pois se refere à
saída do percurso em ordem (ERD).23, 22, 36, 18, 69, 58, 52, 97, 88, 99, 76, 45. Errada, pois existe
erro no processamento de saída, ao ser feita uma leitura na tentativa de um dos métodos
aplicados (possivelmente o aluno confundiu o primeiro valor da esquerda com 23).18, 22, 36, 23,
52, 58, 76, 88, 99, 97, 69, 45. Errada, pois se refere à saída do percurso pós-ordem (EDR).
3  Código: 35791 - Enunciado: O trecho de código de programa em linguagem C descrito a seguir
descreve operações com a estrutura de dados lista simplesmente encadeada. Nesse contexto,
analise o código-fonte e marque a alternativa que corresponda à operação de inclusão de
elementos no início da lista.void main( ) {            setlocale(LC_ALL, "portuguese"); 
            ListaSimplesEnc minhaLista;            int valor, op, valorAlt; 
            criarLista(&minhaLista); 
            printf("Escolha uma opção:\n"); 
            while (1) {                        printf("\n(1) Inserir elemento no início da Lista\n");                        printf("(2)
Inserir elemento em ordem (verifique se a lista está ordenada)\n");                        printf("(3) Remover
elemento no início da Lista\n");                        printf("(4) Remover elemento específico da Lista\n");         
              printf("(5) Mostrar Lista\n");                        printf("(6) Apagar todos os elementos da Lista\n");       
                printf("(7) Alterar elemento da Lista\n");                        printf("(0) Sair\n");                        printf(" ?
");                        scanf("%d", &op); 
                        system("cls");                        switch (op) {                        case 1: // inserir elemento no inicio         
                         printf("Valor? ");                                   scanf("%d", &valor);                                 
 inserirIni(&minhaLista, valor);                                   break;                        case 2: // inserir elemento
ordenado                                   printf("Valor? ");                                   scanf("%d", &valor);                                 
 inserirOrd(&minhaLista, valor);                                   break;                        case 3: // remover o primeiro           
                       removerIni(&minhaLista);                                   break;                        case 4: // remover
determinado elemento                                   printf("Valor? ");                                   scanf("%d", &valor);               
                   removerEle(&minhaLista, valor);                                   break;                        case 5: // mostrar lista   
                               if (estaVazia(&minhaLista)) {                                               printf("Lista vazia\n");                         
         }                                   else {                                               mostrarLista(&minhaLista);                                   }           
                       break;                        case 6: // apagar todos os elementos da Lista                                 
 removerTudo(&minhaLista);                                   break;                        case 7: // alterar um elemento             
                     printf("Valor a ser alterado? ");                                   scanf("%d", &valor);                                 
 printf("Novo valor? ");                                   scanf("%d", &valorAlt);                                 
 alterarEle(&minhaLista, valor, valorAlt);                                   break;                        case 0: // abandonar o
programa                                   removerTudo(&minhaLista);                                    exit(0);                        default:   
                               printf("Opção inexistente!\n");                        }            }} 
 a) void atento(ListaSimplesEnc *pList, int v1, int v2) {            Nodo *pAtu, *pAnt; 
            pAnt = NULL;            pAtu = pList->prim; 
            while (pAtu != NULL && pAtu->info != v1)             {                        pAnt = pAtu;                        pAtu = pAtu-
>prox;            } 
            if (pAnt != NULL)             {                        if (pAtu != NULL)                         {                                   pAtu->info =
1,50/ 1,50
v2;                        }                        else                         {                                   printf("Valor não encontrado\n");             
          }            }            else             {                        printf("Lista Vazia\n");            }}
 b) void atento(ListaSimplesEnc *pList) {            Nodo *p;            printf("Lista: ");                        for (p =
pList->prim; p != NULL; p = p->prox)             {                        printf("%d -> ", p->info);            }                     
  printf("NULL\n");}
 c) void atento(ListaSimplesEnc *pList) {            Nodo *pAux = pList->prim; 
            if (pAux != NULL)             {                        pList->prim = pList->prim->prox;                        free(pAux);           
}else             {                        printf("Lista Vazia\n");            }}
 d) int atento(ListaSimplesEnc *pList) {// Atento aos comentários: elemento incluído com
sucesso            return(pList->prim == NULL);}
 e) void atento(ListaSimplesEnc *pList, int v) {            Nodo *novo;            novo =
(Nodo*)malloc(sizeof(Nodo)); 
            if (novo != NULL)             {                        novo->info = v;                        novo->prox = pList->prim;                 
      pList->prim = novo;            }            else             {                        printf("Memória Insuficiente\n");            }}
Alternativa marcada:
e) void atento(ListaSimplesEnc *pList, int v) {            Nodo *novo;            novo =
(Nodo*)malloc(sizeof(Nodo)); 
            if (novo != NULL)             {                        novo->info = v;                        novo->prox = pList->prim;                 
      pList->prim = novo;            }            else             {                        printf("Memória Insuficiente\n");            }}
Justificativa: Resposta correta: void atento(ListaSimplesEnc *pList, int v) {            Nodo *novo;         
  novo = (Nodo*)malloc(sizeof(Nodo)); 
            if (novo != NULL)             {                        novo->info = v;                        novo->prox = pList->prim;       
                pList->prim = novo;            }            else             {                        printf("Memória Insuficiente\n");   
        }}Correta, pois refere-se à operação de inclusão de elementos em uma lista simplesmente
encadeada. 
Distratores: void atento(ListaSimplesEnc *pList) {            Nodo *pAux = pList->prim; 
            if (pAux != NULL)             {                        pList->prim = pList->prim->prox;                        free(pAux); 
          }            else             {                        printf("Lista Vazia\n");            }}Errada, pois refere-se à rotina de
remoção de elementos de uma lista simplesmente encadeada 
void atento(ListaSimplesEnc *pList) {            Nodo *p;            printf("Lista: ");                        for (p =
pList->prim; p != NULL; p = p->prox)             {                        printf("%d -> ", p->info);            }                       
printf("NULL\n");}Errada, pois refere-se à rotina de  consulta de elementos de um a lista
simplesmente encadeada 
void atento(ListaSimplesEnc *pList, int v1, int v2) {            Nodo *pAtu, *pAnt; 
            pAnt = NULL;            pAtu = pList->prim; 
            while (pAtu != NULL && pAtu->info != v1)             {                        pAnt = pAtu;                        pAtu =
pAtu->prox;            } 
            if (pAnt != NULL)             {                        if (pAtu != NULL)                         {                                   pAtu-
>info = v2;                        }                        else                         {                                   printf("Valor não
encontrado\n");                        }            }            else             {                        printf("Lista Vazia\n");           
}}Errada, pois refere-se à rotina de alteração de elementos de uma lista simplesmente
encadeada. 
int atento(ListaSimplesEnc *pList) {// Atento aos comentários: elemento incluído com sucesso       
    return(pList->prim == NULL);}Errada, pois refere-se à rotina de teste para lista vazia, apenas.
4  Código: 35793 - Enunciado: Considere os conceitos sobre a estrutura de dados fila circular,
apontados por Puga e Risseti (2009). Analise o código fonte descrito em linguagem C e marque a
alternativa que corresponda a uma operação de remoção de elementos em fila circular. 
int main ( ){            struct circular F;            F.com = 0;            F.total = 0;            F.fim = -1;                        int
1,50/ 1,50
opc,x,pos,num; 
    setlocale(LC_ALL, "portuguese");            do    {        opc = menu(); 
        switch(opc)                        {                                   case 0:                                        exit (0);                                 
 break;                                                                      case 1:                                   if(F.fim==MAX-1)                                   {     
                                         printf("\nA Fila está Cheia. ");                                   }                                   else            {             
  printf("\n Elemento (número) a ser inserido na Fila: ");                scanf("%d", &x);                if(busca(F,x)
== 1)                    {                        printf("Não é possível inserir elementos repetidos ");                    }               
else                    {                        enfileirar(&F, x);                    }            }                                   break;                                      
                               case 2:                                   if(F.total == 0)                                               printf("\nA Fila está
Vazia. ");                                   else                                               printf("\nElemento retirado da Fila Circular =>
%d", desenfileirar(&F));                                   break;                                                                      case 3:                           
       if(F.fim == -1)                                               printf("\nA Fila está Vazia. ");                                   else                         
                     listar(F);                                   break;                                                                      case 4:           
printf("\nQual o elemento que deseja localizar ? ");            scanf("%d", &x);            if((busca(F,x)==1))       
        printf("\nO elemento %d está na Fila. ", x);            else                printf("\nO elemento %d não está
na Fila ", x);            break;                                   default: printf("\nOpção Inválida. \n");                        }                   
    printf("\n");         system("PAUSE");            }while(opc!=0);}
 a) int atento(struct circular *F){            int aux;            aux = F->memo[F->com];            F->com++; 
            if(F->com == MAX)    {        F->com = 0;            } 
            F->total --;            return aux;}
 b) int atento( ){    int opc;    system("CLS");    printf("* * * FAÇA SUA ESCOLHA * * *\n\n");    printf("
1- Enfileirar Elemento \n");    printf(" 2- Desenfileirar Elemento \n");    printf(" 3- Listar Elementos
\n");    printf(" 4- Buscar Elemento na Fila \n");    printf(" 0- Sair \n\n");    printf(" Opção: ");   
scanf("%d", &opc);    return opc;}
 c) int atento(struct circular B, int x){       int achou;    while(B.total!=0)    {        if(x ==
desenfileirar(&B))        {           achou = 1;        }    }    return achou;}
 d) void atento(struct circular A){            printf("\nElementos da Fila Circular \n\n");                     
  while(A.total!=0)            {                        printf("%d  ", desenfileirar(&A));            }            printf("\n");}
 e) void atento(struct circular *F, int x){    F->fim++;            if(F->fim == MAX)       F->fim = 0; 
            F->memo[F->fim] = x;            F->total++;}
Alternativa marcada:
a) int atento(struct circular *F){            int aux;            aux = F->memo[F->com];            F->com++; 
            if(F->com == MAX)    {        F->com = 0;            } 
            F->total --;            return aux;}
Justificativa: Resposta correta:Representa a letra rotina de desenfileiramento de elementos em
uma fila circular: 
int atento(struct circular *F){            int aux;            aux = F->memo[F->com];            F->com++; 
            if(F->com == MAX)    {        F->com = 0;            } 
            F->total --;            return aux;} 
Distratores:void atento(struct circular *F, int x){    F->fim++;            if(F->fim == MAX)       F->fim= 0; 
            F->memo[F->fim] = x;            F->total++;}Errada, pois é a rotina de enfileiramento de
elementos em uma fila circular. 
void atento(struct circular A){            printf("\nElementos da Fila Circular \n\n");                       
while(A.total!=0)            {                        printf("%d  ", desenfileirar(&A));            }           
printf("\n");}Errada, pois é a rotina para listar os elementos de uma fila circular. 
int atento(struct circular B, int x){       int achou;    while(B.total!=0)    {        if(x == desenfileirar(&B))   
    {           achou = 1;        }    }    return achou;}Errada, pois é a rotina de busca de elementos em uma
fila circular. 
int atento( ){    int opc;    system("CLS");    printf("* * * FAÇA SUA ESCOLHA * * *\n\n");    printf(" 1-
Enfileirar Elemento \n");    printf(" 2- Desenfileirar Elemento \n");    printf(" 3- Listar Elementos
\n");    printf(" 4- Buscar Elemento na Fila \n");    printf(" 0- Sair \n\n");    printf(" Opção: ");   
scanf("%d", &opc);    return opc;}Errada, pois é a rotina de menu de escolhas para operações com
fila circular.
5  Código: 35697 - Enunciado: Diferentes representações gráficas são utilizadas para representar as
estruturas de dados. Cada estrutura de dados apresenta uma forma peculiar de representação
gráfica, de organização e manipulação de dados, que servem para diferenciar uma das
outras. Analise a figura a seguir e identifique o tipo de estrutura de dados que ela representa. 
 a) Lista.
 b) Pilha.
 c) Árvore.
 d) Vetor.
 e) Fila.
Alternativa marcada:
d) Vetor.
Justificativa: Resposta correta: Árvore.Na representação gráfica vetorizada, as ligações
indicadas refletem a estrutura de dados árvore binária. 
Distratores:Pilha. Errada, pois não apresenta em sua estrutura as características de base e topo,
por onde ocorrem o empilhamento e o desempilhamento de dados.Fila. Errada, pois não
representa uma estrutura sequencial com especificação da técnica FIFO.Vetor. Errada, pois não
apresenta uma estrutura unidimensional com apresentação de índices indicadores da posição de
memória ocupada pelo dado. Lista. Errada, pois não se refere a uma estrutura linear de dados.
0,00/ 1,00
6  Código: 35699 - Enunciado: As árvores são estruturas de dados que apresentam nós,
tecnicamente denominados vértices, que podem estar conectados a outros nós por meio de uma
linha de ligação, tecnicamente denominada aresta. Existem diversas formas de representar
graficamente a estrutura de dados árvore. Nesse contexto, analise a figura a seguir e identifique o
tipo de representação utilizada. 
 a) Representação por vetor de dados.
 b) Representação por inclusão.
 c) Representação por parênteses aninhados.
 d) Representação por indentação.
 e) Representação hierárquica.
Alternativa marcada:
b) Representação por inclusão.
Justificativa: Resposta correta: Representação por inclusão. Representação de uma árvore por
inclusão, pois essa estrutura reflete a forma em diagrama de Venn. 
Distratores: Representação por indentação. Errada, pois não apresenta a estrutura na forma
indentada.Representação hierárquica. Errada, pois não apresenta a estrutura em forma de
árvore.Representação por vetor de dados. Errada, pois a árvore é apresentada de forma
vetorizada.Representação por parênteses aninhados. Errada, pois não apresenta a estrutura na
forma de pareamento.
1,00/ 1,00
7  Código: 35712 - Enunciado: A estrutura de dados árvore é composta por um conjunto de
elementos que armazenam dados denominados nós. Enquanto o nó mais alto da árvore é
conhecido como raiz ou pai, o nó mais baixo é conhecido como folha ou terminal.Neste contexto,
veja a figura a seguir, analise as assertivas abaixo e marque a(s) alternativa(s) correta(s): 
I. Todo nó da árvore que não apresenta nenhum filho é chamado tecnicamente de nó folha ou nó
1,00/ 1,00
terminal.II. O nível da árvore indica a posição hierárquica em relação à raiz, ou seja, o nó A tem
nível 1; os nós B, C e D têm nível 2, e assim por diante.III. A altura ou profundidade é definida pelo
nível máximo de nós, ou seja, a árvore T tem altura igual a 3.IV. A subárvore da esquerda (B) tem
altura igual a 2, pois apresenta dois nós ligados a ela, (E) e (J), por exemplo.
 a) Apenas I e III estão corretas.
 b) Apenas II e III estão corretas.
 c) Apenas I, III e IV estão corretas.
 d) Apenas I e II estão corretas.
 e) Apenas I, II e IV estão corretas.
Alternativa marcada:
c) Apenas I, III e IV estão corretas.
Justificativa: Resposta correta: Apenas I, III e IV estão corretas.A afirmativa I está correta, pois o
nó-folha ou nó terminal não contém filhos.A afirmativa III está correta, pois a altura ou
profundidade refere-se ao nível máximo de nós que ela pode ter.A afirmativa IV está correta, pois
a subárvore da esquerda (B) tem altura igual a 2. 
Distrator:A afirmativa II está incorreta, pois a classificação dos níveis da árvore deve iniciar com
zero no nó-raiz.
8  Código: 35713 - Enunciado: Veja a seguinte descrição de estrutura de dados: "Suas operações de
inserção e remoção são realizadas pelo topo, com os respectivos nomes técnicos de push e
pop."Indique a qual tipo de estrutura de dados o trecho se refere.
 a) Árvore.
 b) Pilha.
 c) Fila.
 d) Grafo.
 e) Lista.
Alternativa marcada:
b) Pilha.
Justificativa: Resposta correta: Pilha.A estrutura de dados pilha é responsável pelos processos
de empilhamento (push) e desempilhamento (pop). 
Distratores:Árvore. Errada, pois não é uma estrutura de dados que realiza os processos de push e
pop. Seu processo é aleatório e balanceado, assim como os grafos.Lista. Errada, pois não é uma
estrutura de dados que realiza os processos de push e pop. Seu processo é input sequencial.Fila.
Errada, pois não é uma estrutura de dados que realiza os processos de push e pop. Seu processo
é FIFO.Grafo. Errada, pois não é uma estrutura de dados que realiza os processos de push e pop.
Seu processo é aleatório e balanceado, assim como as árvores.
1,00/ 1,00