texto - Decom - Ufop

Universidade Federal de Ouro Preto – UFOP
Instituto de Ciências Exatas e Biológicas – ICEB
Departamento de Computação – DECOM
Disciplina: Algoritmos e Estruturas de Dados I – CIC102
Professor: David Menotti (menottid@gmail.com)
Aluno: ______________________________________________________________ No. ______
• A prova é individual e sem consulta, exceto o contido em sua mente;
• A interpretação das questões faz parte da avaliação;
• Faça as observações que acredita ser necessário, por escrito, na folha de resposta.
• Nas questões que requerem implementação escreva os algoritmos em C ou C++.
• Dica: primeiro, leia todas as questões e só, então, comece a resolver as questões a partir
das que você acredita serem as mais fáceis.
2ª. Avaliação – 2,4 pontos
(24% da nota total, onde 0,4 pontos extra)
1. (0,6 pontos) Considere uma pilha P vazia e uma fila F não vazia. Utilizando apenas os testes
de fila e pilha vazias (FilaVazia, PilhaVazia e FazPilhaVazia), as operações
Enfileira, Desenfileira, Empilha, Desempilha, e uma variável aux do tipo
TItem, escreva uma função em C/C++ que inverta a ordem dos elementos da fila (a função
recebe somente a fila como parâmetro). Uma sugestão para a definição (protótipo) da função
é:
void InverteFila(TFila* pFila);
2. (0,6 pontos) Escreva uma função em C/C++
int Troca(TLista* pLista, TCelula* p, TCelula* q)
que, dado dois apontadores quaisquer para células (p e q), troca de posição essas células na
lista simplesmente encadeada, como mostrado na figura abaixo. (Obs. Não vale trocar
apenas o campo item! Você deverá fazer a manipulação dos apontadores para trocar as duas
células de posição). Considere que p e q não são adjacentes (um do lado do outro).
Antes: X Y
λ
Primeiro p
q
Ultimo
Depois: Y X
λ
Primeiro q
p
Ultimo
q
p

Universidade Federal de Ouro Preto – UFOP
Instituto de Ciências Exatas e Biológicas – ICEB
Departamento de Computação – DECOM
Disciplina: Algoritmos e Estruturas de Dados I – CIC102
Professor: David Menotti (menottid@gmail.com)
3. (0,6 pontos) Considere uma árvore estritamente binária e quase completa, composta por
um ponteiro para o nó raiz, onde cada nó é composto por um valor inteiro e ponteiros para
os nós direito e esquerdo, como os TADs apresentados abaixo:
typedef struct Tarvore
{
TNo *pRaiz;
} TArvore;
typedef struct TNo
{
int valor;
TNo *pEsq;
TNo *pDir;
} TNo;
Construa uma função em C/C++ que receba dois valores inteiros e um ponteiro para árvore
estritamente binária e quase completa, e então insira os dois novos nós (representados pelos
valores inteiros recebidos) na árvore de forma que ela continue sendo uma árvore
estritamente binária e quase completa. Obs: caso a árvore esteja vazia somente um dos
valores deverá ser inserido na árvore, de forma que ela continue sendo estritamente binária e
quase completa. Caso seja necessário usar outras estruturas de dados como pilhas, filas e
listas, considere que elas já estão implementadas.
4. (0,6 pontos) Considere uma matriz composta por valores 1 e 0 representando uma imagem
binária (ponto branco valor 0, ponto preto valor 1) como ilustrado na figura abaixo.
unsigned char img[10][10] = {
{0,0,1,1,0,0,0,0,0,0},
{0,1,0,0,0,1,0,0,0,0},
{0,1,0,1,1,0,0,0,1,0},
{0,1,0,0,1,0,1,0,0,0},
{0,1,1,0,1,0,1,1,0,0},
{0,0,0,0,1,0,0,1,0,0},
{0,0,1,0,1,0,1,1,1,0},
{0,0,1,1,1,0,0,1,0,1},
{0,0,0,0,0,0,1,1,0,0},
{0,0,0,0,0,0,1,0,0,0} };
A matriz/imagem apresentada acima/esquerda contém quatro regiões (uma com 7 pontos,
duas com 11 pontos e uma última com um único ponto). Construa uma função em C/C++,
que determine (e retorne) o número de regiões existentes em uma matriz/imagem. Uma
sugestão para a definição (protótipo) da função é:
Considere os TADs definidos abaixo,
typedef struct TPonto
{
int x,y;
struct TPonto* pstProx;
} TPonto;
int Regiao(TMatriz* pImagem);
typedef struct TMatriz
{
int m,n;
unsigned char** Matriz;
} TMatriz;
Também considere que funções de pilhas e filas já estão implementados para o TAD
TPonto. Ainda considere que existem funções para criar, liberar e «zerar» o TAD TMatriz.