ESTRUTURA DE DADOS Aula 8 Exercício 1

Prévia do material em texto

ESTRUTURA DE DADOS
8a aula
		
	 
	Lupa
	 
	 
	 
		1
        Questão
	
	
	Dr. Pei Tam possui uma lista não ordenada de pacientes de seu consultório em que registra apenas o nome endereço e o telefone de cada paciente. Como não há limites para o crescimento de sua lista, como se pode implementar a inserção de um novo paciente na lista, sabendo que cada paciente é do tipo Paciente e a lista é do tipo List assim definidos :
struct Paciente {
     long int matricula;
      string nome, endereco e tel;
};
struct List {
                           Paciente p;
                           struct List *link;
                  };
		
	
	List * inserePac(List *i)  {
      List *novo = new List;
     Paciente pat;
      novo->p =  pat;
      novo->link = i;
     return novo;
}
	
	List * inserePac(List  *i, Paciente pt){
      List *novo ;
      novo->p = pt;
      novo->link = i;
     return novo;
}
	
	 List * inserePac(List *i, Paciente pac)
{
      List *novo = new List;
      novo.p = pac;
      novo.link = i;
     return novo;
}
	
	List  insereCliente(List *i, Paciente pac)
{
      List  novo[];
      novo[0].p = pac;
      novo[0].link = i;
     return novo;
}
	 
	List * inserePac(List *i, Paciente pt)
{
      List *novo = new List;
      novo->p = pt;
      novo->link =i;
     return novo;
}
	Respondido em 07/09/2020 22:22:50
	
		
	Gabarito
Comentado
	
	
	 
		2
        Questão
	
	
	Para a criação de uma Fila seqüencial basta iniciar as variáveis de início e final, ou seja, apontá-las para as posições iniciais do vetor. O que alteraria na rotina de inserir se a variável final fosse inicializada com o valor -1 (menos um):
		
	
	Após a inserção deve-se fazer o incremento da variável inicio
	 
	Antes da inserção deve-se fazer o incremento da variável final
	
	Após a inserção deve-se fazer o decremento da variável final
	
	Após a inserção deve-se fazer o incremento da variável final
	
	Antes da inserção deve-se fazer o decremento da variável final
	Respondido em 07/09/2020 22:20:41
	
		
	Gabarito
Comentado
	
	
	 
		3
        Questão
	
	
	Admita a seguinte estrutura de nó de uma lista simplesmente encadeada: struct tno { int chave; tno *proximo; }; Admita, agora, a seguinte declaração de uma variável do tipo nó: tno *no; Qual das alternativas a seguir traz uma operação válida sobre essa variável?
		
	 
	no->proximo = new tno;
	
	no.proximo = no;
	
	no->proximo = -10;
	
	no->chave = new int;
	
	no.chave = 5;
	Respondido em 07/09/2020 22:20:44
	
Explicação:
Analisando cada item :
	 
	no.chave = 5;
	>> Como no é ponteiro então temos que usar a seta para acessar os campos da área apontada por no.
	 
	no->proximo = -10;
	>> O campo proximo é de ponteiro então não pode receber inteiro.
	 
	no->chave = new int;
	>> O campo chave é de inteiro então não deve receber endereço de inteiro.  O operador new aloca memória e retorna o endereço da área alocada.
	 
	no->proximo = new tno;
	>> É correto porque o campo proximo é campo de ponteiro e pode receber outro ponteiro, pode receber NULL ou pode receber endereço da área alocada com new, como foi o caso.
	 
	no.proximo = no;
>> Incorreto porque não pode se pode usar o ponto para acessar campo de struct apontada pelo ponteiro no.
	
	
	 
		4
        Questão
	
	
	q       Considere 
 
int *p, *q, *r;
int x = 10, y = 20;
 
Após seguir cada instrução na ordem dada a seguir :
 
p = &x;
q = &y;
*p = *p + *q;
(*q)++;
r = q;
q = p;
 
identifique a opção que fornece correta e respectivamente, os valores de *p, *q ,  *r ,   x   e   y  :
 
		
	 
	30  30  21  30  21
	
	30  20  0   30 21
	
	30  21  21  10  20
	
	30  20  20 10 20
	
	30  30  21  10   20
	Respondido em 07/09/2020 22:20:52
	
Explicação:
Fazendo passo a passo temos :
int *p, *q, *r;
int x = 10, y = 20;
p = &x;    //p aponta para x, que vale 10
q = &y;  // q aponta para y que recebeu 20
*p = *p + *q;    //a área apontada por p, que é x, vai receber 10 + 20, que dá 30. Logo, *p e x valem 30.
(*q)++;     //A área apontada por q é incrementada. Ou sejam, y ou *q recebem 21
r = q;     //r aponta para y
q = p;    // q aponta para onde p aponta, ou seja, q aponta para x
Logo :
*p , que é x, vale 30
*q, que é igual a *p, que é x, vale 30
*r é y, que vale 21
x vale 30
y vale 21
Logo, a resposta certa é  30  30  21  30  21
	
	
	 
		5
        Questão
	
	
	Qual o valor de x no final do programa? int main() { int x, *p, y; x = 2; p = &x; y = *p; y = 5; (*p)++; (*p) = (*p) - y; return(0); }
		
	
	5
	
	Nenhuma das anteriores. O programa possui um erro de sintaxe.
	
	2
	
	8
	 
	-2
	Respondido em 07/09/2020 22:20:59
	
Explicação:
Analisando passo a passo : 
int main() {
int x, *p, y;
x = 2;
p = &x;   // p aponta para x, sendo que x recebeu 2
y = *p;   //y recebeu o conteúdo da área apontada por p, ou seja, y recebeu *p que é 2
y = 5;   //y recebeu 5
(*p)++;  //A área apontada por p recebeu 3 Ou seja, x recebeu 3
(*p) = (*p) - y;   //*p, que é x recebeu 3 - 5. Ou seja, *p recebeu -2
return(0);
}
Como p aponta para x e *p recebeu -2, então x recebeu -2
	
	
	 
		6
        Questão
	
	
	Verifique as afirmativas e marque a opção correta.
I- Na alocação estática de memória a quantidade de memória alocada é feita em tempo de compilação.
II- Na alocação dinâmica de memória a quantidade de memória alocada é feita em tempo de execução.
III- Na alocação estática de memória a quantidade de memória alocada é fixa durante a execução do programa.
IV- Na alocação dinâmica de memória a quantidade de memória alocada é fixa durante a execução do programa.
		
	
	Apenas a I está correta
	
	Apenas a opção I está errada
	
	Apenas a II está correta
	 
	Apenas a IV está errada
	
	Apenas as opções I e II são corretas
	Respondido em 07/09/2020 22:23:27
	
Explicação:
Analisando cada afirmativa :
I- Na alocação estática de memória a quantidade de memória alocada é feita em tempo de compilação.
Correto. Aloca-se memória antes da execução.
II- Na alocação dinâmica de memória a quantidade de memória alocada é feita em tempo de execução.
Correto.
III- Na alocação estática de memória a quantidade de memória alocada é fixa durante a execução do programa.
Correto. A memória alocada antes da execução não sofre alteração durante a execução.
IV- Na alocação dinâmica de memória a quantidade de memória alocada é fixa durante a execução do programa.
Falso. A quantidade de memória não é fixa.
 
Apenas a afirmativa IV é falsa ou está errada.
	
	
	 
		7
        Questão
	
	
	Em algumas situações, principalmente na utilização de listas, há a necessidade de posicionar o ponteiro em determinado local da lista. Dessa forma, analisando o trecho de código abaixo, que mostra uma função, assinale a alternativa correta que descreve o objetivo desta. Sabe-se que o sinal de asterisco (*) sinaliza um ponteiro.
void funcao (Nodo **P){
 if ( *P != NULL ){
  while ( (*P) -> Anterior != NULL )
   *P= (*P) -> Anterior;
 }
}
		
	 
	Posicionar o ponteiro no início da lista
	
	Posicionar o ponteiro no meio da lista
	
	Posicionar o ponteiro onde houver o valor NULL
	
	Colocar o valor NULL em todos os ponteiros
	
	Posicionar o ponteiro no final da lista
	Respondido em 07/09/2020 22:23:34
	
		
	Gabarito
Comentado
	
	
	 
		8
        Questão
	
	
	Assinale a alternativa correta sobre alocação de memória.
		
	
	Alocação estática de memória refere-se ao processo de alocar memória com o uso de ponteiros.
	
	É correto afirmar que a alocação dinâmica de memória sempre leva a programas mais rápidos.
	
	Uma das vantagens da alocação dinâmica sobre a alocação estática é que não é necessário fazer a liberação da memória utilizada.
	 
	Na alocação dinâmica de memória, a memória é alocada sob demanda, apenas quando necessário.
	
	A declaração de um vetor é um exemplo clássico de alocação dinâmica de memória.
	Respondido em 07/09/2020 22:23:37