TESTE DE CONHECIMENTO AULA 08 - ESTRUTURA DE DADOS

Prévia do material em texto

ESTRUTURA DE DADOS
AULA 08
		1.
		Qual das instruções abaixo é correta para declarar um ponteiro para inteiro?
	
	
	
	&i;
	
	
	int *pti;
	
	
	int_pti pti;
	
	
	*int pti;
	
	
	*pti;
	
Explicação:
Por definição, para declarar um ponteiro  temos o seguinte :
     asterisco < nome da variável ponteiro> seguido de ponto e vírgula.
Logo :  int *pti;
 
	
	
	
	 
		
	
		2.
		    Tei Ping , famosa  cabeleireira das estrelas,  possui uma lista não ordenada de clientes em que registra apenas o nome, endereço e o telefone de cada cliente. Como não se pode pré-definir um limite para o tamanho da lista, como se pode implementar a inserção de um novo cliente na lista ? Sabe-se  que cada  cliente é do tipo Cliente  e a lista é do tipo List assim definidos :
 
struct Cliente {
     long int matricula;
      string nome, endereco e tel;
};
struct List {
                           Cliente  p;
                           struct List *link;
                  };
	
	
	
	List * insereCliente(List *i)  {
      List *novo = new List;
     Cliente c;
      novo->p =  c;
      novo->link = i;
     return novo;
}
	
	
	List * insereCliente(List  *i, Cliente c){
      List *novo ;
      novo->p = c;
      novo->link = i;
     return novo;
}
	
	
	List  insereCliente(List *i, Cliente c)
{
      List  novo[];
      novo[0].p = c;
      novo[0].link = i;
     return novo;
}
	
	
	List * insereCliente(List *i, Cliente c)
{
      List *novo = new List;
      novo->p = c;
      novo->link =i;
     return novo;
}
	
	
	 List * insereCliente(List *i, Cliente c)
{
      List *novo = new List;
      novo.p = c;
      novo.link = i;
     return novo;
}
	
Explicação:
Analisando a resposta certa :
List * insereCliente(List *i, Cliente c)
{
      List *novo = new List;    //aloca memória para novo nó
      novo->p = c;    //acessa o campo p da área apontada por novo e atribui o cliente c ao campo p
      novo->link =i;   //faz o link do novo nó apontar para onde i está apontando
     return novo;    //retorna o endereço do novo nó
}
Logo, esta função insere um novo nó no início de uma lista simplesmente encadeada e retorna o ponteiro para o início da lista resultante.
Analisando as demais opções, que estão erradas :
2o. item .... Opção errada : faltou alocar memória
3o. item .... Opção errada : Cliente c não está definido.
4o. item .... Opção errada :  Usa ponto quando deveria ser o operador seta
5o. item .... Opção errada : Muitos erros... Usa vetor sem definir tamanho e trabalha com  o elemento de índice zero de novo, acessando os campos com ponto.
	
	
	
	 
		
	
		3.
		Marque a afirmativa que represente uma separação.
	
	
	
	Intercalar a ordem dos dados da lista do final para o início, atualizando a lista.
	
	
	Alterar a ordem dos dados da lista do final para o início, atualizando a lista.
	
	
	Organizar os dados da lista em ordem crescente ou decrescente.
	
	
	Juntar duas listas, colocando uma lista no final de outra, obtendo, ao final, uma só lista resultante.
	
	
	Consiste em dividir a lista em duas outras listas. A quantidade de nós que cada lista terá, depende da necessidade.
		
	Gabarito
Comentado
	
	
	
	
	 
		
	
		4.
		Seja a seguinte seqüência de instruções em um programa C++: int *pti; int i = 10; pti = &i; Qual afirmativa é falsa?
	
	
	
	*pti é igual a 10
	
	
	pti é igual a 10
	
	
	ao se alterar o valor de i, *pti será modificado
	
	
	ao se executar *pti = 20; i passará a ter o valor 20
	
	
	pti armazena o endereço de i
	
Explicação:
Analisando cada opção :
	
	pti é igual a 10
	Explicação :  A afirmativa está incorreta porque *pti é igual 10 e não pti é igual a 10.  Note que pti é o endereço de i. Logo, a afirmativa deve ser marcada.
	
	pti armazena o endereço de i
	Explicação :  pti é um ponteiro que recebeu o endereço (&) de i. Logo, a afirmativa está correta e não deve ser marcada.
	
	*pti é igual a 10
	Explicação :  Afirmativa correta e não deve ser marcada, visto que * é o operador de indireção. Como pti aponta para i, logo *pti é i, que vale 10.
	
	ao se executar *pti = 20; i passará a ter o valor 20
	Explicação :  Afirmativa correta e não deve ser marcada, visto que *pti acessa a área apontada por i. Se *pti recebeu 20 significa que i recebeu 20.
	
	 
 
ao se alterar o valor de i, *pti será modificado
 
Explicação : Afirmativa correta e não deve ser marcada, visto que pti aponta para i e dessa forma, *pti é i.
	
	
	
	 
		
	
		5.
		Em uma aplicação que usa apenas o processo de alocação estática de memória é correto afirmar que:
	
	
	
	Todas as afirmações acima são incorretas
	
	
	A memória utilizada pela aplicação é totalmente alocada após o inicio de sua execução
	
	
	Apenas a memória associada às variáveis do tipo vetor é alocada após o inicio da execução da aplicação
	
	
	Toda a memória utilizada pela aplicação não muda durante toda a sua execução
	
	
	A memória utilizada pela aplicação é inicialmente estática, mas pode mudar
		
	Gabarito
Comentado
	
	
	
	
	 
		
	
		6.
		Na Alocação dinâmica, temos alguma regras a considerar. Leia atentamente as afirmativas abaixo e assinale a correta.
I Alocou com new, desaloca com free
II Alocou com new[], desaloca com delete
III Alocou com new[], desaloca com delete[]
IV Alocou com new[], desaloca com free[]
V Alocou com new, desaloca com delete
	
	
	
	III e V estão corretas
	
	
	I e III estão corretas
	
	
	I e IV estão corretas
	
	
	II e V estão corretas
	
	
	I, II, III e V estão corretas
	
	
	
	 
		
	
		7.
		Em uma rotina em que se pretenda inserir o primeiro dado em uma estrutura dinâmica, é correto afirmar que:
	
	
	
	Só deve existir estrutura de repetição se ocorrer a inclusão de mais de um dado simultaneamente
	
	
	Existe uma instrução de repetição para percorrer a lista.
	
	
	Deve existir uma estrutura de repetição somente de a lista for duplamente encadeada.
	
	
	Deve existir uma estrutura de repetição somente se a estrutura for circular.
	
	
	Não deve existir uma estrutura de repetição.
		
	Gabarito
Comentado
	
	
	
	
	 
		
	
		8.
		Considere a função em C++ que manipula  uma lista simplesmente encadeada :
void imprime (Lista  *l)   {
   Lista* p;
   for (p = l;   p != NULL;   p = p->prox)
         cout  <<"Info  =  "  <<  p->info;
}
sendo 
struct Lista {
                            int info;
                            struct Lista *prox;
};
 
	
	
	
	Função de busca
	
	
	Função que verifica se lista está vazia
	
	
	Função para liberar a lista
	
	
	Função que retira um elemento da lista
	
	
	Função que percorre os elementos da lista
	
Explicação:
Veja que existe um loop em que o ponteiro é inicializado e a cada rodada do for,  imprime o dado da lista e passa a apontar para o próximo nó da lista. Logo, a função percorre a lista.
 >> Não poderia ser verificar lista vazia porque para isso teríamos que testar se o ponteiro é NULL.
>> Não pode ser busca, pois seria  preciso testar cada elemento da lista. Se encontrasse deveria retornar o endereço do nó, caso contrário deveria retornar NULL.
>> Para retirar elemento teríamos que usar delete, para liberar memória, entre outros. Logo, não pode ser.
>> PAra liberar a lista teríamos que repetidamente usar delete, em um loop. Não pode ser.