2
Questão 1.a) (2.5 pontos ) Considere um vetor de ponteiros para Bolsista ordenado em ordem
crescente (alfabética) por tipoDaBolsa. Para um mesmo tipo de bolsa, o vetor encontra-se
ordenado crescentemente por matricula (ver exemplo na Figura 1). Escreva uma função
EhBolsista que usando a técnica de busca binária verifica se já existe um determinado bolsista
neste vetor, isto é, para um tipo de bolsa e uma matrícula. Você deve obrigatoriamente
escrever uma função auxiliar de comparação.
Figura 1
static int compara(Bolsista * bol, char * tipo, int matricula) { int resp; resp = strcmp(bol->tipoDaBolsa,tipo); if (resp !=0) return resp; if (bol->matricula < matricula) return -1; if (bol->matricula > matricula) return 1; return 0; }
0.2 – protótipo com static, e os parâmetros dos tipos corretos 0.3 – chamada da strcmp com teste e retorno correto
Perde 0.3 se comparar as strings
0.4 – tratamento das 3 possibilidades da comparação da matricula
int EhBolsista(Bolsista ** v, int n, char * tipo, int matricula) { int ini=0,fim=n-1,meio,resp; while(ini<=fim) { meio=(ini+fim)/2; resp = compara(v[meio],tipo,matricula); if (resp <0) ini=meio+1; else if (resp >0) fim=meio-1; else return 1; } return 0; }
0.5 – protótipo com os parâmetros dos tipos corretos e a presença de todos
0.3 – chamada correta da função compara com armazenando do resultado em uma variável Perde 0.2 se colocar a chamada da compara em todas as condições do teste
0.3 – pelos 2 returns corretos. Tanto pelo valor retornado como pela posição correta 0.5 – pelo desenvolvimento da pesquisa binária: inicialização correta de ini e de fim, posição correta de cáculo do valor de meio, atualização correta de ini e de fim, condição correta do while
3
struct tipomat { int matricula; char tipo[21]; };typedef struct tipomat TipoMat;
0.3 – declaração de uma estrutura para representar o tipo estruturado para a busca static int compTipoMat(const void * a, const void * b)
{
TipoMat *info = (TipoMat*)a; Bolsista **bol = (Bolsista**)b;
int resp = strcmp(info->tipo, (*bol)->tipoDaBolsa); if (resp !=0) return resp; if (info->matricula < (*bol)->matricula) return -1; if (info->matricula > (*bol)->matricula) return 1; return 0; }
0.3 – protótipo com static, e os parâmetros dos tipos corretos 0.3 – chamada da strcmp com teste e retorno correto
Perde 0.3 se comparar as strings
0.4 – tratamento das 3 possibilidades da comparação da matricula int EhBolsista(Bolsista ** v, int n, char * tipo, int matricula) {
Bolsista **b; TipoMat info;
info.matricula = matricula; strcpy(info.tipo, tipo);
b = (Bolsista**)bsearch(&info, v, n, sizeof(Bolsista*), compTipoMat); if(b==NULL)
return 0; return 1; }
0.3 – protótipo com os parâmetros dos tipos corretos e a presença de todos 0.6 – chamada correta da função bsearch
4
Questão 1.b) (3.0 pontos) Considere a existência de uma lista simplesmente encadeada com
pedidos de bolsa. O tipo que representa o nó encadeado é o tipo estruturado
Pedido (ver
exemplo na Figura 2).
Figura 2
Usando obrigatoriamente a função desenvolvida na questão anterior, escreva a função
eliminaPedidosRepetidos que elimina da lista os pedidos já existentes no vetor de ponteiros
para Bolsista e retorna a lista alterada. Note que é para alterar a lista recebida e não fazer uma
nova lista. Exemplo: dado o vetor da Figura 1 e a lista da Figura 2, a função deve retornar a
lista da Figura 3.
Figura 3
Pedido * eliminaPedidosRepetidos(Bolsista ** v, int n, Pedido * lst) {
Pedido *p, *aux, *ant=NULL; p=lst; while (p!=NULL) { if (EhBolsista(v,n,p->tipoDoPedido,p->matricula)) { if(ant==NULL) { aux=lst; lst=lst->prox; free(aux); p=lst; } else { ant->prox=p->prox; free(p); p=ant->prox; } } else { ant = p; p=p->prox; } } return lst; }
0.5 – protótipo com os parâmetros dos tipos corretos e a presença de todos 0.1 – inicialização da variável para percorrer a lista
0.3 – repetição até o fim da lista (while)
0.8 – chamada da função de busca com os parâmetros corretos e teste se vai eliminar o nó 0.5 – retirada do pedido da lista considerando se é o primeiro nó
0.4 – retirada do pedido da lista se é um nó intermediário 0.3 – caminhar na lista de pedidos sem retirar o nó (último else) 0.1 – retorno
5
Questão 1.c) (3.0 pontos) Considerando apenas o tipo estruturado Bolsista, escreva a função
ordenaDataInicio que ordena o vetor de ponteiros para Bolsista, pelo método de quick sort
(ordenação rápida), de modo que os bolsistas mais antigos precedam os mais recentes. No
caso de mesmo ano e mês de início da bolsa, os bolsistas devem ficar ordenados
crescentemente por nome. Você deve obrigatoriamente escrever uma função auxiliar de
comparação. Se você preferir, você pode usar a função qsort da biblioteca. Exemplo:
Original Após Ordenação
Vetor de Bolsistas: 410 Duda dout 6 2010 411 Paulo dout 2 2014 201 Gina ic 6 2011 202 Andre ic 3 2011 203 Carlos ic 6 2010 301 Bia mest 5 2010 101 Ana soc 5 2010 102 Bela soc 6 2010 Vetor de Bolsistas: 101 Ana soc 5 2010 301 Bia mest 5 2010 102 Bela soc 6 2010 203 Carlos ic 6 2010 410 Duda dout 6 2010 202 Andre ic 3 2011 201 Gina ic 6 2011 411 Paulo dout 2 2014
Figura 4
static int compData(Data d1,Data d2){ if (d1.ano < d2.ano) return -1; if (d1.ano > d2.ano) return 1; if (d1.mes < d2.mes) return -1; if (d1.mes > d2.mes) return 1; return 0; }
0.5 – teste dos valores de ano e mês com retorno correto static int menor (Bolsista * b, Bolsista * x)
{
int resp = compData(b->dataInicio, x->dataInicio);
return resp >0 || (resp == 0 && strcmp(b->nome,x->nome)>0); }
1.0 – função de comparação em separado considerando os tipos envolvidos e o valor de retorno
perde 1.0 se não tiver a função de comparação em separado void ordenaDataInicio(Bolsista ** v, int n)
{ int a = 1, b = n-1; Bolsista * x; Bolsista * temp; if (n<=1) return; x=v[0]; do {
while (a<n && !menor(v[a],x)) a++; while (menor(v[b],x)) b--; if (a<b) { temp = v[a]; v[a] = v[b]; v[b] = temp; a++; b--; } } while (a<=b); v[0]=v[b]; v[b]=x; ordenaDataInicio(v,b); ordenaDataInicio(&v[a],n-a); } 1.5 – ordenação rápida
6
static int compData(Data d1,Data d2){ if (d1.ano < d2.ano) return -1; if (d1.ano > d2.ano) return 1; if (d1.mes < d2.mes) return -1; if (d1.mes > d2.mes) return 1; return 0; }
0.5 – teste dos valores de ano e mês com retorno correto static int compMenor(const void * a, const void * b) {
Bolsista **aa = (Bolsista **)a; Bolsista **bb = (Bolsista **)b;
int resp = compData((*aa)->dataInicio, (*bb)->dataInicio);
return resp >0 || (resp == 0 && strcmp((*aa)->nome,(*bb)->nome)>0); }
1.5 – função de comparação
void ordenaDataInicio(Bolsista ** v, int n) {
qsort(v, n, sizeof(Bolsista*), compMenor); }
7
Questão 2 (1.5 ponto): Considere o tipo estruturado Pedido, que representa um nó de uma
lista simplesmente encadeada de pedidos. Assumindo que a lista não está ordenada, escreva a
função RECURSIVA maior
Matricula que recebe a lista (ou seja , o ponteiro para o primeiro
elemento da lista) e retorna a maior matrícula (ou seja, a matrícula de maior valor). Caso não
exista nenhum pedido a função retorna -1. Exemplo: para uma lista de pedidos como a da
Figura 2, a função retorna o valor 415.
int maiorMatricula(Pedido * lst) {
int max1, max2; if (lst==NULL) return -1;
max1 = lst->matricula;
max2 = maiorMatricula (lst->prox); if (max1 > max2) return max1; else return max2; } Outra solução:
int maior(int n1, int n2) { if (n1 > n2) return n1; return n2; } int maiorMatricula(Pedido * lst) { if (lst==NULL) return -1;
return maior(lst->matricula, maiorMatricula (lst->prox)); }
0.2 – protótipo correto 0.2 – caso base
0.5 – passo recursivo com atribuição de valor a max2
0.6 – teste se o maior é o primeiro da lista ou o maior da sub-lista com retorno correto, diretamente ou através de função auxiliar
