apostila aed
DESCRIPTION
TRANSCRIPT
![Page 1: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/1.jpg)
www.professoresalgoritmos.com
Apostila: Estruturas de dados e Arquivos
Ivre Marjorie R. Machado
Linguagem de programação C++
![Page 2: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/2.jpg)
www.professoresalgoritmos.com
Índice
1- Registros 2- Alocação Dinâmica de Memória3- Ponteiros4- Análise de Complexidade5- Técnicas de Análise de Algoritmos6- Tipos Abstratos de dados (TAD)7- TAD – Listas Encadeadas8- TAD – Pilha9- TAD – Fila
![Page 3: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/3.jpg)
www.professoresalgoritmos.com
Índice
10- Recursividade11- TAD – Árvores12- Balanceamento em Árvores13- Pesquisa em Memória Primária Árvore Binária de Busca14- Pesquisa em Memória Primária Tabela Hash15- Pesquisa Digital Árvore TRIE16- Ordenação
![Page 4: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/4.jpg)
www.professoresalgoritmos.com
Registros
Ivre Marjorie R. Machado
![Page 5: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/5.jpg)
www.professoresalgoritmos.com
Definição
• Registros são estruturas de dados capazes de agregar várias informações
• É possível gerar novos tipos de dados, não se limitando apenas à utilização dos tipos de dados primitivos (char, int, float, double)
• Cada informação contida em um registro é chamada de campo ou membro
5
![Page 6: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/6.jpg)
www.professoresalgoritmos.com
Definição
• Os campos podem ser de diferentes tipos primitivos, ou mesmo podem representar outros registros
Registros são conhecidos como variáveis compostas heterogêneas
6
![Page 7: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/7.jpg)
www.professoresalgoritmos.com
Declaração de Registros
• São definidos por meio da utilização da palavra struct, conforme apresentado:
struct nome_do_registro
{
tipo campo1;
tipo campo2;
...
tipo campon;
};
7
![Page 8: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/8.jpg)
www.professoresalgoritmos.com
Declaração de Registros
struct Aluno
{
char nome[255];
int idade, cel;
char endereco[300];
};
Palavra-chave Nome do Registro
chaves
Ponto-e-vírgula
Campos ou Membros
8
![Page 9: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/9.jpg)
www.professoresalgoritmos.com
Declaração de Registros
• Definir uma estrutura não cria nenhuma variável, somente informa ao compilador as características de um novo tipo de dados
• Não há reserva de memória
• No exemplo, foi definido um novo tipo de dado denominado Aluno
• A definição desse tipo pode vir antes da função main() ou dentro dela
9
![Page 10: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/10.jpg)
www.professoresalgoritmos.com
Declaração de Variáveis do Tipo Registro
• Para utilizar uma struct, é necessária a declaração de variáveis desse tipo:
• Para o nosso exemplo:
nome_do_registro nome_da_variável;
Aluno alu1, alu2;
variáveisTipo de dado10
![Page 11: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/11.jpg)
www.professoresalgoritmos.com
Declaração de Variáveis do Tipo Registro
• A declaração reserva espaço de memória suficiente para armazenar cada um dos membros da estrutura (nome, idade, cel e endereco) para a variável alu1 e alu2
• Também é possível declarar um vetor ou uma matriz do tipo da estrutura, como:
Aluno alu[10], mat[2][3];
vetor matriz11
![Page 12: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/12.jpg)
www.professoresalgoritmos.com
Acesso a Membros de Estruturas
• Após a variável ser declarada, o programa precisa manipular o conteúdo de cada campo individualmente
• Para isso, é preciso informar o nome da variável e o do campo desejado, separados por um ponto
nome_da_variável.nome_do_campo
ponto12
![Page 13: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/13.jpg)
www.professoresalgoritmos.com
Acesso a Membros de Estruturas
• Para armazenar um determinado valor nas variáveis do exemplo:
• Para armazenar um dado digitado pelo usuário
strcpy(alu1.nome,”Maria”);
alu1.idade = 16;
gets(alu1.nome);
Cin<<alu1.idade;
13
![Page 14: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/14.jpg)
www.professoresalgoritmos.com
Exemplo 1
int main()
{
//nesse exemplo a estrutura foi criada dentro da main()
struct Aluno
{
char nome[255];
char endereco[300];
int idade, cel;
} alu1;
cout<<"\nCadastro - Aluno 1: ";
cout<<"\nDigite o nome: ";
gets(alu1.nome);
cout<<"\nDigite o endereco: ";
gets(alu1.endereco);
cout<<"\nDigite a idade: ";
cin>>alu1.idade;
cout<<"\nDigite o celular: ";
cin>>alu1.cel; 14
![Page 15: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/15.jpg)
www.professoresalgoritmos.com
Exemplo 1
cout<<"\n************* Cadastro realizado *************";
cout<<"\nAluno 1 ";
cout<<"\nNome: "<<alu1.nome;
cout<<"\nIdade: "<<alu1.idade;
cout<<"\nCel: "<<alu1.cel;
cout<<"\nEndereco: "<<alu1.endereco;
cout<<"\nFim do programa!"
system("PAUSE");
return EXIT_SUCCESS;
}
15
![Page 16: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/16.jpg)
www.professoresalgoritmos.com
Exemplo 2
//nesse exemplo a estrutura foi criada fora da main()
struct Aluno
{
char nome[255];
char endereco[300];
int idade, cel;
};
int main()
{
Aluno alu1;
cout<<"\nCadastro - Aluno 1: ";
cout<<"\nDigite o nome: ";
gets(alu1.nome);
cout<<"\nDigite o endereco: ";
gets(alu1.endereco);
cout<<"\nDigite a idade: ";
cin>>alu1.idade;
cout<<"\nDigite o celular: ";
cin>>alu1.cel; 16
![Page 17: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/17.jpg)
www.professoresalgoritmos.com
Exemplo 2
cout<<"\n************* Cadastro realizado *************";
cout<<"\nAluno 1 ";
cout<<"\nNome: "<<alu1.nome;
cout<<"\nIdade: "<<alu1.idade;
cout<<"\nCel: "<<alu1.cel;
cout<<"\nEndereco: "<<alu1.endereco;
cout<<"\nFim do programa!"
system("PAUSE");
return EXIT_SUCCESS;
}
17
![Page 18: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/18.jpg)
www.professoresalgoritmos.com
Declaração de Vetor do tipo Registro
• Pode-se criar vetores utilizando uma estrutura de dados
• Alterando o exemplo para que sejam armazenados os dados (nome, idade, cel, endereco) de 10 alunos.
Aluno alu[10];
vetor
18
![Page 19: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/19.jpg)
www.professoresalgoritmos.com
Acesso a Membros com Vetor de Estruturas
• Para preencher o vetor todo com 10 alunos
for(i=0; i<10; i++)
{
gets(alu1[i].nome);
cin<<alu1[i].idade;
}
Índice do vetor
19
![Page 20: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/20.jpg)
www.professoresalgoritmos.com
Exemplo 3struct Aluno
{
char nome[255];
char endereco[300];
int idade, cel;
};
int main()
{
Aluno alu1[10];
int i;
for(i=0; i<10; i++)
{
cout<<"\nCadastro - Aluno "<<i+1<<": ";
cout<<"\nDigite o nome: ";
gets(alu1[i].nome);
cout<<"\nDigite o endereco: ";
gets(alu1[i].endereco);
cout<<"\nDigite a idade: ";
cin>>alu1[i].idade;
cout<<"\nDigite o celular: ";
cin>>alu1[i].cel;
}20
![Page 21: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/21.jpg)
www.professoresalgoritmos.com
Exemplo 3
for(i=0; i<10; i++)
{
cout<<"\n*********** Cadastro realizado ************";
cout<<"\nAluno "<<i+1;
cout<<"\nNome: "<<alu1[i].nome;
cout<<"\nIdade: "<<alu1[i].idade;
cout<<"\nCel: "<<alu1[i].cel;
cout<<"\nEndereco: "<<alu1[i].endereco;
}
cout<<"\nFim do programa!";
system("PAUSE");
return EXIT_SUCCESS;
}
21
![Page 22: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/22.jpg)
www.professoresalgoritmos.com
Passando Registros para Funções
• As estruturas podem ser passadas como parâmetros de funções da mesma maneira que uma variável simples
• O nome de uma estrutura não é um endereço, portanto, ela pode ser passada por valor
• O exemplo a seguir apresenta uma função que recebe duas estruturas como parâmetro e imprime os valores da soma de seus membros
22
![Page 23: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/23.jpg)
www.professoresalgoritmos.com
Exemplo 4
//A estrutura e a função estão antes da main()
struct Venda
{
int pecas;
float preco;
};
void listavenda(Venda c, Venda d)
{
cout<<"\n**** Venda Total ****";
cout<<"\nTotal de pecas: "<<(c.pecas + d.pecas);
cout<<"\nPreco total: "<<((c.pecas*c.preco) + (d.pecas*d.preco));
}
23
![Page 24: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/24.jpg)
www.professoresalgoritmos.com
Exemplo 4
int main()
{
Venda A, B;
cout<<"\nVenda A";
cout<<"\nInsira o numero de pecas: ";
cin>>A.pecas;
cout<<"\nInsira o preco: ";
cin>>A.preco;
cout<<"\nVenda B";
cout<<"\nInsira o numero de pecas: ";
cin>>B.pecas;
cout<<"\nInsira o preco: ";
cin>>B.preco;
listavenda(A,B);//chamada da função
cout<<"\nFim do programa";
system("PAUSE");
return EXIT_SUCCESS;
}
24
![Page 25: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/25.jpg)
www.professoresalgoritmos.com
Passando Registros para Funções por referência
• A sintaxe das passagem de estrutura para funções por referência é a mesma da passagem de variáveis simples por referência
• Como as estruturas, em geral, são dados que ocupam uma grande quantidade de memória, é conveniente que se use passagem de parâmetro por referência
Usando referência não há criação de uma cópia da variável na função
25
![Page 26: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/26.jpg)
www.professoresalgoritmos.com
Exemplo 5
//Alterando o exemplo anterior para que a função receba os parâmetros
//por referência
struct Venda
{
int pecas;
float preco;
};
void listavenda(Venda *c, Venda *d)
{
cout<<"\n**** Venda Total ****";
cout<<"\nTotal de pecas: "<<((*c).pecas+ (*d).pecas);
cout<<"\nPreco total: "<<(((*c).pecas* (*c).preco)+((*d).pecas*
(*d).preco));
}
26
![Page 27: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/27.jpg)
www.professoresalgoritmos.com
Exemplo 5
int main()
{
Venda A, B;
cout<<"\nVenda A";
cout<<"\nInsira o numero de pecas: ";
cin>>A.pecas;
cout<<"\nInsira o preco: ";
cin>>A.preco;
cout<<"\nVenda B";
cout<<"\nInsira o numero de pecas: ";
cin>>B.pecas;
cout<<"\nInsira o preco: ";
cin>>B.preco;
listavenda(&A,&B);//chamada da função
cout<<"\nFim do programa";
system("PAUSE");
return EXIT_SUCCESS;
}
27
![Page 28: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/28.jpg)
www.professoresalgoritmos.com
Exemplo 6
//Outra forma de passar a estrutura como parâmetros por referência
struct Venda
{
int pecas;
float preco;
};
void listavenda(Venda& c, Venda& d)
{
cout<<"\n**** Venda Total ****";
cout<<"\nTotal de pecas: "<<(c.pecas + d.pecas);
cout<<"\nPreco total: "<<((c.pecas * c.preco)+(d.pecas * d.preco));
}
28
![Page 29: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/29.jpg)
www.professoresalgoritmos.com
Exemplo 6
int main()
{
Venda A, B;
cout<<"\nVenda A";
cout<<"\nInsira o numero de pecas: ";
cin>>A.pecas;
cout<<"\nInsira o preco: ";
cin>>A.preco;
cout<<"\nVenda B";
cout<<"\nInsira o numero de pecas: ";
cin>>B.pecas;
cout<<"\nInsira o preco: ";
cin>>B.preco;
listavenda(A,B);//chamada da função
cout<<"\nFim do programa";
system("PAUSE");
return EXIT_SUCCESS;
}
29
![Page 30: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/30.jpg)
www.professoresalgoritmos.com
Funções que retornam um Registro
• A linguagem C++ permite que as funções retornem uma estrutura completa para outra função, como o exemplo:
Venda novavenda()
{
Venda x;
cout<<"\nVenda A";
cout<<"\nInsira o numero de pecas: ";
cin>>x.pecas;
cout<<"\nInsira o preco: ";
cin>>x.preco;
return x;
}
30
![Page 31: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/31.jpg)
www.professoresalgoritmos.com
Exercícios
1- Explique qual a diferença entre vetor e registro. Dê exemplos.
31
![Page 32: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/32.jpg)
www.professoresalgoritmos.com
Exercícios2- Foi realizada uma pesquisa de algumas características físicas
de 50 habitantes de uma certa região. De cada habitante foram coletados os seguintes dados: sexo, altura, idade e cor dos olhos (A - Azuis, V - Verdes ou C – Castanhos).
Faça um programa que leia esses dados e armazene-os em um registro do tipo vetor. Em seguida, determine:
a) a média de idade das pessoas com olhos castanhos e altura superior a 1.60 m
b) a maior idade entre os habitantes
c) a quantidade de indivíduos do sexo feminino cuja idade esteja entre 20 e 45 anos (inclusive) ou que tenham olhos verdes e altura inferior a 1.70 m
d) o percentual de homens32
![Page 33: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/33.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ASCENCIO, Ana Fernanda Gomes e CAMPOS, Edilene A. Veneruchi. Fundamentos da Programação de Computadores – Algoritmos, Pascal e C/C++. São Paulo: Pearson Prentice Hall, 2007. 2ª Edição. Capítulo 10.
• MIZRAHI, Victorine Viviane. Treinamento em Linguagem C++. 2ª Ed. Módulo 1. São Paulo: Pearson Prentice Hall, 2006. Capítulo 7.
33
![Page 34: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/34.jpg)
www.professoresalgoritmos.com
Alocação Dinâmica de Memória
Ivre Marjorie R. Machado
![Page 35: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/35.jpg)
www.professoresalgoritmos.com
Definição
• Na declaração de um vetor é preciso dimensioná-lo, ou seja, saber, de antemão, quanto de espaço é necessário
– Prever o número máximo de elementos no vetor durante a codificação
Ex.: Suponha que desejamos desenvolver um programa para calcular a média e a variância
das notas de uma prova. Mas não sabemos que o número máximo de alunos?
35
![Page 36: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/36.jpg)
www.professoresalgoritmos.com
Definição
• Solução:
– Dimensionar um vetor com um número absurdamente alto, para não termos limitação no momento da utilização do programa
– Essa solução pode levar a um desperdício de memória ou uma limitação do número de alunos e consequentemente do programa
36
![Page 37: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/37.jpg)
www.professoresalgoritmos.com
Definição
• A linguagem C oferece meios de requisitar espaços de memória em tempo de execução
• Assim, voltando ao exemplo, é possível consultar o número de alunos e então fazer a alocação do vetor dinamicamente, sem de desperdício de memória
Alocação dinâmica de memória
37
![Page 38: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/38.jpg)
www.professoresalgoritmos.com
Reserva de espaço de memória
Existem 3 maneiras de reservar espaço de memória:
1. Usar variáveis globais (e estáticas): o espaço reservado existe enquanto o programa estiver sendo executado
2. Usar variáveis locais: o espaço existe apenas enquanto a função que declarou a variável está sendo executada
3. Requisitar ao sistema, em tempo de execução, um espaço de um determinado tamanho: Esse espaço permanece reservado até que seja explicitamente liberado pelo programa.
38
![Page 39: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/39.jpg)
www.professoresalgoritmos.com
Função Malloc()
• Biblioteca: stdlib.h
• A função básica para alocar memória é a malloc()
• A função recebe como parâmetro o número de bytes que se deseja alocar e retorna o endereço inicial da área da memória alocada
– Dessa forma, é necessário o uso de um ponteiro para receber o endereço inicial do espaço alocado
39
![Page 40: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/40.jpg)
www.professoresalgoritmos.com
Função Malloc()
• Exemplo: Alocação dinâmica de um vetor de inteiros com 10 elementos:
int *v;
v = malloc(10 * 4);
Considerando que 1 inteiro ocupa 4 bytes
40
![Page 41: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/41.jpg)
www.professoresalgoritmos.com
Função Malloc()
• Para ficarmos livres de compiladores e máquinas, usamos o operador sizeof()
int *v;
v = malloc(10 * sizeof(int));
diz quantos bytes o tipo especificado tem
41
![Page 42: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/42.jpg)
www.professoresalgoritmos.com
Função Malloc()
• Como malloc retorna um ponteiro genérico, para um tipo qualquer, representado por void *
– que pode ser convertido para o tipo apropriado na atribuição:
int *v;
v = (int *)malloc(10 * sizeof(int));
Conversão para o tipo int
42
![Page 43: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/43.jpg)
www.professoresalgoritmos.com
Função Malloc()
• Se não houver espaço livre suficiente para realizar a alocação, a função retorna um endereço nulo (NULL):
int *v;
v = (int *)malloc(10 * sizeof(int));
if( v == NULL)
{
cout<<“Memória insuficiente”;
exit(1); //aborta o programa e retorna 1
}
...43
![Page 44: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/44.jpg)
www.professoresalgoritmos.com
Função Free()
• Biblioteca: stdlib.h
• A função básica para liberar um espaço de memória alocado dinamicamente é a free()
• A função recebe como parâmetro o ponteiro da memória a ser liberada
int *v;
v = (int *)malloc(10* sizeof(int));
...
Free(v); //libera espaço de memória
44
![Page 45: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/45.jpg)
www.professoresalgoritmos.com
Função Free()
• Só podemos passar para a função free() um ponteiro (endereço) de memória que tenha sido alocado dinamicamente
• Cuidado, pois não é possível acessar o espaço da memória depois de liberado
45
![Page 46: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/46.jpg)
www.professoresalgoritmos.com
Exercícios
1- Explique a vantagem de usar alocação dinâmica de memória. Use exemplos.
2- O que é alocação dinâmica de memória?
3- Como podemos liberar um espaço de memória alocado dinamicamente?
46
![Page 47: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/47.jpg)
www.professoresalgoritmos.com
Exercícios
4- Escreva o que será impresso pelo programa abaixo.
int main ( )
{
int *A;
A = (int*)malloc(sizeof(int));
*A = 10;
cout<<"\nvalor de A: "<<*A;
int *B;
B = A;
*B = 15;
cout<<"\nvalor de B: "<<*B;
}
47
![Page 48: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/48.jpg)
www.professoresalgoritmos.com
Exercícios
5- Escreva o que será impresso pelo programa abaixo.
int main ( )
{
int *A;
A = (int*)malloc(sizeof(int));
*A = 10;
cout<<"\nPrimeiro valor de A: "<<*A;
int *B;
B= (int*)malloc(sizeof(int));
*B = *A;
*B = 15;
cout<<"\nvalor de B: "<<*B;
cout<<"\nSegundo valor de A: "<<*A;
} 48
![Page 49: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/49.jpg)
www.professoresalgoritmos.com
Exercícios
6- Dado o código abaixo, indique o resultado do mesmo para cada um dos valores de “*A”.
void main(){
int *A;A = (int*)malloc(sizeof(int));*A = ??;int *B;B = (int*)malloc(sizeof(int));*B = *A;*B = 15;cout<<"\n "<<*B;cout<<"\n "<<*A;
}
*A = 10 Resposta:
(*A = _____ e *B = _____ )
*A = 35 Resposta:
(*A = _____ e *B = _____ )
• Substitua o valor do símbolo ‘??’ nocódigo por cada um dos valoresapresentados para *A abaixo. Em seguida,mostre os resultados que serão impressosna tela (*B e *A) para cada um dosvalores.
49
![Page 50: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/50.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados.Rio de Janeiro: Elsevier, 2004 – 5ª impressão.
50
![Page 51: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/51.jpg)
www.professoresalgoritmos.com
Ponteiros
Ivre Marjorie R. Machado
![Page 52: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/52.jpg)
www.professoresalgoritmos.com
Definição
• Ponteiro é um endereço de memória
• Seu valor indica em que parte da memória do computador uma variável está alocada, não o que está armazenado nela
Ponteiro variável é um lugar na memória que armazena o endereço de outra
variável
52
![Page 53: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/53.jpg)
www.professoresalgoritmos.com
Razões para usar ponteiros
• Receber parâmetros em funções que necessitem modificar o parâmetro original
• Criar estruturas complexas, como listas encadeadas e árvores binárias, em que um item deve conter referência a outro
• Alocar e desalocar memória do sistema
• Passar para uma função o endereço de outra
53
![Page 54: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/54.jpg)
www.professoresalgoritmos.com
Ponteiros
• Dizemos que uma variável aponta para outra variável quando a primeira contém o endereço da segunda
• Endereço de memória: um endereço é a referência que o computador usa para localizar variáveis
– Toda variável ocupa uma certa localização na memória e seu endereço é o do primeiro byte ocupado por ela
54
![Page 55: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/55.jpg)
www.professoresalgoritmos.com
Declaração de Ponteiros
int *ptr;
Nome_ponteiroTipo de dado
int a, *ptr;
a = 5;
ptr = &a;
*ptr = 6;
112
ptr ->108
a 5104
Exemplo:
55
![Page 56: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/56.jpg)
www.professoresalgoritmos.com
Declaração de Ponteiros
int *ptr;
Nome_ponteiroTipo de dado
int a, *ptr;
a = 5;
ptr = &a;
*ptr = 6;
112
ptr -> 104108
a 5104
Exemplo:
56
![Page 57: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/57.jpg)
www.professoresalgoritmos.com
Declaração de Ponteiros
int *ptr;
Nome_ponteiroTipo de dado
int a, *ptr;
a = 5;
ptr = &a;
*ptr = 6;
112
ptr -> 104108
a 6104
Exemplo:
57
![Page 58: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/58.jpg)
www.professoresalgoritmos.com
Ponteiros
• Operador de endereços: &
• Acessa no endereço da posição da memória reservada para a variável
int *ptr;
ptr = &a;
58
![Page 59: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/59.jpg)
www.professoresalgoritmos.com
Ponteiros
• Operador indireto: * (resulta no conteúdo / valor da variável)
• Acessa o conteúdo de endereço de memória armazenado
int *ptr;
*ptr = 6;
59
![Page 60: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/60.jpg)
www.professoresalgoritmos.com
Exemplo1 - Ponteiros
int main()
{
int x = 4, y =7;
int *px, *py;
cout<<"\n &X= "<<&x<<" X= "<<x;
cout<<"\n &Y= "<<&y<<" Y= "<<y;
cout<<"\n";
px=&x;
py=&y;
cout<<"\n PX= "<<px<<" *PX= "<<*px;
cout<<"\n PY= "<<py<<" *PY= "<<*py;
cout<<"\n";
system("PAUSE");
return EXIT_SUCCESS;
}60
![Page 61: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/61.jpg)
www.professoresalgoritmos.com
Exemplo2 - Ponteiros
int main()
{
int x, y;
int *px=&x;
*px = 14;
y = *px;
cout<<"\n y= "<<y;
cout<<"\n x= "<<x;
cout<<"\n";
system("PAUSE");
return EXIT_SUCCESS;
}
61
![Page 62: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/62.jpg)
www.professoresalgoritmos.com
Operações com Ponteiros
1. Atribuição:
2. Incrementando:
3. Diferença:
4. Comparações: usando os operadores ( >, <, <=, >=, ==, != )
px = &x;
px++; px = py + 3;
px - py;
62
![Page 63: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/63.jpg)
www.professoresalgoritmos.com
Ponteiros para Estruturas
• Do mesmo modo que podemos declarar variáveis do tipo estrutura:
Aluno alu;
struct Aluno
{
int mat;
char nome[255], curso[50];
};
63
![Page 64: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/64.jpg)
www.professoresalgoritmos.com
Ponteiros para Estruturas
• Podemos declarar variáveis do tipo ponteiro para estrutura:
Aluno *palu;
palu-> mat nome curso
64
![Page 65: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/65.jpg)
www.professoresalgoritmos.com
Acesso aos campos da Estrutura
• Para acessar os campos da estrutura com um ponteiro:
(*nome_ponteiro). Nome_campo
ponto
Os parênteses são indispensáveis, pois o operador “*” tem precedência menor do que o operador de
acesso “.”
65
![Page 66: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/66.jpg)
www.professoresalgoritmos.com
Acesso aos campos da Estrutura
• Outra forma de acessar os membros é:
• E para acessar o endereço de um campo:
nome_ponteiro -> Nome_campo
&nome_ponteiro -> Nome_campo
66
![Page 67: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/67.jpg)
www.professoresalgoritmos.com
Alocação dinâmica de Estruturas
Aluno *palu;
palu = (Aluno*)malloc(sizeof(Aluno));
struct Aluno
{
int mat;
char nome[255], curso[50];
};
Estrutura Aluno criada anteriormente
67
![Page 68: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/68.jpg)
www.professoresalgoritmos.com
Alocação dinâmica de Estruturas
• Após uma alocação dinâmica, podemos acessar normalmente os campos da estrutura com a variável ponteiro que armazena seu endereço
68
![Page 69: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/69.jpg)
www.professoresalgoritmos.com
Exercícios
1- O que é um ponteiro?
2- Explique o que significa a instrução:
int *p;
3- Explique para que serve o operador & e o operador * nas instruções abaixo:
a) p = &i;
b) *p = i;
69
![Page 70: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/70.jpg)
www.professoresalgoritmos.com
Exercícios
4- Escreva o que será impresso pelo programa abaixo.
int main()
{
int x=3, y=7;
int *px=&x;
*px = 12;
y = *px;
cout<<"\n y= "<<y;
cout<<"\n x= "<<x;
cout<<"\n";
system("PAUSE");
}70
![Page 71: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/71.jpg)
www.professoresalgoritmos.com
Exercícios
5- Escreva o que será impresso pelo programa abaixo.
int main()
{
int x=3, y=7;
int *px=&x, *py=&y;
y= 4;
cout<<"\n *px= "<<*px;
cout<<"\n *py= "<<*py;
cout<<"\n";
system("PAUSE");
} 71
![Page 72: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/72.jpg)
www.professoresalgoritmos.com
Exercícios
6- Escreva o que será impresso pelo programa abaixo.
void Troca (int *A, int B)
{
int temp;
temp = *A;
*A = B;
B = temp;
}
int main()
{
int x,y;
x = 5;
y = 3;
Troca(&x,y);
cout << x << endl << y;
getch();
}
72
![Page 73: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/73.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• MIZRAHI, Victorine Viviane. Treinamento em Linguagem C++. 2ª Ed. Módulo 2. São Paulo: Pearson Prentice Hall, 2006. Capítulo 11.
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados.Rio de Janeiro: Elsevier, 2004 – 5ª impressão. Capítulos 4 e 8.
73
![Page 74: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/74.jpg)
www.professoresalgoritmos.com
Análise de Complexidade
Ivre Marjorie R. Machado
![Page 75: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/75.jpg)
www.professoresalgoritmos.com
Introdução
• O projeto de um algoritmo deve considerar o desempenho que este terá após sua implementação.
• Várias soluções podem surgir e aspectos de tempo de execução e espaço ocupado são pontos muito relevantes na escolha da solução mais adequada.
75
![Page 76: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/76.jpg)
www.professoresalgoritmos.com
Introdução
• Analisar um algoritmo significa predizer os recursos computacionais que o algoritmo requer quando da sua execução: memória, largura de banda de comunicação, hardware de computação.
• Recurso mais considerado: tempo de processamento.
• Em geral, existem vários algoritmos para solucionar um mesmo problema e a análise é capaz de identificar qual é o mais eficiente.
76
![Page 77: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/77.jpg)
www.professoresalgoritmos.com
Introdução
• A área de análise de algoritmos pode considerar dois tipos de problemas distintos:
– Análise de um algoritmo em particular: custo para a resolução de um problema específico.
– Análise de uma classe de algoritmos: um conjunto de algoritmos para resolver um problema específico é estudado, para determinar qual o melhor.
77
![Page 78: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/78.jpg)
www.professoresalgoritmos.com
Introdução
• Interesse: expressão ou fórmula matemática (modelo matemático) que represente o tempo de execução de um algoritmo.
• Aspectos mais importantes da análise de tempo:– quantidade de elementos a processar (tamanho da
entrada);
– forma como os elementos estão dispostos na entrada.
• Tempo de execução de um algoritmo: uma função f(n), onde n é o tamanho da entrada.
• A função f deve expressar o número de operações básicas, ou passos, executados pelo algoritmo.
78
![Page 79: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/79.jpg)
www.professoresalgoritmos.com
Introdução
• Interesse: expressão ou fórmula matemática (modelo matemático) que represente o tempo de execução de um algoritmo.
• Aspectos mais importantes da análise de tempo:– quantidade de elementos a processar (tamanho da
entrada);
– forma como os elementos estão dispostos na entrada.
• Tempo de execução de um algoritmo: uma função f(n), onde n é o tamanho da entrada.
• A função f deve expressar o número de operações básicas, ou passos, executados pelo algoritmo.
79
![Page 80: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/80.jpg)
www.professoresalgoritmos.com
Introdução
A operação básica de maior freqüência de execução no algoritmo é denominada
operação dominante ou operação fundamental.
80
![Page 81: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/81.jpg)
www.professoresalgoritmos.com
Complexidade de Tempo
• A complexidade de tempo de um algoritmo tem por objetivo avaliar sua eficiência.
• Para medir o custo de execução de um algoritmo comum definir uma função de custo ou função de complexidade f, em que f(n) é a medida do tempo necessário para executar um algoritmo para um problema de tamanho n
81
![Page 82: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/82.jpg)
www.professoresalgoritmos.com
Complexidade de Tempo
• A complexidade de tempo de um algoritmo tem por objetivo avaliar sua eficiência.
• Para medir o custo de execução de um algoritmo comum definir uma função de custo ou função de complexidade f, em que f(n) é a medida do tempo necessário para executar um algoritmo para um problema de tamanho n.
82
![Page 83: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/83.jpg)
www.professoresalgoritmos.com
Complexidade de Tempo
• Função de complexidade de tempo do algoritmo: se f(n) for uma medida da quantidade do tempo necessário para executar um algoritmo de tamanho n
• Função de complexidade de espaço do algoritmo: se f(n) for uma medida da quantidade de memória necessária para executar um algoritmo de tamanho n
83
![Page 84: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/84.jpg)
www.professoresalgoritmos.com
Complexidade de Tempo
• Melhor caso: corresponde ao menor tempo de execução sobre todas as possíveis entradas de tamanho n
• Caso médio (ou caso esperado): corresponde à média dos tempos de execução de todas as entradas de tamanho n
• Pior caso: corresponde ao maior tempo de execução sobre todas as possíveis entradas de tamanho n
84
![Page 85: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/85.jpg)
www.professoresalgoritmos.com
Exemplo1
• Seja f uma função de complexidade tal que f(n) é o número de registros consultados no arquivo, isto é, o número de vezes que a chave de consulta é comparada com a chave de cada registro.Os casos a considerar são:
Melhor caso: f(n) = 1
Pior caso: f(n) = n
Caso médio: f(n) = (n+1)/2
85
![Page 86: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/86.jpg)
www.professoresalgoritmos.com
Exemplo2
Considere o problema de encontrar o maior e o menor elementos de um vetor de inteiros v[0..n-1], n>=1
void calculaMaxMin1(int vet[], int n)
{
int max = vet[0], min = vet[0];
for(int i=1; i<n; i++)
{
if(vet[i]>max)
max = vet[i];
if(vet[i]<min)
min = vet[i];
}
}
86
![Page 87: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/87.jpg)
www.professoresalgoritmos.com
Exemplo2
Para o exemplo anterior, temos que f é uma função de complexidade tal que f(n) é o número de comparações entre os elementos de vet, se vet contiver n elementos, temos que:
f(n) = 2(n-1), para n > 0
Esse programa pode ser facilmente melhorado. Basta observar que a comparação vet[i] < minsomente é necessária quando o resultado da
comparação vet[i] > max é falso.
87
![Page 88: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/88.jpg)
www.professoresalgoritmos.com
Exemplo2 – Nova versão
void calculaMaxMin2(int vet[], int n)
{
int max = vet[0], min = vet[0];
for(int i=1; i<n; i++)
{
if(vet[i]>max)
max = vet[i];
else if(vet[i]<min)
min = vet[i];
}
}
88
![Page 89: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/89.jpg)
www.professoresalgoritmos.com
Exemplo2 – Nova versão
void calculaMaxMin2(int vet[], int n)
{
int max = vet[0], min = vet[0];
for(int i=1; i<n; i++)
{
if(vet[i]>max)
max = vet[i];
else if(vet[i]<min)
min = vet[i];
}
}
Melhor caso: f(n) = n-1
Pior caso: f(n) = 2(n-1)
Caso médio: f(n) = 3n/2-3/2
89
![Page 90: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/90.jpg)
www.professoresalgoritmos.com
Exemplo2 – Nova versão
void calculaMaxMin(int vet[], int
n)
{
int max = vet[0], min = vet[0];
for(int i=1; i<n; i++)
{
if(vet[i]>max)
max = vet[i];
else if(vet[i]<min)
min = vet[i];
}
}
90
![Page 91: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/91.jpg)
www.professoresalgoritmos.com
Comportamento Assintótico de Funções
• O nº de comparações para encontrar o maior elemento de um conjunto de n inteiros, ou para ordenar os elementos de um conjunto com n elementos, aumenta com n
• Parâmetro n fornece uma medida da dificuldade para se resolver o problema
– O custo para obter uma solução para um dado problema aumenta com o tamanho de n do problema
91
![Page 92: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/92.jpg)
www.professoresalgoritmos.com
Comportamento Assintótico de Funções
• Para valores suficientemente pequenos de n, qualquer algoritmo custa pouco para ser executado, mesmo os algoritmos ineficientes– Para problemas de tamanho pequeno a escolha
do algoritmo não é um problema crítico
– A análise de algoritmos é realizada apenas para valores grandes de n
– A análise de um algoritmo geralmente conta com apenas algumas operações elementares, e em muitos casos com uma operação elementar
92
![Page 93: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/93.jpg)
www.professoresalgoritmos.com
Notação Assintótica
• Passos:
1. Identificar o termo dominante da expressão que descreve sua complexidade, ou seja, descreve a ordem de crescimento assintótico desta expressão.
2. Obter uma função que é um limitante superior assintótico para a nossa expressão, isto é, para instâncias arbitrárias de tamanho n podemos resolver o problema em tempo menor ou igual a O(n).
93
![Page 94: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/94.jpg)
www.professoresalgoritmos.com
Notação O(f(n))
f(n) = O(1)
Complexidade constante, ou seja, independe do tamanho da entrada n. As instruções são executadas um número fixo de vezes
f(n) = O(log n)
Complexidade sub-linear ou logarítmica, ocorre geralmente em problemas que dividem-se em problemas menores em sua resolução
f(n) = O(n)
Complexidade linear, ou seja, quando um pequeno trabalho é realizado sobre os elementos de entrada n. Esta situação é boa para algoritmos que tenham entrada e saída n.
94
![Page 95: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/95.jpg)
www.professoresalgoritmos.com
Notação O(f(n))
f(n) = O(n log n)
Esta complexidade geralmente acontece com algoritmos que separam o problema em menores e unem as resoluções depois de encontrá-las.
f(n) = O(n^2)
Complexidade quadrática, ou seja, quando itens são processados aos pares, geralmente quando temos um anel dentro do outro.
f(n) = O(2^n)
Complexidade exponencial. São algoritmos péssimos em ponto de vista prático. Geralmente são algoritmos utilizados para resolução de problemas na força bruta.
95
![Page 96: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/96.jpg)
www.professoresalgoritmos.com
Notação O(f(n))
f(n) = O(n!)
Complexidade fatorial. São algoritmos piores que os exponenciais. Péssimos na prática e resultado de aplicação d e força bruta, não são recomendados para resolução de problemas.
96
![Page 97: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/97.jpg)
www.professoresalgoritmos.com
Notação Assintótica
• A tabela de classes de problemas está ordenada de maneira crescente
• Para compararmos dois algoritmos, é necessário saber primeiro a qual classe pertencem ao algoritmos.
– Se forem de classe diferentes s comparação fica fácil, seguindo a ordem da tabela.
– Se forem da mesma classe, deverão ser comparados por suas funções reais de complexidade de tempo, lembrando que o caso comparado deve ser o mesmo (ex. pior caso com pior caso)
97
![Page 98: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/98.jpg)
www.professoresalgoritmos.com
Funçãode custo
Tamanho n
10 20 30 40 50 60
n 0,00001 s 0,00002 s
0,00003 s
0,00004 s
0,00005 s
0,00006
n² 0,0001 s 0,0004 s 0,0009 s 0,0016 s 0,0035 s 0,0036 s
n³ 0,001 s 0,008 s 0,027 s 0,64 s 0,125 s 0,316 s
n⁵ 0,1 s 3,2 s 24,3 s 1,7 min 5,2 min 13 min
2^n 0,001 s 1 s 17,9 min 12,7 dias 35,7 anos
366 séc.
3^n 0,059 s 58 min 6,5 anos 3855 séc.
10⁸ séc. 10¹³ séc.
Comparação de funções de complexidades
98
![Page 99: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/99.jpg)
www.professoresalgoritmos.com
Trabalho de Pesquisa
• Fazer uma pesquisa sobre:
– Problemas P
– Problemas NP
– Problemas NP-completos
• Conceitue cada um. Dê exemplos.
• Não esqueça de colocar as referências usadas.
• Entregar impresso dia (06/09/2012).
• Pode ser feito em dupla.
99
![Page 100: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/100.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: Thomson Learning, 2007.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Notas de aula Profª Raquel Marcia Müller (http://www.comp.uems.br/Members/rmmuller/pg_aedii)
100
![Page 101: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/101.jpg)
www.professoresalgoritmos.com
Técnicas de Análise de Algoritmos
Ivre Marjorie R. Machado
![Page 102: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/102.jpg)
www.professoresalgoritmos.com
Introdução
• A análise de algoritmos ou programas utiliza técnicas de matemática discreta, envolvendo contagem ou enumeração dos elementos de um conjunto que possuam propriedade comum:
– Manipulação de somas, produtos, permutações, fatoriais, coeficientes binomiais, solução de equações de recorrência, entre outras.
102
![Page 103: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/103.jpg)
www.professoresalgoritmos.com
Introdução
• Infelizmente não existe um conjunto completo de regras para analisar programas.
• Dessa forma, algumas dessas técnicas serão ilustradas informalmente com exemplos.
103
![Page 104: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/104.jpg)
www.professoresalgoritmos.com
Introdução
• Complexidade de tempo da maioria dos problemas é polinomial ou exponencial.
– Polinomial: função de complexidade é O (p(n)) , onde p(n) é um polinômio.
• Exemplos: pesquisa binária (O (log n)), pesquisa seqüencial ( O (n)), ordenação por inserção (O (n²)), e multiplicação de matrizes (O (n³)).
– Exponencial: função de complexidade é O (c^n), c> 1.
• Exemplo:Problema do Caixeiro Viajante(PCV) (O (n!)).
104
![Page 105: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/105.jpg)
www.professoresalgoritmos.com
Complexidade
• O(1) ou constante
• O(log n) ou logaritímica
• O(n) ou linear
• O(n log n) ou n log de n
• O(n²) ou quadrática
• O(n³) ou cúbica
• O(n!) ou fatorial
Maior Complexidade
105
![Page 109: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/109.jpg)
www.professoresalgoritmos.com
Notação O - Exemplos
• f(n) = 403 = O(1)
• f(n) = 5 + 2 logn + 3 log²n = O(log²n)
• f(n) = 5 + 2 logn + 3n = O(n)
• f(n) = 5*2^n + 5n^10 = O(2^n)
• f(n) = n² - 1 = O(n²)
• f(n) = n³ - 1 = O(n³)
• f(n) = 3n + 5 logn + 2 = O(n)
109
![Page 110: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/110.jpg)
www.professoresalgoritmos.com
Complexidade de algumas estruturas de controle
• Regras rígidas sobre o cálculo da complexidade de qualquer algoritmo não existem, cada caso deve ser estudado em suas condições.
• No entanto, as estruturas de controle clássicas da programação estruturada permitem uma estimativa típica de cada uma.
• A partir disso, algoritmos construídos com combinações delas podem ter sua complexidade mais facilmente estabelecida.
110
![Page 111: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/111.jpg)
www.professoresalgoritmos.com
• Comando simples : tem um tempo de execução constante, O(c) = O(1).
• Seqüência: tem um tempo igual à soma dos tempos de cada comando da seqüência; se cada comando é O(1), assim, também será a seqüência; senão, pela regra da soma, a seqüência terá a complexidade do comando de maior complexidade.
• Alternativa : qualquer um dos ramos pode ter complexidade arbitrária; a complexidade resultante é a maior delas; isto vale para alternativa dupla (if-else) ou múltipla (switch).
111
![Page 112: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/112.jpg)
www.professoresalgoritmos.com
• Repetições
• Repetição contada: é aquela em que cada iteração (ou “volta”) atualiza o controle mediante uma adição(geralmente, quando se usa uma estrutura do tipo for, que especifica incremento/decremento automático de uma variável inteira).
• Se o número de iterações é independente do tamanho do problema, a complexidade de toda a repetição é a complexidade do corpo da mesma, pela regra da constante (ou pela regra da soma de tempos).
for (i=0; i<k ; i++)
trecho com O(g(n))
se k não é f(n)então o
trecho é O(g(n))
112
![Page 113: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/113.jpg)
www.professoresalgoritmos.com
• Se o número de iterações é função de n, pela regra do produto teremos a complexidade da repetição como a complexidade do corpo multiplicada pela função que descreve o número de iterações. Isto é:
for (i=0; i<10 ; i++)
{
x = x+v;
printf (“%d”, x);
}
isto é O(1), logo toda a repetição é
O(1)
113
![Page 114: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/114.jpg)
www.professoresalgoritmos.com
for (i=0; i<n; i++)
trecho com O(g(n))como o número de iterações é f(n)=n então o trecho é
O(n*g(n))
for (i=0; i<k*n ; i++)
trecho com O(log n)o trecho é O(f(n)*g(n)), no caso O(k*n*log n),
ou seja: O(n log n)
Exemplo:
114
![Page 115: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/115.jpg)
www.professoresalgoritmos.com
• Uma aplicação comum da regra do produto é a determinação da complexidade de repetições aninhadas.
• Exemplo:
• Exemplo:
for (i=0; i<n ; i++)
for (j=0; j<n ; j++)
trecho com O(1)
o trecho é O(f(n)*g(n)), no caso
g(n)=n*1 (laço interno); logo,
O(n*n), ou seja: O(n²)
for (i=1; i<=n ; i++)
for (j=1; j<=i ; j++)
trecho com O(1)
o laço interno é executado 1+2+3+...n-1
+n=n*(n+1)/2 vezes, logo, O(n*(n+1)/2), ou seja: O(0.5(n²+n)) ou
seja O(n²)
115
![Page 116: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/116.jpg)
www.professoresalgoritmos.com
for (i=1; i<=n ; i++)
for (j=n; i<=j ; j--)
trecho com O(1)
o laço interno é executado n+n-1+n-2+...+2+1=n*(n+1)/2 vezes, ou seja: O(n²)
como no caso anterior
• Os dois últimos exemplos podem ser generalizados para quaisquer aninhamentos de repetições contadas em k níveis, desde que todos os índices dependam do tamanho do problema. Nesse caso, a complexidade da estrutura aninhada será da ordem de n ^ k.
116
![Page 117: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/117.jpg)
www.professoresalgoritmos.com
for (IndExt=1; IndExt<=n ; IndExt++)
for (IndMed=IndExt; IndMed<=n ; IndMed++)
for (IndInt=1; IndInt<=IndMed; IndInt++)
trecho com O(1)
o laço mediano é executado n+n-1+n-2+... +2+1=(n²+n)/2 vezes; o laço mais
interno será executado no máximo n vezes; logo, tem-se O((n²+n)*n), ou seja: O(n³)
117
![Page 118: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/118.jpg)
www.professoresalgoritmos.com
• Repetições
• Repetição multiplicativa: é aquela em que cada iteração atualiza o controle mediante uma multiplicação ou divisão.
limite=1;
while (limite<=n)
{
trecho com O(1)
limite = limite*2;
}
o número de iterações depende de n; limite vai
dobrando a cada iteração; depois de k iterações, limite = 2^k e k = log2limite; como o valor
máximo de limite é n, então o trecho é O(log2n)
= O(log n)
OBS: Na verdade O(log n) independe da base do logaritmo, pois logan = logab*logbn = c*logbn.
118
![Page 119: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/119.jpg)
www.professoresalgoritmos.com
int limite;
for (limite=n; limite!=0; limite /=2)
trecho com O(1)
o número de iterações depende de n; limite vai-se subdividindo a cada iteração; depois de k=log2n iterações, encerra; então o trecho é O(log n)
• Os dois exemplos anteriores também podem ser generalizados, adotando-se um fator genérico de multiplicação fator. Nesse caso, o número de iterações será dado por k = logfatorlimite = O(logf(n)), se o limite é função de n.
119
![Page 120: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/120.jpg)
www.professoresalgoritmos.com
int limite=n;
while (limite!=0)
{
for (i=1; i<=n; i++)
trecho com O(1)
limite = limite/2;
}
o número de iterações depende de n; limite vai-se
subdividindo a cada iteração; o laço interno é O(n), o
externo O (log n);logo, o trecho é O (n log n)
Exemplo:
120
![Page 121: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/121.jpg)
www.professoresalgoritmos.com
• Chamada de função: Pode ser resolvida considerando-se que a função também tem um algoritmo com sua própria complexidade. Esta é usada como base para cálculo da complexidade do algoritmo invocador. Por exemplo: se a invocação estiver num ramo de uma alternativa, sua complexidade será usada na determinação da máxima complexidade entre os dois ramos; se estiver no interior de um laço, será considerada no cálculo da complexidade da seqüência repetida, etc.
• A questão se complica ao se tratar de uma chamada recursiva.
121
![Page 122: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/122.jpg)
www.professoresalgoritmos.com
• Embora não haja um método único para esta avaliação, em geral a complexidade de um algoritmo recursivo será função de componentes como: a complexidade da base e do núcleo da solução e a profundidade da recursão. Por este termo entende-se o número de vezes que o procedimento é invocado recursivamente. Este numero, usualmente, depende do tamanho do problema e da taxa de redução do tamanho do problema a cada invocação. E é na sua determinação que reside a dificuldade da análise de algoritmos recursivos.
122
![Page 123: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/123.jpg)
www.professoresalgoritmos.com
• Exemplo:
int fatorial (int n)
{
if (n==0)
return 1; // Base
else
return n*fatorial(n- 1); //Núcleo
}
• A redução do problema se faz de uma em uma unidade, a cada reinvocação do procedimento, a partir de n, até alcançar n = 0. Logo, a profundidade da recursão é igual a n. O núcleo da solução (que é repetido a cada reinvocação) tem complexidade O(1), pois se resume a uma multiplicação. A base tem complexidade O(1), pois envolve apenas uma atribuição simples. Nesse caso, conclui-se que o algoritmo tem um tempo T(n) = n*1+1 = O(n).
123
![Page 124: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/124.jpg)
www.professoresalgoritmos.com
Exemplo
• Considere um algoritmo recursivo, nesse caso é necessário obter uma equação de recorrência (maneira de definir uma função por uma expressão envolvendo a mesma função)
• O exemplo a seguir inspeciona n elementos de um conjunto e permite descartar 2/3 dos elementos e então fazer uma chamada recursiva sobre os n/3 elementos restantes
124
![Page 125: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/125.jpg)
www.professoresalgoritmos.com
Exemplo 1- Algoritmo recursivo
void pesquisa(int n)
{
if(n<=1)
{
cout<<"Inspeciona o elemento e termina";
}
else
{
cout<<"\nPara cada um dos n elementos -
inspecione o elemento";
pesquisa(n/3);
}
}
125
![Page 126: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/126.jpg)
www.professoresalgoritmos.com
Exemplo 1- Algoritmo recursivo
void pesquisa(int n)
{
if(n<=1)
{
cout<<"Inspeciona o elemento e termina";
}
else
{
cout<<"\nPara cada um dos n elementos -
inspecione o elemento";
pesquisa(n/3);
}
}
Para esse exemplo, a
complexidade será O(n),
Complexidade linear.
126
![Page 127: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/127.jpg)
www.professoresalgoritmos.com
Exemplo
• Considere o algoritmo para ordenar nelementos de um vetor v cujo princípio é o seguinte:
1. Selecione o menor elemento do vetor
2. Troque esse elemento com o primeiro elemento do v[0]
3. A seguir, repita essas duas operações com os n-1 elementos restantes, depois com os n-2 elemento, até que reste apenas um elemento
127
![Page 128: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/128.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
128
![Page 129: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/129.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
O número n de elementos
representa o tamanho da
entrada de dados.
129
![Page 130: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/130.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
O programa contém dois anéis,
um dentro do outro.
130
![Page 131: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/131.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
Devemos começar a análise pelo anel
interno. Nesse anel temos um comando de decisão que, por
sua vez, possui apenas um
comando de atribuição.
131
![Page 132: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/132.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
O comando de atribuição leva um tempo constante
para ser executado, assim como a avaliação da condição do comando de
decisão.
132
![Page 133: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/133.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
Não sabemos se o corpo do comando
de decisão será executado ou não: nessas situações
devemos considerar o pior caso, isto é,
assumir que a linha 10 sempre será
executada.
133
![Page 134: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/134.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
O tempo para incrementar o índice do anel e avaliar sua
condição de terminação também é
O(1), e o tempo combinado para
executar uma vez o anel composto pelas
linhas de 6 a 11 é O(max(1,1,1)) = O(1), conforme a regra da
soma para notação O.
134
![Page 135: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/135.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
Como o número de iterações do anel é n-i, então o tempo gasto no anel é O(( n-i ) * 1)
= O( n-i ), conforme regra do produto.
135
![Page 136: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/136.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
O corpo do anel mais externo contém, além
do anel interno, os comandos de
atribuição nas linhas 5, 13, 14 e 15. Logo, o tempo de execução
das linhas de 5 a 15 é O(max(1,(n-i),1,1,1)) =
O(n-i).
136
![Page 137: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/137.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
A linha 3 é executada n-1 vezes, e o tempo total
para executar o programa está limitado
ao produto de uma constante pelo
somatório de (n – i) a saber:
137
![Page 138: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/138.jpg)
www.professoresalgoritmos.com
Exemplo 2- Programa para ordenar
)(222
)1()( 2
21
1
nOnnnn
inn
i
138
![Page 139: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/139.jpg)
www.professoresalgoritmos.com
Complexidade de Tempo
• Melhor caso: corresponde ao menor tempo de execução sobre todas as possíveis entradas de tamanho n
• Caso médio (ou caso esperado): corresponde à média dos tempos de execução de todas as entradas de tamanho n
• Pior caso: corresponde ao maior tempo de execução sobre todas as possíveis entradas de tamanho n
139
![Page 140: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/140.jpg)
www.professoresalgoritmos.com
Exemplo3
Considere o problema de encontrar o maior e o menor elementos de um vetor de inteiros v[0..n-1], n>=1
void calculaMaxMin1(int vet[], int n)
{
int max = vet[0], min = vet[0];
for(int i=1; i<n; i++)
{
if(vet[i]>max)
max = vet[i];
if(vet[i]<min)
min = vet[i];
}
}
140
![Page 141: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/141.jpg)
www.professoresalgoritmos.com
Exemplo3
Para o exemplo anterior, temos que f é uma função de complexidade tal que f(n) é o número de comparações entre os elementos de vet, se vet contiver n elementos, temos que:
f(n) = 2(n-1), para n > 0
Esse programa pode ser facilmente melhorado. Basta observar que a comparação vet[i] < minsomente é necessária quando o resultado da
comparação vet[i] > max é falso.
141
![Page 142: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/142.jpg)
www.professoresalgoritmos.com
Exemplo4 – Nova versão
void calculaMaxMin2(int vet[], int n)
{
int max = vet[0], min = vet[0];
for(int i=1; i<n; i++)
{
if(vet[i]>max)
max = vet[i];
else if(vet[i]<min)
min = vet[i];
}
}
142
![Page 143: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/143.jpg)
www.professoresalgoritmos.com
Exemplo4 – Nova versão
void calculaMaxMin2(int vet[], int n)
{
int max = vet[0], min = vet[0];
for(int i=1; i<n; i++)
{
if(vet[i]>max)
max = vet[i];
else if(vet[i]<min)
min = vet[i];
}
}
Melhor caso: f(n) = n-1
Pior caso: f(n) = 2(n-1)
Caso médio: f(n) = (3n-3)/2
Melhor caso: o vetor está ordenado
crescente e no pior caso está
ordenado decrescente
143
![Page 144: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/144.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: Thomson Learning, 2007.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Notas de aula Profª Raquel Marcia Müller (http://www.comp.uems.br/Members/rmmuller/pg_aedii)
144
![Page 145: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/145.jpg)
www.professoresalgoritmos.com
Tipos Abstratos de dados (TAD)
Ivre Marjorie R. Machado
![Page 146: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/146.jpg)
www.professoresalgoritmos.com
Introdução
• TAD: Tipos Abstratos de Dados
• Ideia central: encapsular (esconder) de quem usa um determinado tipo a forma concreta com que ele foi implementado
146
![Page 147: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/147.jpg)
www.professoresalgoritmos.com
TAD - Exemplo
• Se criarmos um tipo para representar um ponto no espaço, um cliente desse tipo usa-o de forma abstrata, com base apenas nas funcionalidades oferecidas pelo tipo
• A forma com que ele foi efetivamente implementado (armazenando cada coordenada num campo ou agrupando todas num vetor) passa a ser um detalhe de implementação, que não deve afetar o uso do tipo nos mais diversos contextos
147
![Page 148: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/148.jpg)
www.professoresalgoritmos.com
Modularização
• Vantagens:– desacoplamos a implementação do uso
– facilitamos a manutenção
– aumentamos o potencial de reutilização do tipo criado
– a implementação do tipo pode ser alterada sem afetar seu uso em outros contextos.
• Modularização: divisão de um programa em vários arquivos-fontes.
148
![Page 149: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/149.jpg)
www.professoresalgoritmos.com
Modularização
• Um módulo agrupa vários tipos e funções com funcionalidades relacionadas, caracterizando assim uma finalidade bem definida.
• Se um módulo definir um novo tipo de dado e o conjunto de operações para manipular dados desse tipo, dizemos que o módulo representa um tipo abstrato de dados (TAD)
149
![Page 150: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/150.jpg)
www.professoresalgoritmos.com
Interface - TAD
• A interface de um TAD consiste:
– Na definição do nome do tipo e do conjunto de funções exportadas para sua criação e manipulação
150
![Page 151: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/151.jpg)
www.professoresalgoritmos.com
Exemplo 1 – TAD Ponto
• Operações:– Cria: operação que cria um ponto com coordenadas x
e y
– Atribui: operação que atribui novos valores às coordenadas de um ponto
– Distancia: operação que calcula a distância entre dois pontos
– Libera: operação que libera a memória alocada por um ponto
• Interface: arquivo ponto.h
151
![Page 152: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/152.jpg)
www.professoresalgoritmos.com
Exemplo 2 – TAD Circulo
• Operações:– Cria: operação que cria um circulo com centro
(x,y) e raio r
– Area: operação que calcula a area do circulo
– Interior: operação que verifica se um dado ponto está dentro do circulo
– Libera: operação que libera a memória alocada por um circulo
• Interface: arquivo circulo.h
152
![Page 153: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/153.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: Thomson Learning, 2007. Capítulo 1.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados.Rio de Janeiro: Elsevier, 2004 – 5ª impressão. Capítulo 9.
153
![Page 154: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/154.jpg)
www.professoresalgoritmos.com
TAD – Listas Encadeadas
Ivre Marjorie R. Machado
![Page 155: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/155.jpg)
www.professoresalgoritmos.com
Introdução
• O vetor não é estrutura muito flexível, pois precisamos dimensioná-lo com um número máximo de elementos– Complexidade das funções para inserir e remover
usando vetor em um tempo linear é O(n)
• Solução: utilizar estruturas de dados que cresçam conforme precisamos armazenar novos elementos– E diminuam a medida que retiramos elementos
armazenados
155
![Page 156: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/156.jpg)
www.professoresalgoritmos.com
Introdução
• Essas estruturas são chamadas dinâmicas e armazenam cada um dos seus elementos por alocação dinâmica – Complexidade para inserir e remover: O (1)
• A primeira estrutura a ser estudada é a lista encadeada
• As listas encadeadas são amplamente utilizadas para implementar diversas outras estruturas de dados com semânticas próprias
156
![Page 157: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/157.jpg)
www.professoresalgoritmos.com
Introdução
• Tipos de listas:
– Listas Simplesmente Encadeadas
– Listas Circulares
– Listas Duplamente Encadeadas
157
![Page 159: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/159.jpg)
www.professoresalgoritmos.com
Lista Linear Encadeada
• Para cada novo elemento inserido na estrutura => alocamos um espaço de memória para armazená-lo
• Assim, o espaço total de memória gasto pela estrutura é proporcional ao número de elementos armazenados
• Não podemos garantir que os elementos armazenados na lista ocuparão um espaço contíguo de memória– Portanto, não temos acesso direto aos elementos da
lista
159
![Page 160: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/160.jpg)
www.professoresalgoritmos.com
Lista Linear Encadeada
• Exemplos de listas:
Lista Telefônica
Lista de clientes de uma agência bancária
Lista de setores de disco a serem acessados por um sistema operacional
Lista de pacotes a serem transmitidos em um nó de uma rede de computação de pacotes
160
![Page 161: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/161.jpg)
www.professoresalgoritmos.com
Lista Linear Encadeada
• Para percorrer todos os elementos da lista, devemos explicitamente guardar o seu encadeamento
Isso é feito armazenando-se junto com a informação de cada
elemento, um ponteiro para o próximo elemento da lista
161
![Page 162: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/162.jpg)
www.professoresalgoritmos.com
Lista Linear Encadeada
Info1 Info2 Info3
prim
NULL
162
![Page 163: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/163.jpg)
www.professoresalgoritmos.com
Lista Linear Encadeada
• Estrutura:
– Consiste em uma sequência encadeada de elementos, em geral chamados nós (nodos) da lista
– Um nó da lista é representado por um estrutura que contém dois campos: a informação armazenada e o ponteiro para o próximo elemento da lista
163
![Page 164: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/164.jpg)
www.professoresalgoritmos.com
Lista Linear Encadeada
• A lista é representada por um ponteiro para o primeiro elemento (ou nó)
• Do primeiro elemento, podemos alcançar o segundo, seguindo o encadeamento, e assim por diante
• O último elemento da lista possui um ponteiro para inválido, com valor NULL e sinaliza que não existe um próximo elemento
164
![Page 165: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/165.jpg)
www.professoresalgoritmos.com
Exemplo – Lista Encadeada
struct nodo
{
int valor;
nodo* prox;
};
valor prox
165
![Page 166: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/166.jpg)
www.professoresalgoritmos.com
Principais Operações Lista Encadeada
1. Função Inserir na Lista
2. Função Imprime os elementos da Lista
3. Função Verifica se a Lista está vazia
4. Função Remover um elemento da Lista
166
![Page 167: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/167.jpg)
www.professoresalgoritmos.com
1- Função Inserir na Lista
• Uma vez criada a lista vazia, podemos inserir nela novos elementos
• Para cada elemento inserido, devemos alocar dinamicamente a memória necessária para armazenar o elemento e encadeá-lo na lista existente
• Parâmetros para a função: o ponteiro para a lista e o valor/ informação do novo elemento
167
![Page 168: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/168.jpg)
www.professoresalgoritmos.com
1- Função Inserir na Lista
• A função inserir na lista pode:
– Inserir um novo elemento no fim da lista, fazendo que o último elemento aponte para NULL,
– Inserir no início da lista fazendo com que o prim(primeiro ponteiro) aponte para esse novo elemento.
168
![Page 169: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/169.jpg)
www.professoresalgoritmos.com
2- Função Imprime os elementos
• Essa função percorre todos os elementos da Lista e imprime os valores dos elementos armazenados na lista
• Usamos uma variável auxiliar que é um ponteiro (aux) que aponta para cada uma das estruturas até chegar no NULL
169
![Page 170: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/170.jpg)
www.professoresalgoritmos.com
3- Função Verifica se a Lista está vazia
• Essa função pode ser útil e utilizada em outras funções
• A função recebe a lista e retorna 1 se estiver vazia ou 0 se não estiver vazia
• Uma lista está vazia se seu valor é NULL
170
![Page 171: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/171.jpg)
www.professoresalgoritmos.com
3- Função Verifica se a Lista está vazia
int ListaVazia(nodo * primeiro)
{
if(primeiro == NULL)
return 1;
else
return 0;
}
171
![Page 172: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/172.jpg)
www.professoresalgoritmos.com
4- Função Remover um elemento
• Parâmetros: lista e o valor do elemento que desejamos remover da lista
• Função mais complexa
• Se o elemento a ser retirado for o primeiro da lista: devemos fazer
172
![Page 174: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/174.jpg)
www.professoresalgoritmos.com
Listas Circulares
• Algumas aplicações necessitam representar conjuntos cíclicos
• Estrutura: o último elemento tem como próximo o primeiro elemento da lista, o que forma um ciclo
• Nesse caso nem faz sentido em falar em primeiro ou último elemento já que é um ciclo– dessa forma, a lista pode ser representada por
um ponteiro para um elemento inicial qualquer
174
![Page 175: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/175.jpg)
www.professoresalgoritmos.com
Lista Circular
Info1 Info2 Info3
prim
175
![Page 176: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/176.jpg)
www.professoresalgoritmos.com
Função Imprime elementos Lista Circular
• Para percorrer os elementos de uma lista circular é necessário visitar todos os elementos a partir de um ponteiro do elemento inicial até alcançar novamente esse mesmo elemento
176
![Page 177: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/177.jpg)
www.professoresalgoritmos.com
Função Imprime elementos Lista Circular
void imprimeListaCircular(nodo* primeiro)
{
nodo* aux = primeiro;
if(aux != NULL)
{
do{
cout<<prim->valor;
aux = aux -> prox;
}while (aux != primeiro);
}
}
177
![Page 179: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/179.jpg)
www.professoresalgoritmos.com
Listas Duplamente Encadeada
• A lista encadeada vista anteriormente, também chamada Lista Simplesmente Encadeada (LSE), caracteriza-se por formar um encadeamento simples entre os elementos:
–Cada elemento armazena um ponteiro para o próximo elemento da lista
179
![Page 180: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/180.jpg)
www.professoresalgoritmos.com
Listas Duplamente Encadeada
• Problemas da LSE:
– não conseguimos percorrer eficientemente os elementos em ordem inversa (do final para o início da lista)
– O encademento simples também dificulta a retirada de um elemento da lista, pois não temos um ponteiro para o elemento anterior ao ser retirado
180
![Page 181: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/181.jpg)
www.professoresalgoritmos.com
Listas Duplamente Encadeada
• Solução: Listas duplamente encadeadas
• Nessas listas, cada elemento tem um ponteiro para o próximo e um ponteiro para o elemento anterior
• Assim, dado um elemento, podemos acessar os dois elementos adjacentes: o próximo e o anterior
181
![Page 182: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/182.jpg)
www.professoresalgoritmos.com
Listas Duplamente Encadeada
Info1 Info2 Info3
prim
Ou NULL
182
![Page 183: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/183.jpg)
www.professoresalgoritmos.com
Exemplo – Lista Duplamente Encadeada
struct nodo2
{
int valor;
nodo* ant;
nodo* prox;
};
ant valor prox
183
![Page 184: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/184.jpg)
www.professoresalgoritmos.com
Principais Operações Lista Duplamente Encadeada
1. Função Inserir na Lista
2. Função Remover um elemento da Lista
3. Função Buscar elemento na Lista
184
![Page 185: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/185.jpg)
www.professoresalgoritmos.com
Função Remover Elemento daLista Duplamente Encadeada
• A função fica mais complicada, pois é necessário acertar o encadeamento duplo
– Em contrapartida, podemos retirar um elemento da lista se conhecermos apenas o ponteiro para esse elemento
185
![Page 186: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/186.jpg)
www.professoresalgoritmos.com
Função Remover Elemento daLista Duplamente Encadeada
• Se p representa o ponteiro do elemento que desejamos retirar, para acertar o encadeamento devemos conceitualmente fazer:
p-> ant-> prox = p-> prox;p-> prox -> ant = p-> ant;
Isto é, o anterior passa a apontar para o próximo, e o próximo passa a apontar para o anterior 186
![Page 187: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/187.jpg)
www.professoresalgoritmos.com
Função Remover Elemento daLista Duplamente Encadeada
• Se p aponta para um elemento no meio da lista: as duas atribuições são suficientes para acertar o encadeamento
• Se p aponta para um elemento no extremo da lista:
– Se p for o último elemento, o elemento anterior deverá apontar para NULL quando p for removido
– Se p for o primeiro elemento, o ponteiro para o primeiro deverá apontar para o próximo elemento
187
![Page 188: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/188.jpg)
www.professoresalgoritmos.com
Exercícios
1- Implemente as principais operações para o TAD lista simplesmente encadeada
2- Implemente as principais operações para o TAD lista duplamente encadeada
188
![Page 189: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/189.jpg)
www.professoresalgoritmos.com
Exercícios
3- Analise a estrutura “no” e o procedimento “abcd”:
189
![Page 190: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/190.jpg)
www.professoresalgoritmos.com
Exercícios
Sabendo-se que as variáveis “prim” e “ult” são, respectivamente, ponteiros para o início e o final de uma lista simplesmente encadeada com 5 elementos, o procedimento “abcd” é utilizado para:
[A] incluir um elemento no final da lista.
[B] excluir o último elemento da lista.
[C] incluir um elemento no início da lista.
[D] excluir o primeiro elemento da lista.
190
![Page 191: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/191.jpg)
www.professoresalgoritmos.com
Exercícios
4- Marque (certo) ou (errado):
a) (CESPE - 2008 - TRT - 5ª Região (BA) - Técnico Judiciário -Tecnologia da Informação )
A principal característica de uma lista encadeada é o fato de o último elemento da lista apontar para o elemento imediatamente anterior.
b) (CESPE - 2009 - ANAC - Técnico Administrativo -Informática)Em uma lista circular duplamente encadeada, cada nó aponta para dois outros nós da lista, um anterior e um posterior.
191
![Page 192: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/192.jpg)
www.professoresalgoritmos.com
Exercícios
(Poscomp-2011)
( ) Uma lista permite que as inserções possam ser feitas em qualquer lugar (posição), mas as remoções, não.
( ) Em uma lista circular com encadeamento simples, o primeiro elemento aponta para o segundo e para o último.
( ) Para remover um elemento de uma lista duplamente encadeada, deve-se alterar o encadeamento dos elementos anterior e próximo ao elemento removido.
192
![Page 193: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/193.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: Thomson Learning, 2007.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados.Rio de Janeiro: Elsevier, 2004 – 5ª impressão. Capítulo 10.
193
![Page 194: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/194.jpg)
www.professoresalgoritmos.com
TAD – Pilha
Ivre Marjorie R. Machado
![Page 196: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/196.jpg)
www.professoresalgoritmos.com
Introdução
• Uma das Estrutura de dados mais simples é a PILHA
– Por isso, é a mais utilizada em programação
Principal ideia: todo acesso a seus elementos é feito a partir do topo
196
![Page 197: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/197.jpg)
www.professoresalgoritmos.com
Introdução
• Quando um novo elemento é introduzido na pilha, ele passa a ser o elemento do topo
• O único elemento que pode ser removido da pilha é o do topo
• Os elementos da pilha só podem ser retirados na ordem inversa à ordem em que foram introduzidos: o primeiro que sai é o último que entrou (LIFO – Last in, first out)
197
![Page 198: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/198.jpg)
www.professoresalgoritmos.com
Introdução
• Operações Básicas:
1. Operação empilhar (push):
– inseri um novo elemento no topo da pilha
2. Operação desempilhar (pop):
– remove um elemento do topo da pilha
198
![Page 199: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/199.jpg)
www.professoresalgoritmos.com
Funcionamento da Pilha
a
push (a)
topo
199
![Page 200: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/200.jpg)
www.professoresalgoritmos.com
Funcionamento da Pilha
a
push (a)
topo
b
a
push (b)
topo
200
![Page 201: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/201.jpg)
www.professoresalgoritmos.com
Funcionamento da Pilha
a
push (a)
topo
b
a
push (b)
topo
c
b
a
push (c)
topo
201
![Page 202: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/202.jpg)
www.professoresalgoritmos.com
Funcionamento da Pilha
c
b
a
topo
pop ()desempilha o c
b
a
topo
202
![Page 203: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/203.jpg)
www.professoresalgoritmos.com
Funcionamento da Pilha
c
b
a
push (a)
topo
pop ()desempilha o c
b
a
topo
a topo
pop ()desempilha o b
203
![Page 204: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/204.jpg)
www.professoresalgoritmos.com
Exemplo - Pilha
• O exemplo mais próximo é a própria pilha de execução da linguagem C
– As variáveis locais das funções são dispostas em uma pilha, e uma função só tem acesso às variáveis da função que está no topo
• Não é possível acessar as variáveis da função locais às outras funções
204
![Page 205: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/205.jpg)
www.professoresalgoritmos.com
Implementação de pilha com lista
struct Lista
{
float valor;
Lista* prox;
};
struct Pilha
{
Lista* topo;
};
205
![Page 206: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/206.jpg)
www.professoresalgoritmos.com
Pilha* cria_pilha(void)
{
Pilha* p = (Pilha*)malloc(sizeof(Pilha));
p->topo = NULL;
return p;
}
void push_pilha(Pilha* p, float num)
{
Lista* n = (Lista*)malloc(sizeof(Lista));
n->valor = num;
n->prox = p->topo;
p->topo = n;
}
int pilha_vazia(Pilha* p)
{
return (p->topo == NULL);
} 206
![Page 207: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/207.jpg)
www.professoresalgoritmos.com
float pop_pilha(Pilha* p)
{
Lista* t;
float v;
if(pilha_vazia(p))
{
cout<<"\n Pilha vazia";
exit(1);
}
else
{
t = p->topo;
v = t->valor;
p->topo = t->prox;
free(t);
return v;
}
} 207
![Page 208: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/208.jpg)
www.professoresalgoritmos.com
void libera_pilha(Pilha* p)
{
Lista* q = p->topo;
while(q != NULL)
{
Lista* t = q->prox;
free(q);
q = t;
}
free(p);
}
void imprime_pilha(Pilha* p)
{
Lista* q;
for(q=p->topo; q!=NULL; q=q->prox)
{
cout<<"\n "<<q->valor;
}
}208
![Page 209: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/209.jpg)
www.professoresalgoritmos.com
int main()
{
Pilha* pi = cria_pilha();
push_pilha(pi,2);
push_pilha(pi,4);
push_pilha(pi,1);
imprime_pilha(pi);
getch();
system("cls");
pop_pilha(pi);
imprime_pilha(pi);
getch();
}
209
![Page 210: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/210.jpg)
www.professoresalgoritmos.com
Exercícios
1- Faça uma função que retorne a quantidade de elementos (tamanho) de uma pilha.
2- Faça uma função para concatenar duas pilhas, essa função deve receber as pilhas como parâmetro (observe a imagem).
2.1
4.5
1.0
P1 – topo -> 7.2
3.1
9.8
P2 – topo ->
7.2
3.1
9.8
2.1
4.5
1.0
P1 – topo ->
concatena
210
![Page 211: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/211.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: Thomson Learning, 2007.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados.Rio de Janeiro: Elsevier, 2004 – 5ª impressão. Capítulo 11.
211
![Page 212: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/212.jpg)
www.professoresalgoritmos.com
TAD – Fila
Ivre Marjorie R. Machado
![Page 214: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/214.jpg)
www.professoresalgoritmos.com
Introdução
• Outra Estrutura de dados bastante usada na computação é a FILA
• O que a diferencia da pilha é a ordem de saída dos elementos: enquanto na pilha “o último que entra é o primeiro que sai”, na fila “o primeiro que entra é o primeiro que sai”
214
![Page 215: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/215.jpg)
www.professoresalgoritmos.com
Introdução
Ideia principal: só podemos inserir um novo elemento no final da fila e só
podemos retirar o elemento do início.
215
![Page 216: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/216.jpg)
www.professoresalgoritmos.com
Introdução
• Analogia natural com a fila do dia-a-dia: quem entra primeiro na fila é o primeiro a se atendido (ex. fila de Banco, fila do CAA, fila do Mc Donald, etc)
• Os elementos da fila só podem ser retirados na ordem em que foram introduzidos: o primeiro que entra é o primeiro que sai (FIFO – First in, First out)
216
![Page 217: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/217.jpg)
www.professoresalgoritmos.com
Introdução
• Operações Básicas:
1. Inserir elementos na fila:
– inserir elementos em uma extremidade da fila
2. Retirar elementos da fila:
– retirar elementos de outra extremidade da fila
217
![Page 218: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/218.jpg)
www.professoresalgoritmos.com
Exemplo - Fila
• Um exemplo de utilização em computação é a implementação de uma fila de impressão:
– Impressora é compartilhada por várias máquinas: adotar uma estratégia para determinar o documento será impresso primeiro
• Estratégia mais simples: tratar todas as requisições com a mesma prioridade e imprimir os documentos na ordem em que forem submetidos (o primeiro submetido é o primeiro a ser impresso)
218
![Page 219: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/219.jpg)
www.professoresalgoritmos.com
Estrutura de fila com lista encadeada
ini fim
Info1 Info2 Info3
219
![Page 220: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/220.jpg)
www.professoresalgoritmos.com
Implementação de fila com lista
struct Lista
{
float info;
Lista* prox;
};
struct Fila
{
Lista* ini;
Lista* fim;
};220
![Page 221: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/221.jpg)
www.professoresalgoritmos.com
Fila* fila_cria()
{
Fila* f = (Fila*)malloc(sizeof(Fila));
f->ini = NULL;
f->fim = NULL;
return f;
}
int fila_vazia(Fila* f)
{
return (f->ini == NULL);
}
221
![Page 222: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/222.jpg)
www.professoresalgoritmos.com
void fila_insere(Fila* f, float v)
{
Lista* n = (Lista*)malloc(sizeof(Lista));
n->info = v; //armazena a informação
n->prox = NULL; //novo no será o ultimo
if(f->fim != NULL) //fila não esta vazia?
{
f->fim->prox = n;
}
else //senão a fila esta vazia
{
f->ini = n;
}
f->fim = n; //fila aponta p novo elemento
}
222
![Page 223: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/223.jpg)
www.professoresalgoritmos.com
float fila_retira(Fila* f)
{
Lista* t;
float v;
if(fila_vazia(f))
{
cout<<"Fila vazia";
exit(1); //aborta o programa
}
t = f->ini;
v = t->info;
f->ini = t->prox;
if(f->ini == NULL) //fila ficou vazia?
{
f->fim = NULL;
}
free(t);
return v;
} 223
![Page 224: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/224.jpg)
www.professoresalgoritmos.com
void fila_libera(Fila* f)
{
Lista* q = f->ini;
while(q != NULL)
{
Lista* t = q->prox;
free(q);
q = t;
}
free(f);
}
void fila_imprime(Fila* f)
{
Lista* q;
for(q = f->ini; q!=NULL; q = q->prox)
{
cout<<" "<<q->info<<" - ";
}
} 224
![Page 225: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/225.jpg)
www.professoresalgoritmos.com
int main()
{
Fila* f = fila_cria();
fila_insere(f, 20);
fila_insere(f, 80);
fila_insere(f, 10);
fila_imprime(f);
getch();
system("cls");
fila_retira(f);
fila_imprime(f);
getch();
}225
![Page 226: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/226.jpg)
www.professoresalgoritmos.com
Exercícios
1- Faça uma função que retorna a quantidade de elementos existem na fila.
2- Faça uma função que verifica se existe um determinado número(valor) inserido na fila.
226
![Page 227: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/227.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: Thomson Learning, 2007.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados.Rio de Janeiro: Elsevier, 2004 – 5ª impressão. Capítulo 12.
227
![Page 228: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/228.jpg)
www.professoresalgoritmos.com
Recursividade
Ivre Marjorie R. Machado
![Page 229: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/229.jpg)
www.professoresalgoritmos.com
Introdução
• Uma função é dita recursiva se definida em termos dela mesma
• Ou seja, uma função é recursiva quando dentro dela está presente uma instrução de chamada a ela própria
229
![Page 230: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/230.jpg)
www.professoresalgoritmos.com
Exemplo – Fatorial Recursivo
int fatorial(int n)
{
if(n==0)
{
return 1;
}
else
{
return(n * fatorial(n-1));
}
}
230
![Page 231: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/231.jpg)
www.professoresalgoritmos.com
Exemplo – Fatorial Recursivo
int main()
{
int num;
do{
cout<<"\nDigite um numero ou negativo para terminar: ";
cin>>num;
if(num>0)
{
cout<<"\nO fatorial de "<<num<<" e: "<<fatorial(num);
}
}while(num>0);
cout<<"\nFim do programa";
getch();
}
231
![Page 232: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/232.jpg)
www.professoresalgoritmos.com
Introdução
• O código gerado por uma função recursiva exige a utilização de mais memória, o que torna a execução mais lenta
• Não é difícil criar funções recursivas, o difícil é reconhecer as situações nas quais a recursão é apropriada
• Três pontos devem ser lembrados quando queremos escrever uma função recursiva
232
![Page 233: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/233.jpg)
www.professoresalgoritmos.com
Criando uma função recursiva
• 1º Passo: definir o problema em termos recursivos
• Isso significa definir o problema usando ele mesmo na definição
• Ex.: O fatorial de um número pode ser definido por meio da seguinte expressão:
n! = n * (n-1)!
233
![Page 234: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/234.jpg)
www.professoresalgoritmos.com
Criando uma função recursiva
• 2º Passo: encontrar a condição básica. Toda função recursiva deve ter uma condição de término chamada de condição básica
• A função fatorial(), quando chamada, verifica se num é zero
– Se a condição for satisfeita, interrompe a recursão
234
![Page 235: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/235.jpg)
www.professoresalgoritmos.com
Criando uma função recursiva
• 3º Passo: cada vez que a função é chamada recursivamente deve estar mais próxima de satisfazer a condição básica
• Isso garante que o programa não girará em uma sequência infinita de chamadas
• No exemplo, a cada chamada, o valor de num estará mais próximo de zero
235
![Page 236: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/236.jpg)
www.professoresalgoritmos.com
Como trabalha uma função recursiva?
• Para entender o funcionamento de uma função recursiva, vamos imaginar que a chamada recursiva é a chamada a outra função que tenha o mesmo código da função original
236
![Page 237: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/237.jpg)
www.professoresalgoritmos.com
Como trabalha uma função recursiva?
• Supondo que o número digitado tenha sido 3:int fatorial(int 3)
{
...
else
{
return(3 * fatorial(2));
}
}
237
![Page 238: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/238.jpg)
www.professoresalgoritmos.com
Como trabalha uma função recursiva?
• Supondo que o número digitado tenha sido 3:int fatorial(int 3)
{
...
else
{
return(3 * fatorial(2));
}
}
int fat1(int 2)
{
...
else
{
return(2 * fatorial(1));
}
}
238
![Page 239: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/239.jpg)
www.professoresalgoritmos.com
Como trabalha uma função recursiva?
• Supondo que o número digitado tenha sido 3:int fatorial(int 3)
{
...
else
{
return(3 * fatorial(2));
}
}
int fat1(int 2)
{
...
else
{
return(2 * fatorial(1));
}
}
int fat2(int 1)
{
...
else
{
return(1 * fatorial(0));
}
}
239
![Page 240: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/240.jpg)
www.professoresalgoritmos.com
Como trabalha uma função recursiva?
• Supondo que o número digitado tenha sido 3:int fatorial(int 3)
{
...
else
{
return(3 * fatorial(2));
}
}
int fat1(int 2)
{
...
else
{
return(2 * fatorial(1));
}
}
int fat2(int 1)
{
...
else
{
return(1 * fatorial(0));
}
}
int fat3(int 0)
{
if(n == 0)
{
return (1);
}
...
}
240
![Page 241: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/241.jpg)
www.professoresalgoritmos.com
Como trabalha uma função recursiva?
• Supondo que o número digitado tenha sido 3:int fatorial(int 3)
{
...
else
{
return(3 * fatorial(2));
}
}
int fat1(int 2)
{
...
else
{
return(2 * fatorial(1));
}
}
int fat2(int 1)
{
...
else
{
return(1 * fatorial(0));
}
}
int fat3(int 0)
{
if(n == 0)
{
return (1);
}
...
}
241
![Page 242: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/242.jpg)
www.professoresalgoritmos.com
Como trabalha uma função recursiva?
• O que ocorre na memória é quase a mesma coisa, exceto pelo fato de que não há repetição do código da função
• Observe que várias chamadas estão ativas ao mesmo tempo
• Enquanto a última chamada não terminar, a penúltima não termina e assim por diante– Isso faz as variáveis de cada chamada serem todas
mantidas na memória, o que requer mais memória
242
![Page 243: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/243.jpg)
www.professoresalgoritmos.com
Como trabalha uma função recursiva?
3!
3 * 2!
2 * 1!
1* 0!
1
243
![Page 244: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/244.jpg)
www.professoresalgoritmos.com
Característica da função recursiva
• As funções recursivas devem ter:
– Ponto de Parada: resolvido sem utilização de recursividade, sendo este ponto geralmente um limite superior ou inferior da regra geral.
– Regra Geral: o método geral da recursividade reduz a resolução do problema através da invocação recursiva de casos mais pequenos, sendo estes casos menores resolvidos através da resolução de casos ainda menores, e assim sucessivamente, até atingir o ponto de parada que finaliza o método.
244
![Page 245: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/245.jpg)
www.professoresalgoritmos.com
Característica da função recursiva
• Exemplo
Fatorial(n) = (n == 0) 1 // Ponto de parada
(n) n * (n-1)! // Regra geral
245
![Page 246: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/246.jpg)
www.professoresalgoritmos.com
Exemplo – Torre de Hanói
a b c
1
2
3
246
![Page 247: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/247.jpg)
www.professoresalgoritmos.com
Exemplo – Torre de Hanói
void mover(int n, char orig, char temp, char dest)
{
if(n==1)
{
cout<<"\n Mova o disco 1 da haste "<<orig<<" para
haste "<<dest;
}
else
{
mover(n-1, orig, dest, temp);
cout<<"\n Mova o disco "<<n<<" da haste
"<<orig<<" para haste "<<dest;
mover(n-1, temp, orig, dest);
}
}
247
![Page 248: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/248.jpg)
www.professoresalgoritmos.com
Exemplo – Torre de Hanói
int main()
{
mover(3, 'A', 'B', 'C');
getch();
}
248
![Page 250: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/250.jpg)
www.professoresalgoritmos.com
Exemplo – Impressão de um seqüência de números
void print_numero(int num)
{
if (num > 0)
{
print_numero(num-1);
cout << num << " ";
}
}
void print_numero_inv(int num)
{
if (num > 0)
{
cout << num << " ";
print_numero_inv(num-1);
}
}
int main(){
int numero;cout << "Digite o numero inicial: ";cin >> numero;print_numero(numero);cout << endl;print_numero_inv(numero);cout << endl;system("pause");
}
250
![Page 251: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/251.jpg)
www.professoresalgoritmos.com
Exemplo – Resto da divisão de um número por outro (método sem recursão)
#include <iostream.h>
int resto(int x, int y)
{
while(x >= y)
{
x = x –y;
}
return( x );
}
int main(){
int num, den;cout << "Digite o numerador: ";cin >> num;cout << "Digite o denominador: ";cin >> den;
cout << resto(num, den);cout << endl;system("pause");
}
251
![Page 252: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/252.jpg)
www.professoresalgoritmos.com
Exemplo – Resto da divisão de um número por outro (método recursivo)
#include <iostream.h>
int resto(int x, int y)
{
if (x < y)
return(x);
return( resto(x - y, y) );
}
int main(){
int num, den;cout << "Digite o numerador: ";cin >> num;cout << "Digite o denominador: ";cin >> den;
cout << resto(num, den);cout << endl;system("pause");
}
252
![Page 253: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/253.jpg)
www.professoresalgoritmos.com
Exercícios
1- Escreva uma função recursiva denominada potencia() que aceite dois parâmetros inteiros positivos i e j. A função retorna i elevado a potência j. Por exemplo: potencia(2,3) é igual a 8. Use a seguinte definição:
i elevado à potência j é igual a i elevado à potência j-1 vezes i
253
![Page 254: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/254.jpg)
www.professoresalgoritmos.com
Exercícios
2- Escreva uma função recursiva de nome soma() que receba um número inteiro positivo n como argumento e retorne a soma dos n primeiro números inteiros.
Por exemplo, se a função receber n= 5, deve retornar 15, pois 15 = 1+2+3+4+5
254
![Page 255: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/255.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: Thomson Learning, 2007.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados.Rio de Janeiro: Elsevier, 2004 – 5ª impressão. Capítulo 11.
255
![Page 256: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/256.jpg)
www.professoresalgoritmos.com
TAD – Árvores
Ivre Marjorie R. Machado
![Page 258: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/258.jpg)
www.professoresalgoritmos.com
Introdução
• Estruturas de dados chamadas lineares como vetores e listas não são adequadas para representar dados que devem ser dispostos e maneira hierárquica– Exemplo: arquivos (documentos) que criamos em
um computador são armazenados dentro de uma estrutura hierárquica de diretórios (pastas)
– Existe um diretório base dentro do qual podemos armazenar diversos subdiretórios e arquivos
258
![Page 259: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/259.jpg)
www.professoresalgoritmos.com
Introdução
• Árvores: são estruturas de dados adequadas para a representação de hierarquias
– A forma mais natural de definir uma estrutura de árvore é usando a recursividade
• Recursividade: habilidade de uma função chamar a si mesma
259
![Page 260: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/260.jpg)
www.professoresalgoritmos.com
Recursividade
• Uma função poderá também ser considerada recursiva se chamar outras funções que, em algum momento, chamem a primeira função, tornando esse conjunto de funções um processo recursivo.
• Cada vez que uma função é chamada de forma recursiva, é guardada uma cópia dos seus parâmetros de forma a não perder os valores dos parâmetros das chamadas anteriores.
260
![Page 261: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/261.jpg)
Árvores
Uma árvore é composta por:
• um nó Raiz, denominado r, que contém zero ou mais sub árvores• nós folhas ou extremos, que não possuem filhos
261
![Page 262: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/262.jpg)
www.professoresalgoritmos.com
Representação das Árvores
Nó Raiz
...
Folhas262
![Page 263: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/263.jpg)
www.professoresalgoritmos.com
Árvores
• É tradicional desenhar as estruturas de árvores com a raiz para cima e as folhas para baixo
• Não fica explicita a direção dos ponteiros– Fica subentendido que os ponteiros apontam
sempre do pai para os filhos
– Os tipos de árvores existentes são diferenciados pelo número de filhos por nó e as informações armazenadas em cada nó
263
![Page 264: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/264.jpg)
Árvores Binárias
• Exemplo de utilização: avaliação de expressões
• Como trabalhamos com operadores que esperam um ou dois operandos, os nós da árvore para representar uma expressão têm no máximo dois filhos
264
![Page 265: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/265.jpg)
Árvores Binárias
• nós folhas representam os operandos
• nós internos representam operadores
• No exemplo, a expressão representada é a:
(3+6) * (4-1) + 5
265
![Page 266: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/266.jpg)
Árvores Binárias
• Em uma árvore binária, cada nó tem zero, um ou dois filhos.
• Recursivamente, podemos definir uma árvore binária como sendo:
– uma árvore vazia, ou
– um nó raiz tendo duas subárvores, identificadas como a subárvore da direita (sad) e a subárvore da esquerda (sae)
raiz
sae sad
Vazia
* A definição recursiva será usada na construção de algoritmos e na verificação (informal) da correção e do seu desempenho
266
![Page 267: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/267.jpg)
www.professoresalgoritmos.com
Árvores Binárias
a
b c
d e f
Os nós a, b, c, d, e e f formam uma árvore binária:- Sub árvore à esquerda formada por b e
d- Sub árvore à direita formada por c, e e f- A raiz da árvore representada pelo nó a- As raízes das sub árvores representadas
pelos nós b e c- Folhas representadas pelos nós d, e e f- Além disso, cada nó folha representa
uma árvore, com duas sub árvores vazias.
267
![Page 268: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/268.jpg)
www.professoresalgoritmos.com
Árvores Bináriasa
b c
d e f
Podemos usar a seguinte notação textual: - A árvore vazia é representada por < >- e a árvore não vazia, por <raiz sae sad>
Para o nosso exemplo:<a<b< ><d< >< >>><c<e< >< >><f< >< >>>>
268
![Page 269: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/269.jpg)
www.professoresalgoritmos.com
Representação
• De modo semelhante ao que fizemos para as demais estruturas, podemos definir um tipo para representar uma árvore binária
struct arv
{
char info;
arv* esq;
arv* dir;
};
269
![Page 270: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/270.jpg)
www.professoresalgoritmos.com
Representação
• Da mesma forma que uma lista encadeada é representada por um ponteiro para o nó para o primeiro nó, a estrutura da árvore é representada por um ponteiro para o nó raiz
• Dado o ponteiro para o nó raiz tem-se acesso aos demais nós
270
![Page 271: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/271.jpg)
www.professoresalgoritmos.com
Operações básicas
• Cria árvore vazia
–Como uma árvore é representada pelo endereço do nó raiz, uma árvore vazia tem de ser representada pelo valor NULL
271
![Page 272: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/272.jpg)
www.professoresalgoritmos.com
Operações básicas
• Cria árvore não-vazia:
– Para construir árvores não-vazias, podemos ter uma operação que cria um nó raiz dadas a informação e as duas sub árvores, a da esquerda e a da direita
– Essa operação tem como retorno o endereço do nó raiz criado
272
![Page 273: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/273.jpg)
www.professoresalgoritmos.com
Operações básicas
• Imprime árvore:
– Consiste em exibir todo o conteúdo da árvore
– Essa função deve percorrer recursivamente a árvore, visitando todos os nós e imprimindo sua informação
– Como uma árvore binária ou é vazia ou é composta pela raiz e por duas sub árvores
273
![Page 274: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/274.jpg)
www.professoresalgoritmos.com
Operações básicas
• Imprime árvore:
– Portanto, para imprimir a informação de todos os nós da árvore devemos primeiro testar se ela é vazia
– se não for, imprimimos a informação associada à raiz e chamamos (recursivamente) a função para imprimir as sub árvores
274
![Page 275: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/275.jpg)
www.professoresalgoritmos.com
Operações básicas
• Libera árvore:
– Operação para liberar a memória
275
![Page 276: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/276.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: Thomson Learning, 2007.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados.Rio de Janeiro: Elsevier, 2004 – 5ª impressão. Capítulo 13.
276
![Page 277: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/277.jpg)
www.professoresalgoritmos.com
Balanceamento em Árvores
Ivre Marjorie R. Machado
![Page 278: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/278.jpg)
www.professoresalgoritmos.com
Introdução
• Dois argumentos favoráveis às árvores:
1. as árvores são bem apropriadas para representar a estrutura hierárquica de um certo domínio
2. o processo de busca é muito mais rápido usando árvores do que listas encadeadas
• No entanto, o 2º argumento, nem sempre se mantém
278
![Page 279: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/279.jpg)
www.professoresalgoritmos.com
Introdução
• Observe as árvores, todas elas armazenam os mesmos dados, mas obviamente, a árvore (a) é a melhor e a (c) é a pior.
(a)
(b)(c)
279
![Page 280: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/280.jpg)
www.professoresalgoritmos.com
Introdução
• O que acontece nas árvores (b) e (c) é que elas são assimétricas, portanto, não são distribuídas uniformemente
(a)
(b)(c)
280
![Page 281: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/281.jpg)
www.professoresalgoritmos.com
Introdução
• Uma árvore é dita balanceada quando as suassub-árvores à esquerda e à direita possuem a mesma altura.
• E todos os nós vazios estão no mesmo nível, ou seja, a árvore está completa.
• A árvore que não está balanceada, define-se como degenerada
281
![Page 283: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/283.jpg)
www.professoresalgoritmos.com
Introdução
• Como em uma árvore binária cada nó pode ter dois filhos, o número de nós em um certo nível é o dobro do número de ascendentes que residem no nível prévio
Altura Nível Nós em um nível
1 0 2 ^ 0 = 1
2 1 2 ^ 1 = 2
3 2 2 ^ 2 = 4
4 3 2 ^ 3 = 8
283
![Page 284: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/284.jpg)
www.professoresalgoritmos.com
Balanceamento
• Pode ser:
–Balanceamento Estático
–Balanceamento Dinâmico: AVL
284
![Page 285: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/285.jpg)
www.professoresalgoritmos.com
Balanceamento
• Balanceamento Estático
–O balanceamento estático de uma árvore binária consiste em construir uma nova versão, reorganizando-a.
285
![Page 286: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/286.jpg)
www.professoresalgoritmos.com
Balanceamento
• Balanceamento Dinâmico: AVL– Árvore AVL em homenagem aos matemáticos russos
(Adelson-Velskii e Landism -1962)
– Uma árvore AVL é uma árvore binária de pesquisa onde a diferença em altura entre as subárvoresesquerda e direita é no máximo 1 (positivo ou negativo).• A essa diferença chamamos de “fator de balanceamento”
de n(FatBal (n)).
• Essa informação deverá constar em cada nó de uma árvore balanceada
286
![Page 287: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/287.jpg)
www.professoresalgoritmos.com
Árvore AVL
• Árvore AVL (ou árvore balanceada pela altura)
• Assim, para cada nodo podemos definir um fator de balanceamento (FB) , que vem a ser um número inteiro igual a:
• O Fator de uma folha é sempre Zero (0)
FB(nodo p) = altura(subárvore direita p) -altura(subárvore esquerda p)
287
![Page 288: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/288.jpg)
www.professoresalgoritmos.com
Exemplos de Árvores AVL
• Os números nos nodos representam o FB para cada nodo.
• Para uma árvore ser AVL os fatores de balanço devem ser necessariamente -1, 0, ou 1.
288
![Page 290: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/290.jpg)
www.professoresalgoritmos.com
Árvore AVL
• Se o fator de balanceamento de qualquer nó em uma árvore AVL se tornar menor do que -1 ou maior do que 1
– a árvore tem que ser balanceada
– Um arvore AVL pode ser tornar desbalanceada em quatro situações, mas somente duas delas necessitam ser analisadas
• as outras duas são simetricas
290
![Page 291: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/291.jpg)
www.professoresalgoritmos.com
Balanceamento de Árvore AVL
• Inicialmente inserimos um novo nodo na árvore.
– A inserção deste novo nodo pode ou não violar a propriedade de balanceamento.
• Caso a inserção do novo nodo não viole a propriedade de balanceamento
– Podemos então continuar inserindo novos nodos.
291
![Page 292: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/292.jpg)
www.professoresalgoritmos.com
Balanceamento de Árvore AVL
• Caso contrário precisamos nos preocupar em restaurar o balanço da árvore.
– A restauração deste balanço é efetuada através do que denominamos ROTAÇÕES na árvore.
– “Rotações” => movimentações dos nós, pode ser feito a medida que um nó é inserido
292
![Page 293: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/293.jpg)
www.professoresalgoritmos.com
Balanceamento de Árvore AVL
• Primeiro caso: resultado de inserir um nó na subárvore da direita do filho à direita (ver próximo slide)
– Inserindo um nó em algum lugar da subarvore da direita de Q, perturba o balanceamento da árvore P
– Para resolver: girar o nó Q ao redor de seu ascendente P, de modo que o fator de balanceamento tanto de P como de Q se torna zero, o que é ainda melhor do que no princípio
293
![Page 294: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/294.jpg)
www.professoresalgoritmos.com
Balanceamento de Árvore AVL
(a)(b)
(c)
294
![Page 295: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/295.jpg)
www.professoresalgoritmos.com
Balanceamento de Árvore AVL
• Segundo caso: resultado de inserir um nó na subárvore da esquerda do filho à direita (ver próximos slides)
– Para trazer a árvore de volta ao balanceamento, uma dupla rotação é realizada
– O balanço da árvore P é restaurado girando-se R ao redor do nó Q e então girando-se R novament, dessa vez ao redor do nó P
295
![Page 296: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/296.jpg)
www.professoresalgoritmos.com
Balanceamento de Árvore AVL
(a)(b)
296
![Page 297: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/297.jpg)
www.professoresalgoritmos.com
Balanceamento de Árvore AVL
(c)(d)
297
![Page 298: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/298.jpg)
www.professoresalgoritmos.com
Balanceamento de Árvore AVL
(e)
298
![Page 299: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/299.jpg)
www.professoresalgoritmos.com
Dicas: Árvore AVL
1. Para identificarmos quando uma rotação é simples ou dupla observamos os sinais de FatBal:
– se o sinal for igual, a rotação é simples.
– se o sinal for diferente a rotação é dupla.
2. Se FB + rotação para esquerda
3. Se FB - rotação para direita
299
![Page 300: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/300.jpg)
www.professoresalgoritmos.com
Exercícios
1- Considere a inserção dos seguintes valores (nesta ordem) em uma árvore AVL: 5,3,8,2,4,7,10,1,6,9,11. Para essas inserções nenhuma rotação é necessária. Desenhe a árvore AVL resultante e determine o fator de balanceamento de cada nó.
300
![Page 301: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/301.jpg)
www.professoresalgoritmos.com
Exercícios
2- Construir uma árvore AVL com os seguintes dados:
• Inserir inicialmente 10, 20, 30
• Se necessário fazer balanceamento
• Inserir 25 e 27
• Se necessário fazer balanceamento
301
![Page 302: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/302.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: Thomson Learning, 2007.
• DROZDEK, Adam. Estruturas de dados e algoritmos em c++. São Paulo: CengageLearning, 2009. Tradução: Luiz Sérgio de Castro Paiva. Capítulo: 6.
302
![Page 303: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/303.jpg)
www.professoresalgoritmos.com
Pesquisa em Memória Primária Árvore Binária de Busca
Ivre Marjorie R. Machado
![Page 304: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/304.jpg)
www.professoresalgoritmos.com
Introdução
• Pesquisa = busca
304
![Page 305: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/305.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• O algoritmo de busca binária apresentado tem bom desempenho computacional
• e deve ser usado quando temos os dados ordenados armazenados em um vetor
305
![Page 306: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/306.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• Mas se precisarmos inserir e remover elementos da estrutura e ao mesmo tempo dar suporte a funções de busca eficientes, a estrutura de vetor
– (e, consequentemente, a busca binária) não se mostra adequada
• Para inserir um novo elemento em um vetor ordenado, temos de rearrumar os elementos no vetor para abrir espaço para inserção do novo elemento
306
![Page 307: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/307.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• Uma situação semelhante ocorre quando removemos um elemento do vetor
• Sendo assim, precisamos de uma estrutura dinâmica que dê suporte a operações de busca
• No caso, podemos usar a estrutura estudada: Árvore Binária
307
![Page 308: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/308.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• As árvores binárias aqui consideradas têm uma propriedade fundamental:
– o valor associado a raiz é sempre maior do que os valores associados a qualquer nós das subárvores
• Essa propriedade garante que quando percorremos a árvore em ordem simétrica (sae – raiz – sad), os valores são encontrados em ordem crescente
308
![Page 309: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/309.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
8
4 9
1 2
Ordem simétrica: 1 - 4 - 2 - 8 - 9
sae sad 309
![Page 310: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/310.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• Uma variação possível permite a repetição de valores na árvore: – o valor associado à raiz é sempre maior do que o valor
associado a qualquer nó da sae
– e é sempre menor ou igual ao valor associado a qualquer nó sad
• Nesse caso, como a repetição de valores é permitida, quando a árvore é percorrida em ordem simétrica, os valores são encontrados em ordem não decrescente
310
![Page 311: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/311.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• Ao usar a propriedade de ordem simétrica, a busca de um valor em uma árvore pode ser feita de forma eficiente
• Para procurar um valor numa árvore, comparamos o valor que buscamos ao valor associado à raiz– Em caso de igualdade, o valor foi encontrado
– Se o valor for menor, a busca continua em sae
– Se o valor for maior, a busca continua em sad
311
![Page 312: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/312.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• Exemplo:6
2 8
1 4
3312
![Page 313: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/313.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• Tipo da árvore binária:
struct Arv
{
int info;
Arv* esq;
Arv* dir;
};
313
![Page 314: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/314.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• A árvore é representada pelo ponteiro para o nó raiz
• A árvore vazia é inicializada pela atribuição de NULL à variável que representa a árvore
• Uma função simples para criar a árvore vazia é:
Arv* abb_cria()
{
return NULL;
}314
![Page 315: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/315.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• Caso já exista uma árvore binária de busca, podemos imprimir os valores da árvore em ordem crescente percorrendo os nós em ordem simétrica:
void abb_imprime(Arv* a)
{
if(a!= NULL)
{
abb_imprime(a->esq);
cout<<"\n"<<a->info;
abb_imprime(a->dir);
}
} 315
![Page 316: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/316.jpg)
www.professoresalgoritmos.com
Árvore binária de busca
• Até agora nada mudou para as árvores binárias que tínhamos visto
• Outras operações vão explorar a propriedade das árvores de busca
• Busca: função que busca um elemento na árvore
• Insere: função que insere um novo elemento na árvore
• Retira: função que retira um elemento da árvore
316
![Page 317: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/317.jpg)
www.professoresalgoritmos.com
Operação de busca
• A operação para buscar um elemento na árvore explora a propriedade de ordenação da árvore,
• Desempenho computacional proporcional à sua altura (O(log n)) para árvores balanceadas
317
![Page 318: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/318.jpg)
www.professoresalgoritmos.com
Operação de inserção
• A operação de inserção adiciona um elemento na árvore na posição correta para que a propriedade fundamental seja mantida
• Para inserir um valor v em uma árvore, usamos sua estrutura recursiva e a ordenação especificada na propriedade fundamental– Se a (sub)árvore for vazia, deve ser substituída por uma
árvore cujo único nó (o nó raiz) contém o valor v
– Se a árvore não for vazia, comparamos v ao valor na raiz da árvore e inserimos v na sae ou na sad, conforme resultado da comparação
318
![Page 319: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/319.jpg)
www.professoresalgoritmos.com
Operação de inserção
• É importante lembrar da necessidade de atualizar os ponteiros para as subárvores à esquerda ou à direita
–quando da chamada recursiva da função, pois a função de inserção pode alterar o valor do ponteiro para a raiz da (sub)árvore.
319
![Page 320: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/320.jpg)
www.professoresalgoritmos.com
Operação de inserção
Arv* abb_insere(Arv* a, int v)
{
if(a == NULL)
{
a = (Arv*)malloc(sizeof(Arv));
a->info = v;
a->esq = a->dir = NULL;
}
else if (v < a->info)
a->esq = abb_insere(a->esq, v);
else
a->dir = abb_insere(a->dir, v);
return a;
} 320
![Page 321: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/321.jpg)
www.professoresalgoritmos.com
Operação de remoção
• A operação de remoção permite retirar um determinado elemento da árvore
• Essa operação também deve ter como valor de retorno a eventual nova raiz da árvore, mas sua implementação é mais complexa que a inserção
• Novamente a implementação deve ser recursiva
321
![Page 322: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/322.jpg)
www.professoresalgoritmos.com
Operação de remoção
• Se a árvore for vazia, nada tem de ser feito, pois o elemento não está presente na árvore
• Se a árvore não for vazia, comparamos o valor armazenado no nó raiz ao valor que se deseja retirar da árvore
• Se o valor associado à raiz for maior do que o valor a ser retirado, chamamos a função recursivamente para retirar o elemento da subárvore à esquerda
322
![Page 323: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/323.jpg)
www.professoresalgoritmos.com
Operação de remoção
• Se o valor associado à raiz for menor retiramos o elemento da (sub)árvore à direita
• Finalmente, se o valor associado à raiz for igual, encontramos o elemento a ser retirado e devemos efetuar essa operação
• Portanto, estaremos sempre retirando um nó raiz de uma (sub)árvore
• Nesse caso, existem 3 situações possíveis
323
![Page 324: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/324.jpg)
www.professoresalgoritmos.com
Operação de remoção
• 1ª situação: é quando se deseja retirar uma raiz que é folha que é folha (isto é, uma raiz que não tem filhos)
– Neste caso, basta liberar a memória alocada pelo elemento e ter como valor de retorno a raiz atualizada, que passa a ser NULL
• 2ª situação: acontece quando a raiz a ser retirada possui um único filho
– Ao se retirar esse nó, a raiz da árvore passa a ser o único filho existente
324
![Page 325: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/325.jpg)
www.professoresalgoritmos.com
Operação de remoção
• O caso complicado ocorre quando a raiz a ser retirada tem dois filhos, para poder retirar esse nó da árvore, devemos proceder assim:
– Encontrarmos o elemento que precede a raiz na ordenação. Isso equivale a encontrar o elemento mais à direita da subárvore à esquerda
325
![Page 326: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/326.jpg)
www.professoresalgoritmos.com
Operação de remoção
• Trocamos a informação da raiz com a informação do nó encontrado
• Retiramos da subárvore à esquerda, chamando a função recursivamente, o nó encontrado (que agora contém a informação da raiz que se deseja retirar). Observa-se que retirar o nó mais à direita é trivial, pois ele é um nó folha ou um nó com um único filho (no caso, o filho da direita nunca existe)
326
![Page 327: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/327.jpg)
www.professoresalgoritmos.com
Operação de remoçãoArv* abb_retira(Arv* r, int v)
{
if(r == NULL)
return NULL;
else if(r->info > v)
r->esq = abb_retira(r->esq, v);
else if(r->info < v)
r->dir = abb_retira(r->dir, v);
else //achou o elemento
{
/*elemento sem filhos*/
if(r->esq == NULL && r->dir == NULL)
{
free(r);
r= NULL;
}
//.... 327
![Page 328: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/328.jpg)
www.professoresalgoritmos.com
Operação de remoção
else if(r->esq == NULL)
{
Arv* t = r;
r = r->dir;
free(t);
}
else if(r->dir == NULL)
{
Arv* t = r;
r = r->esq;
free(t);
}
else
{
//.... 328
![Page 329: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/329.jpg)
www.professoresalgoritmos.com
Operação de remoção
Arv* f = r->esq;
while(f->dir != NULL)
{
f = f->dir;
}
r->info = f->info;
f->info = v;
r->esq = abb_retira(r->esq, v);
}
}
return r;
}
329
![Page 330: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/330.jpg)
www.professoresalgoritmos.com
Árvores Balanceadas
• É fácil prever que, após várias operações de inserção/remoção, a árvore tende a ficar desbalanceada
– Essas operações não garantem o balanceamento
• Para que seja possível usar árvores binárias de busca e manter sempre a altura das árvores no mínimo, ou próximo dele
– É necessário um processo de inserção e remoção de nós mais complicado
330
![Page 331: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/331.jpg)
www.professoresalgoritmos.com
Árvores Balanceadas
• E com isso manter as árvores “balanceadas” ou “equilibradas”, tendo as duas subárvoresde cada nó o mesmo peso, isto é, o mesmo número de elementos nas subárvores deve ser igual ou aproximadamente igual
331
![Page 332: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/332.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: ThomsonLearning, 2007.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados. Rio de Janeiro: Elsevier, 2004 – 5ª impressão. Capítulo 17.
332
![Page 333: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/333.jpg)
www.professoresalgoritmos.com
Pesquisa em Memória Primária Tabela Hash
Ivre Marjorie R. Machado
![Page 334: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/334.jpg)
www.professoresalgoritmos.com
Introdução
• Tabelas de dispersão = tabela hash
• Essas estruturas se bem projetadas podem ser usadas para buscar um elemento em ordem constante: O(1).
• Preço pago por essa eficiência:
– será um uso maior de memória,
– mas esse uso excedente não precisa ser tão grande e é proporcional ao número de elementos armazenados.
334
![Page 335: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/335.jpg)
www.professoresalgoritmos.com
Introdução
• Os registros armazenados em uma tabela hashsão diretamente endereçados a partir de uma transformação aritmética sobre a chave de pesquisa
335
![Page 336: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/336.jpg)
www.professoresalgoritmos.com
Introdução
• Limitação da tabela hash:
– Ausência de ordenação
– Ausência de navegação
• Utilização das tabelas hash:
– Banco de dados
– Dicionários
– Tabelas de símbolos
– Sistemas de senha e autenticação
336
![Page 337: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/337.jpg)
www.professoresalgoritmos.com
Exemplo
• Desejamos armazenar dados referentes aos alunos de uma disciplina. Cada aluno é individualmente identificado pelo seu numero de matrícula.
• Podemos usar o número de matrícula como chave de busca do conjunto de alunos armazenados.
• O número de matrícula é dado por uma sequencia de 8 dígitos, – o último dígito representa um dígito de controle e,
portanto, não parte efetiva do número de matrícula.
337
![Page 338: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/338.jpg)
www.professoresalgoritmos.com
Exemplo
• Se 9711234-4 fosse um número de matrícula válido, o último dígito 4, após o hífen, representaria o dígito de controle.
• O número de matrícula efetivo nesse caso seria composto pelo primeiro sete dígitos: 9711234.
338
![Page 339: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/339.jpg)
www.professoresalgoritmos.com
Exemplo
• Para permitir um acesso a qualquer aluno em ordem constante, podemos usar o número de matrícula do aluno como índice de um vetor (vet)
• Se isso for possível, acessamos os dados do aluno cuja matrícula é dada por mat pela indexação do vetor (vet[mat])
• Assim, o acesso ao elemento ocorre em ordem constante, imediata
• Problema: o preço pago para ter acesso rápido é muito grande
339
![Page 340: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/340.jpg)
www.professoresalgoritmos.com
Estrutura do Aluno
struct Aluno
{
int mat;
char nome[81], email[41], turma;
};
340
![Page 341: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/341.jpg)
www.professoresalgoritmos.com
Exemplo
• Como a matrícula é composta por sete dígitos, o número inteiro que conceitualmente representa uma matrícula varia de 0 a 9999999. Portanto, precisamos dimensionar nosso vetor com dez milhões (10.000.000) de elementos. Isso pode ser feito por:
#define MAX 10000000
Aluno vet[MAX];
341
![Page 342: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/342.jpg)
www.professoresalgoritmos.com
Exemplo
• Para acessar o nome do aluno com matrícula mat, basta usar:
vet[mat].nome
• Como a estrutura de cada aluno, no exemplo, ocupa menos de 127 bytes, estamos falando de um gasto de 1.270.000.000 bytes, ou seja, acima de 1 Gbyte de memória
342
![Page 343: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/343.jpg)
www.professoresalgoritmos.com
Exemplo
• Amenizando o problema: podemos usar um vetor de ponteiros em vez de um vetor de estruturas. Desse modo, as posições do vetor que não correspondem a alunos cadastrados teriam valores NULL
• Para cada aluno cadastrado, alocaríamos dinamicamente a estrutura de aluno e armazenaríamos um ponteiro para essa estrutura no vetor
• Para acessar o nome do aluno, agora, vamos usar:
vet[mat]->nome
343
![Page 344: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/344.jpg)
www.professoresalgoritmos.com
Exemplo
• Assim, ao considerar que cada ponteiro ocupa 4 bytes, o gasto excedente de memória seria de, no máximo, aproximadamente, 40 Mbytes.
• Apesar de menor, esse gasto de memória ainda é proibitivo.
• Resolvendo esse problema: e ainda com acesso rápido: usaremos tabelas de dispersão (hash table)
344
![Page 345: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/345.jpg)
www.professoresalgoritmos.com
Tabela Hash
• Idéia central
– Identificar, na chave de busca, quais são as partes significativas
345
![Page 346: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/346.jpg)
www.professoresalgoritmos.com
Tabela Hash
• Os dígitos mais significativos são os 4 últimos seqüenciais
• Dessa maneira, podemos usar um número de matrícula parcial, de acordo com a dimensão que queremos dar a nossa tabela (ou nosso vetor)
• Ex. para dimensionar nossa tabela com apenas 100 elementos, podemos usar os dois últimos dígitos seqüenciais do numero de matrícula
346
![Page 347: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/347.jpg)
www.professoresalgoritmos.com
Tabela Hash
• A tabela pode então ser declarada por:
Aluno* tab[100];
• Para acessar o nome do aluno cujo número de matrícula é dado por mat, usamos como índice da tabela apenas os dois últimos dígitos. Isso poderia se conseguido com a aplicação do operador módulo (%):
vet[mat%100]-> nome
347
![Page 348: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/348.jpg)
www.professoresalgoritmos.com
Tabela Hash
• Dessa forma, o uso de memória excedente é pequeno, e o acesso a um determinado aluno, a partir do número de matrícula, continua imediato
• Problema: Provavelmente, existirão dois ou mais alunos da turma que apresentarão os mesmo dois últimos dígitos no numero da matrícula
348
![Page 349: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/349.jpg)
www.professoresalgoritmos.com
Colisão
• Existe colisão, pois alunos diferentes são mapeados para o mesmo índice da tabela
• Para que a estrutura funcione de maneira adequada, temos que resolver esse problema com o devido tratamento das colisões
• Existem diversos métodos para tratar colisões em tabelas hash, no entanto, não há como eliminar a ocorrência de colisões nas tabelas hash
• O que fazemos é minimizar as colisões, além disso, mesmo com colisões é necessário saber identificar cada elemento da tabela individualmente.
349
![Page 350: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/350.jpg)
www.professoresalgoritmos.com
Função de dispersão
• A função de dispersão (ou função hash) mapeia uma chave de busca em um índice da tabela
• No exemplo, adotamos como função hash a utilização dos dois últimos dígitos do número de matrícula
• Nossa função poderia ser assim:
int hash(int mat)
{
return (mat%100);
}
350
![Page 351: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/351.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Existem diversas estratégias para tratar eventuais colisões que surgem quando duas ou mais chaves de busca são mapeadas para um mesmo índice da tabela hash
• Nas estratégias que serão apresentadas, a tabela de dispersão será representada por um vetor de ponteiros para a estrutura que representa a informação a ser armazenada, no exemplo, Aluno
351
![Page 352: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/352.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Assim, podemos definir um tipo que representa a tabela:
#define N 127
typedef Aluno* Hash[N];
352
![Page 353: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/353.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Nas duas primeiras estratégias a serem apresentadas,
–os elementos que colidem são armazenados em outros índices, ainda não ocupados, da própria tabela
• A escolha da posição ainda não ocupada para armazenar um elemento que colide diferencia as estratégias a serem discutidas
353
![Page 354: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/354.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Uso da posição consecutiva livre
• Na 1ª estratégia, se a função de dispersão mapeia a chave de busca para um índice já ocupado, procuramos o próximo índice livre da tabela para armazenar o novo elemento
• Uma tabela hash nunca terá todos os elementos preenchidos (ocupação acima de 75% eleva o número de colisões)– Portanto, devemos sempre garantir que existirá uma
posição livre na tabela.
354
![Page 355: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/355.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Uso da posição consecutiva livre
* * * * * *
Busca por posição livre
h( x )x
355
![Page 356: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/356.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Uso da posição consecutiva livre
Aluno* hsh_busca(Hash tab, int mat)
{
int h = hash(mat);
while(tab[h] != NULL)
{
if(tab[h]->mat == mat)
{
return tab[h];
}
h = (h+1)% N;
}
return NULL;
}356
![Page 357: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/357.jpg)
www.professoresalgoritmos.com
Função para inserção
Aluno* hsh_insere(Hash tab, int mat, char* n, char* e, char t)
{
int h = hash(mat);
while(tab[h]!= NULL)
{
if(tab[h]->mat == mat)
{
break;
}
h = (h+1)%N;
}
if(tab[h] == NULL) //não encontrou o elemento
{
tab[h]=(Aluno*)malloc(sizeof(Aluno));
tab[h]->mat = mat;
}
//atribui - modifica informação
strcpy(tab[h]->nome, n);
strcpy(tab[h]->email, e);
tab[h]->turma = t;
return tab[h];
}357
![Page 358: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/358.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Uso de uma segunda função de dispersão
• Para evitar a concentração de posições ocupadas na tabela, esta 2ª estratégia faz uma variação na forma de procurar uma posição livre a fim de armazenar o elemento que colidiu.
• Possível segunda função de dispersão:
X = chave de busca
N = dimensão da tabela
358
![Page 359: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/359.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Uso de uma segunda função de dispersão
• De posse dessa nova função, se houver colisão, procuramos uma posição livre na tabela com incrementos da mesma forma que o anterior, dados por . Em vez de tentarmos (h(x) + 1 )%N, tentamos (h(x) + h´(x))% N
359
![Page 360: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/360.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Cuidados:
1. A função de dispersão nunca deve retornar zero, pois isso não faria com que o índice fosse incrementado
2. De preferência, essa função não deve retornar um número divisor da dimensão da tabela, pois isso nos limitaria a procurar uma posição livre em um subconjunto restrito dos índices da tabela
• Se a dimensão da tabela for um número primo, garante-se automaticamente que o resultado da função não será um divisor
360
![Page 361: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/361.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Implementação da função de busca:
int hash2(int mat)
{
return (N - 2 - mat%(N-2));
}
Aluno* hsh_busca(Hash tab, int mat)
{
int h = hash(mat);
int h2 = hash2(mat);
while(tab[h] != NULL)
{
if(tab[h]->mat == mat)
{
return tab[h];
}
h = (h+h2)% N;
}
return NULL;
}
361
![Page 362: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/362.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Uso de listas encadeadas
• Uma estratégia diferente, mas ainda simples, consiste em fazer com que cada elemento da tabela hash represente um ponteiro para uma lista encadeada
• Todos os elementos mapeados para um mesmo índice seriam armazenados na lista encadeada
362
![Page 363: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/363.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Uso de listas encadeadas
* * * * *
* Os índices da tabela que não têm elementos associados representam listas vazias.
363
![Page 364: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/364.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Uso de listas encadeadas
• Com essa estratégia, cada elemento armazenado na tabela será um elemento de uma lista encadeada
• Portanto devemos prever, na estrutura da informação um ponteiro adicional para o próximo elemento da lista
364
![Page 365: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/365.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Uso de listas encadeadas
struct Aluno
{
int mat;
char nome[81];
char email [41];
char turma;
Aluno* prox;
};
365
![Page 366: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/366.jpg)
www.professoresalgoritmos.com
Tratamento de Colisão
• Uso de listas encadeadasAluno* hsh_busca(Hash tab, int mat)
{
int h = hash(mat);
Aluno* a = tab[h];
while(a != NULL)
{
if(a->mat == mat)
{
return a;
}
a = a->prox;
}
return NULL;
}366
![Page 367: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/367.jpg)
www.professoresalgoritmos.com
Aluno* hsh_insere(Hash tab, int mat, char* n, char* e, char t)
{
int h = hash(mat);
Aluno* a = tab[h];
while(a!= NULL)
{
if(a->mat == mat)
{
break;
}
a = a->prox;
}
if(a == NULL) //não encontrou o elemento
{
a =(Aluno*)malloc(sizeof(Aluno));
a->mat = mat;
a->prox = tab[h];
tab[h] = a;
}
//atribui - modifica informação
strcpy(a->nome, n);
strcpy(a->email, e);
a->turma = t;
return a;
}
Função para inserção
367
![Page 368: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/368.jpg)
www.professoresalgoritmos.com
Etapas – Método Tabela Hash
• Duas etapas principais:
1. Computar o valor da função de transformação (hash) a qual transforma a chave de pesquisa em um endereço da tabela
2. Considerando que duas ou mais chaves podem ser transformadas em um mesmo endereço da tabela, é necessário existir um método para lidar com colisões
368
![Page 369: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/369.jpg)
www.professoresalgoritmos.com
Exercícios
1- Considere as seguintes estruturas de dados:
(I)Tabela hash (II)Fila
(III)Arvore de pesquisa (IV)Pilha
Qual ou quais das estruturas acima requer mais do que tempo médio constante para Inserção de um elemento?
(a) Somente(I)
(b) Somente (II)
(c) Somente(III)
(d) Somente (IV)
(e) Todas.
369
![Page 370: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/370.jpg)
www.professoresalgoritmos.com
Exercícios
2- Ao usar o cálculo de endereço ou hashing, geralmente é necessário o uso de um método de tratamento de colisões. Sobre esse método, é correto afirmar:
a) O tratamento de colisões é necessário apenas quando a tabela está cheia e se necessita inserir mais uma chave.
b) O tratamento de colisões é necessário para deter minar o local da chave no momento da inserção na tabela.
c) O tratamento de colisões é necessário quando a tabela está vazia, pois não é possível calcular o endereço diretamente nesse caso.
d) O tratamento de colisões é necessário quando a chave inserida ainda não existir na tabela de endereçamento.
e) O tratamento de colisões é necessário, pois o hashing gera repetição de endereço para diferentes chaves.
370
![Page 371: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/371.jpg)
www.professoresalgoritmos.com
Exercícios
3- (CESPE - 2010 - TRE-MT - Técnico Judiciário - Programação de Sistemas) Em sistema computacional, a forma de armazenar os dados tem papel essencial no tempo e na quantidade de memória necessários à execução de um programa. Em relação a diferentes tipos de estruturas dinâmicas de dados, assinale a opção correta.
a) Pilhas e filas são estruturas de dados em que a inserção e remoção de dados são realizadas em posições previamente especificadas pelo programador.
b) Listas ligadas, também chamadas listas encadeadas, podem ser organizadas de várias maneiras diferentes: simplesmente encadeadas ou duplamente encadeadas; circulares ou não circulares; ordenadas ou não ordenadas; lineares ou não lineares.
371
![Page 372: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/372.jpg)
www.professoresalgoritmos.com
Exercícios
(continuação questão 3)
c) Árvores binárias são estruturas de dados adequadas à representação de hierarquias, e cada nó da árvore tem zero, um ou mais filhos. A relação hierárquica entre seus filhos é definida por sua localização nas subárvores.
d) Tabelas de dispersão ou hash tables apresentam como aspecto negativo a possibilidade de haver colisão na inserção de informações. Entre as técnicas utilizadas para tratar esse problema, inclui-se o endereçamento aberto e o uso de listas encadeadas.
e) Listas de adjacências e matriz de adjacência possuem a desvantagem comum de não ser possível determinar se uma aresta pertence ou não ao grafo.
372
![Page 373: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/373.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: ThomsonLearning, 2007. Capítulo 5.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados. Rio de Janeiro: Elsevier, 2004 – 5ª impressão. Capítulo 18.
373
![Page 374: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/374.jpg)
www.professoresalgoritmos.com
Pesquisa DigitalÁrvore TRIE
Ivre Marjorie R. Machado
![Page 375: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/375.jpg)
www.professoresalgoritmos.com
Introdução
• A pesquisa digital é baseada na representação das chaves como um sequência de caracteres ou de dígitos
375
![Page 376: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/376.jpg)
www.professoresalgoritmos.com
TRIE
• Definida em 1960
• Vem da palavra RETRIEVAL (relacionado a recuperação de informação)
• Usa parte da chave para guiar a pesquisa
• Cada chave é uma sequencia de caracteres, e uma TRIE é organizada ao redor desses caracteres, não ao redor de chaves inteiras
376
![Page 377: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/377.jpg)
www.professoresalgoritmos.com
TRIE
• Cada nó contém informações sobre um ou mais símbolos do Alfabeto
• Alfabeto pode abranger: {0,1}, {A, B, C, D ...} ou {1,2,3,4,....} e mais o caracter nulo (ou branco)
377
![Page 378: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/378.jpg)
www.professoresalgoritmos.com
TRIE
• São usadas para:
– manuseamento de dicionários;
– pesquisas em textos de grande dimensão;
– construção de índices de documentos;
– expressões regulares (padrões de pesquisa).
378
![Page 379: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/379.jpg)
www.professoresalgoritmos.com
TRIE
• O caminho da raiz da TRIE para qualquer outro nó representa um prefixo de uma string
• Em Tries Compactas todos os descendentes diretos do mesmo pai são agrupados
• No último nodo, o último caracter da palavra que estiver sendo procurada deverá ter associado a si (como seu apontador) a posição da palavra no texto
379
![Page 382: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/382.jpg)
www.professoresalgoritmos.com
Conclusão
• Portanto: • Cada nível da árvore que se desce, corresponde
a avançar um elemento na chave• Cada nó pode conter informação sobre um ou
mais símbolos do alfabeto utilizado• Assim: uma dada sequência de arestas pode
formar qualquer palavra (chave) possível com base nesse alfabeto; não existe limite para o tamanho de uma sequência (e portanto para o tamanho de uma chave); as sequências têm comprimento variável
382
![Page 383: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/383.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: ThomsonLearning, 2007. Capítulo 5.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• Celes, Waldemar; Cerqueira, Renato e Rangel, José Lucas. Introdução a Estruturas de Dados. Rio de Janeiro: Elsevier, 2004 – 5ª impressão. Capítulo 18.
383
![Page 384: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/384.jpg)
www.professoresalgoritmos.com
Ordenação
Ivre Marjorie R. Machado
![Page 385: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/385.jpg)
www.professoresalgoritmos.com
Introdução
• A eficiência do manuseio de dados muitas vezes pode ser aumentada se os dados forem dispostos de acordo com algum critério de ordem– Ex.: Dicionários, índices de livros, folhas de
pagamento, contas bancárias, listas de estudantes, etc
• Embora um computador possa manipular um agenda de telefones não-ordenado mais fácil e rapidamente do que um ser humano, é extremamente ineficiente ter um computador processando dados desordenados.
385
![Page 386: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/386.jpg)
www.professoresalgoritmos.com
Introdução
• Sendo assim, frequentemente é necessário ordenar dados antes do processamento
• 1ª Etapa => escolher o critério de ordenação
– A escolha varia de aplicação a aplicação e precisa ser definida pelo usuário
– Ex.: Ordem ascendente e descendente
• 2ª Etapa => como usar o critério escolhido para colocar os dados em ordem
386
![Page 387: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/387.jpg)
www.professoresalgoritmos.com
Introdução
• A ordenação final pode ser obtida de vários modos, mas apenas algumas delas podem ser significativas e eficientes
• Para decidir o melhor método, certos critérios de eficiência devem ser estabelecidos e um método deve ser selecionado para comparar quantitativamente diferentes algoritmos– Propriedades usadas para comparar: número de
comparações e número de movimentos de dados
387
![Page 388: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/388.jpg)
www.professoresalgoritmos.com
Introdução
• Para ordenar um conjunto de dados, eles têm que ser comparados e movidos conforme necessário– A eficiência dessas duas operações depende do
tamanho do conjunto de dados– Vamos calcular o numero de comparações e de
movimentações apenas quando for possível (pior caso, melhor caso e caso médio)
• Aspecto predominante na escolha do algoritmo de ordenação: tempo gasto para ordenar registros em um arquivo
388
![Page 389: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/389.jpg)
www.professoresalgoritmos.com
Introdução
• Um método de ordenação é dito estável
– se a ordem relativa dos itens com chaves iguais mantém-se inalterada pelo processo de ordenação
389
![Page 390: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/390.jpg)
www.professoresalgoritmos.com
Ordenação Bubble Sort (Tipo bolha)
• O algoritmo consome tempo e processamento
• Apesar de simples, não deve ser utilizado com matrizes ou listas muito extensas para evitar lentidão no processamento
• Seu funcionamento é muito simples
• O Algoritmo faz um loop (laço) pelos valores da matriz comparando-os e movendo o maior para a posição anterior
390
![Page 391: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/391.jpg)
www.professoresalgoritmos.com
Ordenação Bubble Sort (Tipo bolha)
• Este método cria uma ordenação decrescente
• Para criar uma ordenação crescente, o algoritmo deverá mover o maior valor para a posição posterior, após o elemento testado
391
![Page 392: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/392.jpg)
www.professoresalgoritmos.com
void bubble_sort(char matriz[], int tamanho)
{
int i, j;
char temp;
for (i=0; i < tamanho; i++)
for(j=0;j < tamanho; j++)
if (matriz[i] < matriz[j])
{
temp = matriz[i];
matriz[i] = matriz[j];
matriz[j] = temp;
}
}
Ordenação Bubble Sort (Tipo bolha)
392
![Page 393: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/393.jpg)
www.professoresalgoritmos.com
Ordenação por Seleção (Select Sort)
• O algoritmo Select Sort também consome processamento e tempo, e assim, também não é adequado em matrizes e listas muito grandes
• Ele trabalha selecionando um elemento como o primeiro da lista, por exemplo.
• É realizada uma pesquisa na lista para encontrar o valor mínimo e este é então posicionado no lugar do elemento pesquisado.
393
![Page 394: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/394.jpg)
www.professoresalgoritmos.com
Ordenação por Seleção (Select Sort)
• Funcionamento:
1- Selecione o menor item do vetor
2- Troque-o com o item que está na primeira posição do vetor
– Repita essas duas operações com os n-1 itens restantes, depois com os n-2 itens, até que reste apenas um elemento
394
![Page 395: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/395.jpg)
www.professoresalgoritmos.com
void ordena(char v[], int n)
{
for(int i=0; i<n-1; i++)
{
int min = i;
for(int j=i+1; j<n; j++)
{
if(v[j] < v[min])
{
min = j;
}
//troca
int aux = v[min];
v[min] = v[i];
v[i] = aux;
}
}
}
Ordenação por Seleção (Select Sort)
Complexidade O(n²)
395
![Page 396: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/396.jpg)
www.professoresalgoritmos.com
Ordenação por Seleção (Select Sort)
• Observações:
• O fato de o arquivo já está ordenado não ajuda em nada, pois o custo continua quadrático
• O algoritmo não é estável, pois ele nem sempre deixa os registros com chaves iguais na mesma posição
396
![Page 397: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/397.jpg)
www.professoresalgoritmos.com
Ordenação por Seleção (Select Sort)Exemplo
1 2 3 4 5 6
Chaves iniciais O R D E N A
i = 1 A R D E N O
i =2 A D R E N O
i = 3 A D E R N O
i = 4 A D E N R O
i = 5 A D E N O R397
![Page 398: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/398.jpg)
www.professoresalgoritmos.com
Ordenação por Seleção (Select Sort)Exemplo agora com números
1 2 3 4 5 6
Chaves iniciais 8 1 4 9 2 3
i = 1 1 8 4 9 2 3
i =2 1 2 4 9 8 3
i = 3 1 2 3 9 8 4
i = 4 1 2 3 4 8 9
i = 5 1 2 3 4 8 9398
![Page 399: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/399.jpg)
www.professoresalgoritmos.com
Ordenação por Inserção
• Método preferido dos jogadores de cartas
• Em cada passo, a partir de i = 2, o i-ésimo item da sequência fonte é apanhado e transferido para a sequência destino, sendo inserido no seu lugar apropriado
• Exemplo: considere que as chaves serão inseridas nessa ordem: O R D E N A
399
![Page 400: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/400.jpg)
www.professoresalgoritmos.com
Ordenação por Inserção
• Funcionamento:
1- A colocação do item no seu lugar apropriado na sequência destino é realizada movendo-se itens com chaves maiores para a direita e então inserindo o item na posição deixada vazia.
400
![Page 401: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/401.jpg)
www.professoresalgoritmos.com
void insertionSort(char v[], int n)
{
for (int i = 1; i < n; i++)
{
int x = v[i];
for (int j = i; j > 0 && x < v[j - 1]; j--)
v[j] = v[j-1];
v[j] = x;
}
}
Ordenação por Inserção
401
![Page 402: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/402.jpg)
www.professoresalgoritmos.com
Ordenação por InserçãoExemplo
1 2 3 4 5 6
Chaves iniciais O R D E N A
i = 2 O R D E N A
i =3 D O R E N A
i = 4 D E O R N A
i = 5 D E N O R A
i = 6 A D E N O R402
![Page 403: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/403.jpg)
www.professoresalgoritmos.com
Ordenação por Inserção
• Observação:
• O método de ordenação por inserção é estável,
–pois ele deixa os registros com chaves iguais na mesmo posição relativa
403
![Page 404: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/404.jpg)
www.professoresalgoritmos.com
Ordenação Shellsort
• Shell (1939) propôs uma extensão do algoritmo de ordenação por inserção
• O método da inserção troca itens adjacentes quando está procurando o ponto de inserção as sequência destino
• Se o menor item estiver na posição mais à direita no vetor, então o número de comparações e movimentações é igual a n-1para encontrar o seu ponto de inserção
404
![Page 405: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/405.jpg)
www.professoresalgoritmos.com
Ordenação Shellsort
• A ordenação Shell Sort compara os elementos de uma matriz que estão separados por uma distância específica chamada gap até que os elementos comparados com o gap corrente estejam em ordem
• O gap é então é dividido por 2 e o processo continua, até que o gap seja igual a 1 e nenhuma divisão possa mais ser feita (com um valor inteiro como resultado)
• Ao final do processo, a matriz estará ordenada
405
![Page 406: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/406.jpg)
www.professoresalgoritmos.com
void shell_sort(int matriz[], int tamanho)
{
int i, gap, temp, ret;
gap = tamanho/2;
do
{
do
{
ret = 0;
for(i=0; i<(tamanho-gap);i++)
{
if(matriz[i]>matriz[i+gap])
{
temp = matriz[i];
matriz[i]=matriz[i+gap];
matriz[i+gap]=temp;
ret = 1;
}
}
}while(ret == 1);
}while(gap = gap/2);
}
Ordenação Shell Sort
406
![Page 407: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/407.jpg)
www.professoresalgoritmos.com
Ordenação Shell sortExemplo
1 2 3 4 5 6
Chaves iniciais O R D E N A
gap = 3 E R D O N A
E N D O R A
E N A O R D
407
![Page 408: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/408.jpg)
www.professoresalgoritmos.com
Ordenação Shell sortExemplo
1 2 3 4 5 6
Chaves iniciais E N A O R D
gap = 1 E N A O R D
A E N O R D
A E N O R D
A E N O R D
A D E N O R
408
![Page 409: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/409.jpg)
www.professoresalgoritmos.com
Ordenação Shellsort
• Este método se parece muito com o algoritmo tipo bolha (Bubble Sort) somado ao tipo seleção (Select Sort), com a diferença de ser mais rápido e podermos escolher quais elementos da matriz serão ordenados
• Assim, este algoritmo pode ser considerado um dos que consome menor processamento e também tempo de execução
409
![Page 410: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/410.jpg)
www.professoresalgoritmos.com
Ordenação Shellsort
• É uma ótima opção para arquivos de tamanho moderado
– mesmo porque sua implementação é simples e requer uma quantidade de código pequena
– Existem métodos mais eficientes, mas são também muito mais complicados para implementar
410
![Page 411: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/411.jpg)
www.professoresalgoritmos.com
Ordenação Quicksort
• Este algoritmo seleciona o valor central da lista como um separador (pivô)
• A partir daí ele cria duas listas:
– a primeira com os valores menores que o separador
– e outra com os valores maiores ou iguais ao separador.
411
![Page 412: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/412.jpg)
www.professoresalgoritmos.com
Ordenação Quicksort
• A seguir a ordenação chama a si mesma recursivamente, sempre selecionando um novo separador nas listas, e criando novas listas menores até que estas tenham apenas um único elemento
• O algoritmo então reposiciona os valores das novas listas na lista original
• Ao final do algoritmo uma matriz (lista) estará ordenada
412
![Page 413: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/413.jpg)
www.professoresalgoritmos.com
void quick_sort(int matriz[], int primeiro,
int ultimo)
{
int temp, high, low, separador, temp1;
low = primeiro;
high = ultimo;
separador = matriz[(primeiro+ultimo)/2];
do
{
while(matriz[low]<separador)
low++;
while(matriz[high]>separador)
high--;
Ordenação Quicksort
413
![Page 414: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/414.jpg)
www.professoresalgoritmos.com
if(low<=high)
{
temp = matriz[low];
matriz[low++] = matriz[high];
matriz[high--]=temp;
}
}while(low<=high);
if(primeiro<high)
quick_sort(matriz, primeiro, high);
if(low<ultimo)
quick_sort(matriz, low, ultimo);
}
Ordenação Quicksort
414
![Page 415: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/415.jpg)
www.professoresalgoritmos.com
Ordenação QuicksortExemplo
1 2 3 4 5 6
O R D E N A
A D R E N O
A D E R N O
A D E N R O
A D E N O R
415
![Page 417: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/417.jpg)
www.professoresalgoritmos.com
Ordenação Quicksort
• Note que as novas “listas” são geradas levando em conta a posição da lista anterior
– Assim o programa saberá exatamente qual a posição de cada valor
• Observe que neste método, o consumo de memória é bem grande
• Em média o tempo de execução do quicksort é O(n log n)
417
![Page 418: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/418.jpg)
www.professoresalgoritmos.com
Ordenação Mergesort
• Complexidade: O(n log n)
• O algoritmo é baseado na abordagem de desenvolvimento dividir e conquistar. Ainda, explora a recursividade, o que o torna bastante intuitivo
418
![Page 419: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/419.jpg)
www.professoresalgoritmos.com
Ordenação Mergesort
• Idéia: dividir a sequência de entrada em duas subsequências. Então, realiza-se a ordenação das duas subsequências, de forma recursiva
• Por fim, intercala-se as sequênciasordenadas para obter o resultado final
419
![Page 420: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/420.jpg)
www.professoresalgoritmos.com
Ordenação Mergesort
• O algoritmo consiste em intercalar pares de sequências de um item para formar sequênciasordenadas de comprimento 2
• Intercalar pares de sequências de comprimento 2 para formar sequências ordenadas de comprimento 4 e assim por diante...
• … até duas sequências de comprimento n/2 serem intercaladas para formar a sequênciaordenada final, de comprimento n.
420
![Page 421: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/421.jpg)
www.professoresalgoritmos.com
Ordenação Mergesort
5 2 4 7 1 3 2 6
2 5 4 7 1 3 2 6
2 4 5 7 1 2 3 6
1 2 2 3 4 5 6 7
421
![Page 422: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/422.jpg)
www.professoresalgoritmos.com
Ordenação Heapsort
• Complexidade: O(n log n)
• O algoritmo leva esse nome por utilizar, na sua solução, uma estrutura do tipo heap
• Um heap é um arranjo (sequência) representado por uma árvore binária(completa)
422
![Page 423: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/423.jpg)
www.professoresalgoritmos.com
Ordenação Heapsort
• Para construí-lo, é necessário conhecer
– o comprimento do arranjo a ser representado (número de elementos)
– e o tamanho do heap, que é definido como o número de elementos no heap armazenados dentro do arranjo A
423
![Page 424: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/424.jpg)
www.professoresalgoritmos.com
Ordenação Heapsort
• O algoritmo de ordenação Heapsort utiliza um heap máximo, isto é, para cada nó diferente da raiz, seu valor deve ser menor que o valor do nó pai
• Para que a ordenação ocorra, primeiro é construído um heap máximo que represente a sequência
• O heap é construído de baixo pra cima, a partir do penúltimo nível, subindo os valores maiores para os níveis superiores.
424
![Page 425: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/425.jpg)
www.professoresalgoritmos.com
Ordenação Heapsort
• A ordenação de heap usa o heap, uma árvore binária com as seguintes propriedades:
– O valor de cada nó não é menor do que os valores de cada um de seus filhos
– A árvore é perfeitamente balanceada e as folhas no último nível estão todas nas posições mais a esquerda
425
![Page 426: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/426.jpg)
www.professoresalgoritmos.com
Ordenação Heapsort
• Etapas:
1- na primeira fase a matriz é transformada em um heap
2- essa fase começa depois que a heap é construída, vamos criar uma matriz e trocar o último valor com o primeiro
Essas etapas irão repetir até que a matriz esteja toda ordenada
426
![Page 427: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/427.jpg)
www.professoresalgoritmos.com
Ordenação Heapsort
Procedimento HeapSort (A vetor, tamA, tam_heap inteiro)Início
declare i inteiro;{Constrói o heap que representa o arranjo}para i de tamA até 2 passo -1 faça
Troca A[1] por A[i];tam_heap = tam_heap - 1;Reorganiza o heap;
fim paraFim
427
![Page 429: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/429.jpg)
www.professoresalgoritmos.com
1- Transforma a matriz em um heap
1º
429
![Page 430: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/430.jpg)
www.professoresalgoritmos.com
1- Transforma a matriz em um heap
2º
430
![Page 431: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/431.jpg)
www.professoresalgoritmos.com
1- Transforma a matriz em um heap
3º
431
![Page 432: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/432.jpg)
www.professoresalgoritmos.com
1- Transforma a matriz em um heap
4º
432
![Page 434: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/434.jpg)
www.professoresalgoritmos.com
2- Construção de uma matriz troca entre o primeiro e último valor
15 12 6 11 10 2 3 1 8
8 12 6 11 10 2 3 1 15
434
![Page 435: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/435.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
1º
435
![Page 436: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/436.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
2º
436
![Page 438: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/438.jpg)
www.professoresalgoritmos.com
2- Construção de uma matriz troca entre o primeiro e último valor
12 11 6 8 10 2 3 1 15
1 11 6 8 10 2 3 12 15
438
![Page 439: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/439.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
1º
439
![Page 440: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/440.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
2º
440
![Page 442: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/442.jpg)
www.professoresalgoritmos.com
2- Construção de uma matriz troca entre o primeiro e último valor
11 10 6 8 1 2 3 12 15
3 10 6 8 1 2 11 12 15
442
![Page 443: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/443.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
1º
443
![Page 444: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/444.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
2º
444
![Page 446: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/446.jpg)
www.professoresalgoritmos.com
2- Construção de uma matriz troca entre o primeiro e último valor
10 8 6 3 1 2 11 12 15
2 8 6 3 1 10 11 12 15
446
![Page 447: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/447.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
1º
447
![Page 448: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/448.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
2º
448
![Page 450: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/450.jpg)
www.professoresalgoritmos.com
2- Construção de uma matriz troca entre o primeiro e último valor
8 3 6 2 1 10 11 12 15
1 3 6 2 8 10 11 12 15
450
![Page 451: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/451.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
1º
451
![Page 453: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/453.jpg)
www.professoresalgoritmos.com
2- Construção de uma matriz troca entre o primeiro e último valor
6 3 1 2 8 10 11 12 15
2 3 1 6 8 10 11 12 15
453
![Page 454: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/454.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
1º
454
![Page 456: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/456.jpg)
www.professoresalgoritmos.com
2- Construção de uma matriz troca entre o primeiro e último valor
3 2 1 6 8 10 11 12 15
1 2 3 6 8 10 11 12 15
456
![Page 457: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/457.jpg)
www.professoresalgoritmos.com
Monto a árvore novamente e transformo em um heap
1º
457
![Page 459: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/459.jpg)
www.professoresalgoritmos.com
Montando a matrizpercebemos que ela já está ordenada:
1 2 3 6 8 10 11 12 15
459
![Page 460: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/460.jpg)
www.professoresalgoritmos.com
*Comparação entre os métodos de ordenação
500 5.000 10.000 30.000
Inserção 11,3 87 161 -
Seleção 16,2 124 228 -
Shellsort 1,2 1,6 1,7 2
Quicksort 1 1 1 1
Heapsort 1,5 1,6 1,6 1,6
Ordem aleatória dos registros
* A tabela apresenta uma comparação do tempo total real para ordenar arranjos com 500, 5.000, 10.000 e 30.000 registros
460
![Page 461: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/461.jpg)
www.professoresalgoritmos.com
Comparação entre os métodos de ordenação
500 5.000 10.000 30.000
Inserção 1 1 1 1
Seleção 128 1.524 3.066 -
Shellsort 3,9 6,8 7,3 8,1
Quicksort 4,1 6,3 6,8 7,1
Heapsort 12,2 20,8 22,4 24,6
Ordem ascendente dos registros
461
![Page 462: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/462.jpg)
www.professoresalgoritmos.com
Comparação entre os métodos de ordenação
500 5.000 10.000 30.000
Inserção 40,3 305 575 -
Seleção 29,3 221 417 -
Shellsort 1,5 1,5 1,6 1,6
Quicksort 1 1 1 1
Heapsort 2,5 2,7 2,7 2,9
Ordem descendente dos registros
462
![Page 463: Apostila aed](https://reader034.vdocuments.net/reader034/viewer/2022050707/5483329ab07959520c8b49cb/html5/thumbnails/463.jpg)
www.professoresalgoritmos.com
Referência Bibliográfica
• ZIVIANI, Nivio. Projeto de Algoritmos com implementações em Java e C++. São Paulo: Thomson Learning, 2007.
• CORMEN, Thomas. Algoritmos: teoria e prática. Campus, 2002.
• DROZDEK, Adam. Estrutura de dados e algoritmos em c++. São Paulo: Cengage Learning, 2009. Capítulo 9.
• Notas de aula da Prof. Raquel Marcia Müller. Disponível em: http://www.comp.uems.br/Members/rmmuller/pt_aedii/Aula4-Ordenacao.pdf
463