max1: 20,max2:+ max1:15, max2:20 max1:30,max2:32,max3:35 max1:40,max2:+

Transcrição

1 Estruturas de Dados Algumas Respostas da Lista 4 Angelo Ciarlini 1- Mostre o aspecto de uma árvore 2-3 que armazena números inteiros após a inserção dos números 30, 20, 10, 40, 15, 35 e 32, nesta ordem. max1: 20,max2:+ max1: 10,max2:20 max1:35, max2:+ max1:-, max2:10 max1:15, max2:20 max1:30,max2:32,max3:35 max1:40,max2: Mostre o aspecto da árvore 2-3 anterior após a remoção dos números 10,15 e 32, nesta ordem. max1: 20,max2:35,max3:+ max1:-, max2:20 max1:30,max2:35 max1:40,max2: Dado um vetor de inteiros com as sete primeiras posições preenchidas, respectivamente com 33, 12, 45,18, 69, 2 e 20, mostre como a ordem dos elementos varia a cada passo da execução do: a. Bubble sort

2 Fim da primeira passada Fim da segunda passada Fim da terceira passada Fim da terceira passada Fim da quarta passada Obs: Após quinta passada saber-se-á que o vetor já está ordenado b. Quick sort Posições Posições Posições Posições 5-6 Obs: Na ordenação das posições 0-3 não há mudanças c. Heap sort Construção do Heap: Posições do heap: Posições do heap: Posições do heap: Posições do heap: 0-4 (ainda não é heap) Posições do heap: 0-6 Desconstrução do Heap: Posições do heap: 0-5 (ainda não é heap) Posições do heap: Posições do heap: 0-4 (ainda não é heap) Posições do heap: Posições do heap: 0-3 (ainda não é heap) Posições do heap: Posições do heap: 0-2 (ainda não é heap) Posições do heap: 0-2 (ainda não é heap) Posições do heap: Posições do heap: 0-1 (ainda não é heap) Posições do heap: Posições do heap: Imagine que você precisa ordenar um vetor com milhares de números e você tem a alternativa de usar funções que implementam o bubble sort, o quick sort e o heap sort. Qual seria o algoritmo adequado a ser utilizado se desejo uma boa eficiência e quero manter o tempo de ordenação o mais constante possível, independente da ordem inicial? Por quê?

3 Resp: O heap sort seria o mais adequado porque ele é ordem O(n log n) independente da disposição inicial dos elementos. O bubble sort é O(n 2 ) e o quick sort é ordem O(n log n) somente quando os elementos estão embaralhados, tendo também O(n 2 ) no pior caso (quando os elementos já estão em ordem). 5 - Explique por que o quick sort é mais eficiente quando os elementos a ordenar estão embaralhados e menos eficiente quando eles já estão praticamente em ordem. Quando os elementos estão embralhados, divide-se, a cada passo, o problema em dois problemas da ordem de aproximadamente metade da ordem original. Se estruturarmos os problemas sob a forma de uma árvore veremos que essa árvore terá altura O(log n). Como, em cada nível da árvore, há uma quantidade de trocas O(n), o algoritmo tem, nesse caso O(n log n). Quando os elementos já estão em ordem (caso extremo), a cada passo coloca-se um elemento na posição e obtém-se um novo vetor com uma posição a menos. Como em cada passo é necessário percorrer os elementos, a ordem final é dada pela soma de uma P.A., logo a ordem do algoritmo, nesse caso, é O(n 2 ). 6 - Faça uma rotina que lê um arquivo texto contendo um caderno de telefones com 3 linhas em seqüência para cada pessoa - o apelido (máx. 10 caracteres minúsculos); - o nome (máx. 40 caracteres); e - o telefone (máx. 30 caracteres) e guarda em memória principal todas as informações #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX 100 typedef struct pessoa char apel[11]; char nome[41]; char end[31]; PESSOA; PESSOA * vet[max]; int n=0; /* número de pessoas */ void le_arq_texto(char *nomearq) FILE *arq;

4 if ((arq=fopen(nomearq,"rt"))==null) printf("erro: arquivo não foi aberto!"); abort(); else while (!feof(arq)) vet[n]= (PESSOA *) malloc(sizeof(pessoa)); fscanf(arq,"%[^\n]\n",vet[n]->apel); /* nao verifica comprimentos */ fscanf(arq,"%[^\n]\n",vet[n]->nome); fscanf(arq,"%[^\n]\n",vet[n]->end); n++; fclose(arq); Faça uma rotina que ordene as informações do exemplo anterior por apelido e as grave em um arquivo binário /* find devolve a posicao correta de x */ int find(char * x, int inf, int sup) int a=inf, b=sup; do while ((strcmp(vet[a]->apel,x)<=0) && (a<n)) /* procura primeiro maior que x */ a++; while (strcmp(vet[b]->apel,x)>0) /* procura ultimo menor que x */ b--; if (b>a) PESSOA * temp=vet[a]; /* troca */ vet[a]=vet[b]; vet[b]=temp; while (b>a); /* continua ate separar os maiores que x dos menores que x */ return a-1; /* x vai entrar no lugar do ultimo menor que x */ /* quicksort */ void sort(int a, int b) PESSOA * x; if (b<=a) /* vetor nao precisa ser ordenado */ return; x=vet[a];

5 i=find(x->apel,a+1,b); /* determina posicao correta de x */ vet[a]=vet[i]; vet[i]=x; sort(a,i-1); /* ordena parte antes de x */ sort(i+1,b); /* ordena parte depois de x */ void salva_arquivo(char *nomearq) FILE *arq=fopen(nomearq,"wb"); for (i=0; i<n; i++) fwrite(vet[i],sizeof(pessoa),1,arq); fclose(arq); void grava_ordenado(char *nomearq) sort(0,n-1); salva_arquivo(nomearq); Defina uma estrutura de dados para armazenar matrizes esparsas quadradas NxN e escreva funções para verificar se uma dada matriz é: a. Simétrica b. Diagonal c. Triangular superior /* Estrutura de Dados */ #define N 5 typedef struct no *pt; struct no int col; int val; pt prox; ; typedef pt matriz[n]; int simetrica(matriz m) int i,j;

6 for(p=m[i];(p!=null); p=p->prox) j=p->col; if (((i+1)!=j) && (get(m,j,i+1)!=p->val)) return 0; return 1; int diagonal(matriz m) for(p=m[i];(p!=null); p=p->prox) if (p->col!=(i+1)) return 0; return 1; int triangular_sup(matriz m) for(p=m[i];(p!=null); p=p->prox) if (p->col<(i+1)) return 0; return 1; 9 - Para a mesma estrutura de dados do exemplo anterior faça rotinas que informem a linha e a coluna da matriz com maior valor médio. descobre_pos_maior(int vet[n]) /* Função auxiliar: acha do maior elemento */ int i,pos=0,maior=vet[0]; for (i=1;i<n;i++) if (vet[i]>maior) maior=vet[i]; pos=i; return pos;

7 int maior_media_linha(matriz m) int i,soma[n]; soma[i]=0; for (p=m[i]; p!=null; p=p->prox) soma[i]+=p->val; return descobre_pos_maior(soma)+1; int maior_media_coluna(matriz m) int i,soma[n]; soma[i]=0; for (p=m[i]; p!=null; p=p->prox) soma[p->col-1]+=p->val; return descobre_pos_maior(soma)+1; 10. Defina um tipo conjunto onde os elementos podem ser números entre e 1000 usando vetores de bits. Faça funções para obter: a. A união de dois conjuntos. b. A interseção de conjuntos. c. A diferença de conjuntos. d. Para descobrir o maior elemento de um conjunto. #include <stdio.h> #define MAX 1000 #define MIN (-1000) #define NUM_BITS (MAX-MIN+1) #define TAM (8*sizeof(int)) #define NUM_INTS ((NUM_BITS/TAM)+1) typedef int SET[NUM_INTS]; void uniao(set s1,set s2,set s3)

8 for (i=0;i<num_ints;i++) s3[i]=s1[i] s2[i]; void intersec(set s1,set s2,set s3) for (i=0;i<num_ints;i++) s3[i]=s1[i]&s2[i]; void diferenca(set s1,set s2,set s3) for (i=0;i<num_ints;i++) s3[i]=s1[i]&(~s2[i]); int maior_elemento(set s) /* Percorre para trás procurando a partir do último bit do último inteiro. Retorna (MIN-1) se o conjunto está vazio. */ int i=num_ints-1, j=(num_bits-1)%tam; while (i>=0) if ((s[i] & 1<<j)!=0) return (i*tam+j)+min; else j--; if (j<0) j=tam; i--; return MIN-1; 11. Explique os mecanismos de tratamento de colisão em tabelas "hash". VER SEÇÃO 14.2 DA APOSTILA