Das 5102 – Fundamentos da Estrutura da Informação
Gabarito da Segunda Prova1. Tipos Abstratos de Dados – TADs – é uma forma programar. Eles permitem a estrutura de programas em módulos correlacionando estruturas de dados com conjuntos de funções.
Em C, TADs são estruturadas em dois arquivos. No arquivo <TAD>.h que compõe o cabeçalho da TAD deve conter a definição das estruturas de dados e as definições ou protótipos das funções relacionadas que serão implementadas no arquivo <TAD>.c. 2. Toda função de uma TAD (exceto possivelmente função de criação da
estrutura) deve receber uma referência para a estrutura de dados definida na TAD. Isso permite que sejam criadas e manipuladas diferentes versões da estrutura de dados em um mesmo programa. Ex: Pilha *p1, *p2; criaPilha(p1); criaPilha(p2); push(p1,10); push(p2, pop(p1)); 3. Passos:
a) Encontrar a posição para inserção
b) Checar se a posição para inserção é válida
c) Inserir o novo elemento via o correto ajuste de ponteiros
int inserirNaPosicao(celula *le, int dado, int pos){ celula *ne, *temp;
temp = le; if(pos == 1){ ne = malloc(sizeof(celula)); ne->prox = NULL; ne->dado = dado; le = ne; return 1; } else{ int cont = 1;
while(cont < pos) && (temp->prox != NULL){ temp = temp->prox;
cont++; }
if((cont == pos-1) && (temp->prox == NULL)){ ne = malloc(sizeof(celula)); ne->prox = NULL; ne->dado = dado; temp->prox = ne; return 1; }else{ ne = malloc(sizeof(celula)); ne->dado = dado; ne->prox = temp->prox; temp->prox = NE; return 1; } }return 0; }
4. Pesquisa de informações em uma lista:
a) int buscaElementoA(celula *le, int elem){ int cont = 1;
celula *temp; temp = le;
if(temp == NULL){ //lista vazia
printf(“a lista se encontra vazia!”); return 0;
}
while(temp->dado != elem){
if(temp->prox == NULL) // final da lista{ return 0; // função falhou
} temp = temp->prox; cont++; } return cont; }
b) celula *buscaElementoB(celula *le, int pos){ int cont = 1;
celula *temp; temp = le;
if(temp == NULL){ //lista vazia
printf(“a lista se encontra vazia!”); return NULL;
}
while(count < pos){
if(temp->prox == NULL){ // final da lista return NULL; // função falhou
} temp = temp->prox; cont++; } return temp; }
5. Uma Heap pode ser implementada usando arrays como estrutura de dados base se a árvore binária que a modela for completa ou quase completa. Isto se deve ao fato das árvores binárias completas e quase completas poderem ser numeradas seqüencialmente de cima para baixo e da esquerda para a direita. Ainda, podemos facilmente identificar os graus de relacionamento na árvore via duas regras bem simples:
a) Filho esquerdo = 2*pai b) Filho direito = 2*pai +1
6. Considere as duas propriedades a seguir:
a) Em uma árvore completa todos os nós folha estarão localizados no último nível da árvore;
b) Em uma árvore quase completa, todos os nós folha estarão no último ou no penúltimo nível da árvore. Os nós folha do último nível em uma árvore quase completa devem estar todos localizados à esquerda. int ehCompleta(celula *ab){
int altura = retornaAltura(ab); //retorna a altura de ab int resultado = checaNivelFolha(ab, altura);
printf(“a árvore especificada é completa!”); return 1;
}else if(resultado == 2) {
printf(“a árvore especificada é quase completa!”); return 2;
} else{
printf(“a árvore especificada é genérica”); return 0;
} }
int checaNivelFolha(celula *ab, int alt) { int ra, rb; ra = rb = 0; if(ab->esq != NULL){ ra = checaNivelFolha(ab->esq, alt); } if(ab->dir != NULL){ rb = checaNivelFolha(ab->dir, alt); } if(ab->nivel == alt){ return 1;
} else if((ab->nivel == alt -1)&& (ra ==0) && (rb==0)){ return 2;
}
if (ra == 1) && (ra == 1) return 1;
else if ((ra == 1)||(ra==2)) &&(rb == 2) return 2;
else
return 0; }
}
7. Não. A função merge proposta para árvores binárias não funcionaria no caso de Heaps porque ela não garante que as propriedades da forma e da heap serão satisfeitas. Considerando que a TAD heap é dada, uma forma simples de, dadas as heaps Ha e Hb, construir uma nova heap Hc contendo todos os elementos de Ha e Hb e ainda mantendo as propriedades da heap, pode ser dada como:
Heap *mergeHeaps(Heap *Ha, Heap *Hb){ Heap *tempA, *tempB;
tempA = copyHeap(Ha); tempB = copyHeap(Hb); while(!isEmpy(tempB)) { Insere(TempA, remove(TempB)); } return tempA; } 8. struct heap{ int chave[20]; int dado[20];
int topo; }
typedef struct heap Heap;
void insere(Heap *h, int c, int d){ int temp, p, index = h->topo; h->chave[topo] = c; h->dado[topo] = d; h->topo = h->topo + 1; p = (int)(index/2); while((h->chave[index] > h->chave[p])&&(p!=0)){ temp = h->chave[index]; h->chave[index] = h->chave[topo]; h->chave[topo] = temp; index = p; p = (int)(index/2); } } int remove(Heap *h){
int temp, index, fe, fd, indiceDeTroca; int tempData = h->dado[0];
h->chave[0] = h->chave[h->topo -1]; h->topo = h->topo - 1; index = 1; fe = index * 2; fd = index * 2 + 1;
while((h->chave[index] < h->chave[fe])||( h->chave[index] < h->chave[fd])){
indiceDeTroca = maxKey(h, fe, fd); temp = h->chave[indiceDeTroca]; h->chave[indiceDeTroca] = h->chave[index]; h->chave[index] = temp; index = indiceDeTroca; fe = index * 2; fd = index * 2 + 1; } }
9. Para a solução desta questão, consideraremos uma fila de prioridade não ordenada
struct cel{ int dado;
struct cel *prox; struct cel *ant; int prioridade; };
typedef struct cel celula; struct fp{
struct cel *head; struct cel *tail; int size;
};
typedef struct fp FilaPr;
celula *c; c = malloc(sizeof(celula)); c->ant = null; c->prioridade = prior; c->dado = dado; c->prox = f->tail; f->tail = c; } celula *removeP(FilaPr *f){ int maxP;
celula *maxCel, *temp; temp = f->tail; maxP = temp->prioridade; maxCel = temp; while(temp->prox != NULL){ temp = temp->prox; if(maxP < temp->prioridade){ maxP = temp->prioridade; maxCel = temp; } } (maxCel->ant)->prox = (maxCel->prox); (maxCel->prox)->ant = (maxCel->ant); return maxCel; }
//Observe que a função acima nao considera o caso do elemento ser único na lista, ou os casos em que o elemento a ser removido são o primeiro ou o último da lista. A preocupação principal com relação a questão está na identificação do elemento e no ajuste dos ponteiros. 10.Nota: como definido durante a prova, consideraremos apenas
operações simples sem parênteses e sem prioridades entre as operações
float resolveEquacao(char *str){ char *elem;
Pilha *PNums, *POps; int d1, d2, d3;
PNums = criaPilha(); POps = criaPilha();
//parsing da string, conside funções que tomam conta desta tarefa while(elementosNaString(str)){ elem = proxElemento(str); if (ehNumero(elem)){ Celula *c = malloc(sizeof(Celula)); c->num = atoi(elem); push(c, PNums); }else{ Celula *c = malloc(sizeof(Celula)); c->op = elem; push(c, POps);
} } while(numElementos(POps) > 0){ d1 = pop(PNums)->num; d2 = pop(PNums)->num; elem = pop(POps)->op; swhich (elem){ case ‘+’: d3 = d1 + d2; break; case ‘-’: d3 = d1 - d2; break; case ‘*’: d3 = d1 * d2; break; case ‘/’: d3 = d1 / d2; break; } Celula *c2 = malloc(sizeof(Celula)); c2->num = d3; push(c2, PNums); } return pop(PNums)->num; }
